fix a few more deprecation-related items

Author: JeffBezanson

base/abstractarray.jl

@@ -2012,6 +2012,9 @@ julia> map(+, [1, 2, 3], [10, 20, 30])
 """
 map(f, A) = collect(Generator(f,A))
 
+map(f, ::AbstractDict) = error("map is not defined on dictionaries")
+map(f, ::AbstractSet) = error("map is not defined on sets")
+
 ## 2 argument
 function map!(f::F, dest::AbstractArray, A::AbstractArray, B::AbstractArray) where F
     for (i, j, k) in zip(eachindex(dest), eachindex(A), eachindex(B))

base/broadcast.jl

@@ -602,7 +602,7 @@ Base.RefValue{String}("hello")
 ```
 """
 broadcastable(x::Union{Symbol,AbstractString,Function,UndefInitializer,Nothing,RoundingMode,Missing,Val}) = Ref(x)
-broadcastable(x::Ptr) = Ref{Ptr}(x) # Cannot use Ref(::Ptr) until ambiguous deprecation goes through
+broadcastable(x::Ptr) = Ref(x)
 broadcastable(::Type{T}) where {T} = Ref{Type{T}}(T)
 broadcastable(x::Union{AbstractArray,Number,Ref,Tuple,Broadcasted}) = x
 # Default to collecting iterables — which will error for non-iterables

base/client.jl

@@ -387,7 +387,6 @@ end
 baremodule MainInclude
 include(fname::AbstractString) = Main.Base.include(Main, fname)
 eval(x) = Core.eval(Main, x)
-Main.Base.@deprecate eval(m, x) Core.eval(m, x)
 end
 
 """

base/compiler/abstractinterpretation.jl

@@ -6,8 +6,6 @@
 
 const CoreNumType = Union{Int32, Int64, Float32, Float64}
 
-const DEPRECATED_SYM = Symbol("deprecated.jl")
-
 const _REF_NAME = Ref.body.name
 
 #########
@@ -199,10 +197,6 @@ function abstract_call_method_with_const_args(@nospecialize(f), argtypes::Vector
 end
 
 function abstract_call_method(method::Method, @nospecialize(sig), sparams::SimpleVector, sv::InferenceState)
-    # TODO: remove with 0.7 deprecations
-    if method.file === DEPRECATED_SYM && method.sig == (Tuple{Type{T},Any} where T)
-        return Any, false, nothing
-    end
     if method.name === :depwarn && isdefined(Main, :Base) && method.module === Main.Base
         return Any, false, nothing
     end

base/loading.jl

@@ -1070,7 +1070,6 @@ function evalfile(path::AbstractString, args::Vector{String}=String[])
         Expr(:toplevel,
              :(const ARGS = $args),
              :(eval(x) = $(Expr(:core, :eval))(__anon__, x)),
-             :(@deprecate eval(m, x) Core.eval(m, x)),
              :(include(x) = $(Expr(:top, :include))(__anon__, x)),
              :(include($path))))
 end

base/task.jl

@@ -178,8 +178,7 @@ function task_local_storage(body::Function, key, val)
 end
 
 # NOTE: you can only wait for scheduled tasks
-# TODO: rename to wait for 1.0
-function _wait(t::Task)
+function wait(t::Task)
     if !istaskdone(t)
         if t.donenotify === nothing
             t.donenotify = Condition()
@@ -193,16 +192,14 @@ function _wait(t::Task)
     end
 end
 
-_wait(not_a_task) = wait(not_a_task)
-
 """
     fetch(t::Task)
 
 Wait for a Task to finish, then return its result value. If the task fails with an
 exception, the exception is propagated (re-thrown in the task that called fetch).
 """
 function fetch(t::Task)
-    _wait(t)
+    wait(t)
     task_result(t)
 end
 
@@ -213,7 +210,7 @@ function sync_end(refs)
     c_ex = CompositeException()
     for r in refs
         try
-            _wait(r)
+            wait(r)
         catch ex
             if !isa(r, Task) || (isa(r, Task) && !istaskfailed(r))
                 rethrow(ex)

src/ast.scm

@@ -378,25 +378,20 @@
     (symbol (string.sub str 1 (length str)))))
 
 ; convert '.xx to 'xx, and (|.| _ '.xx) to (|.| _ 'xx), and otherwise return #f
-(define (maybe-undotop e)
+;; raise an error for using .op as a function name
+(define (check-dotop e)
   (if (symbol? e)
       (let ((str (string e)))
         (if (and (eqv? (string.char str 0) #\.)
                  (not (eq? e '|.|))
                  (not (eqv? (string.char str 1) #\.)))
-            (symbol (string.sub str 1 (length str)))
-            #f))
+            (error (string "invalid function name \"" e "\""))))
       (if (pair? e)
           (if (eq? (car e) '|.|)
-              (let ((op (maybe-undotop (caddr e))))
-                (if op
-                    (list '|.| (cadr e) op)
-                    #f))
+              (check-dotop (caddr e))
               (if (quoted? e)
-                  (let ((op (maybe-undotop (cadr e))))
-                    (if op (list (car e) op) #f))
-                  #f))
-          #f)))
+                  (check-dotop (cadr e))))))
+  e)
 
 (define (vararg? x) (and (pair? x) (eq? (car x) '...)))
 (define (varargexpr? x) (and

src/julia-parser.scm

@@ -1927,6 +1927,12 @@
         (else
          (list (=-to-kw e)))))
 
+(define invalid-identifier? (Set (list* '.... '? '|.'| syntactic-operators)))
+
+(define-macro (check-identifier ex)
+  `(if (invalid-identifier? ,ex)
+       (error (string "invalid identifier name \"" ,ex "\""))))
+
 (define (parse-paren s (checked #t)) (car (parse-paren- s checked)))
 
 ;; return (expr . arglist) where arglist is #t iff this isn't just a parenthesized expr
@@ -2220,12 +2226,6 @@
      ;; process escape sequences using lisp read
      (read (open-input-string (string #\" s #\"))))))
 
-(define invalid-identifier? (Set (list* '.... '? '|.'| syntactic-operators)))
-
-(define-macro (check-identifier ex)
-  `(if (invalid-identifier? ,ex)
-       (error (string "invalid identifier name \"" ,ex "\""))))
-
 ;; parse numbers, identifiers, parenthesized expressions, lists, vectors, etc.
 (define (parse-atom s (checked #t))
   (let ((t (require-token s)))

src/julia-syntax.scm

@@ -240,24 +240,6 @@
            (pair? (caddr e)) (memq (car (caddr e)) '(quote inert))
            (symbol? (cadr (caddr e))))))
 
-;; e.g. Base.(:+) is deprecated in favor of Base.:+
-(define (deprecate-dotparen e)
-  (if (and (length= e 3) (eq? (car e) '|.|)
-           (or (atom? (cadr e)) (sym-ref? (cadr e)))
-           (length= (caddr e) 2) (eq? (caaddr e) 'tuple)
-           (pair? (cadr (caddr e))) (memq (caadr (caddr e)) '(quote inert)))
-      (let* ((s_ (cdadr (caddr e)))
-             (s (if (symbol? s_) s_
-                    (if (and (length= s_ 1) (symbol? (car s_))) (car s_) #f))))
-        (if s
-            (let ((newe (list (car e) (cadr e) (cadr (caddr e))))
-                  (S (deparse `(quote ,s)))) ; #16295
-              (syntax-deprecation (string (deparse (cadr e)) ".(" S ")")
-                                  (string (deparse (cadr e)) "." S) #f)
-              newe)
-            e))
-      e))
-
 ;; convert final (... x) to (curly Vararg x)
 (define (dots->vararg a)
   (if (null? a) a
@@ -1019,20 +1001,13 @@
           ((eq? (car name) 'call)
            (let* ((head    (cadr name))
                   (argl    (cddr name))
-                  (name    (deprecate-dotparen head))
-                  (op (let ((op_ (maybe-undotop name))) ; handle .op -> broadcast deprecation
-                        (if op_
-                            (syntax-deprecation (string "function " (deparse name) "(...)")
-                                                (string "function Base.broadcast(::typeof(" (deparse op_) "), ...)") #f))
-                        op_))
-                  (name (if op '(|.| Base (inert broadcast)) name))
+                  (name    (check-dotop head))
                   (annotations (map (lambda (a) `(meta ,(cadr a) ,(arg-name (caddr a))))
                                     (filter nospecialize-meta? argl)))
                   (body (insert-after-meta (caddr e) annotations))
                   (argl (map (lambda (a)
                                (if (nospecialize-meta? a) (caddr a) a))
                              argl))
-                  (argl (if op (cons `(|::| (call (core Typeof) ,op)) argl) argl))
                   (raw-typevars (or where '()))
                   (sparams (map analyze-typevar raw-typevars))
                   (adj-decl (lambda (n) (if (and (decl? n) (length= n 2))
@@ -1893,15 +1868,11 @@
          ((|.|)
           ;; a.b =
           (let* ((a   (cadr lhs))
-                 (b_  (caddr lhs))
-                 (b   (if (and (length= b_ 2) (eq? (car b_) 'tuple))
-                          (begin
-                            (syntax-deprecation
-                             (string (deparse a) ".(" (deparse (cadr b_)) ") = ...")
-                             (string "setfield!(" (deparse a) ", " (deparse (cadr b_)) ", ...)") #f)
-                            (cadr b_))
-                          b_))
+                 (b  (caddr lhs))
                  (rhs (caddr e)))
+            (if (and (length= b 2) (eq? (car b) 'tuple))
+                (error (string "invalid syntax \""
+                               (string (deparse a) ".(" (deparse (cadr b)) ") = ...") "\"")))
             (let ((aa (if (symbol-like? a) a (make-ssavalue)))
                   (bb (if (or (atom? b) (symbol-like? b) (and (pair? b) (quoted? b)))
                           b (make-ssavalue)))

stdlib/Distributed/src/cluster.jl

@@ -419,7 +419,7 @@ function addprocs_locked(manager::ClusterManager; kwargs...)
         end
     end
 
-    Base._wait(t_launch)      # catches any thrown errors from the launch task
+    Base.wait(t_launch)      # catches any thrown errors from the launch task
 
     # Since all worker-to-worker setups may not have completed by the time this
     # function returns to the caller, send the complete list to all workers.