replace ANY with @nospecialize annotation. part of #11339

NEWS.md

@@ -13,6 +13,9 @@ Language changes
  * The syntax `1.+2` is deprecated, since it is ambiguous: it could mean either
  `1 .+ 2` (the current meaning) or `1. + 2` ([#19089]).
 
+ * Declaring arguments as `x::ANY` to avoid specialization has been replaced
+ by `@nospecialize x`, which needs to be imported from `Base`. ([#22666]).
+
 Breaking changes
 ----------------
 

base/array.jl

@@ -238,7 +238,7 @@ getindex(::Type{T}, x) where {T} = (@_inline_meta; a = Array{T,1}(1); @inbounds
 getindex(::Type{T}, x, y) where {T} = (@_inline_meta; a = Array{T,1}(2); @inbounds (a[1] = x; a[2] = y); a)
 getindex(::Type{T}, x, y, z) where {T} = (@_inline_meta; a = Array{T,1}(3); @inbounds (a[1] = x; a[2] = y; a[3] = z); a)
 
-function getindex(::Type{Any}, vals::ANY...)
+function getindex(::Type{Any}, @nospecialize vals...)
  a = Array{Any,1}(length(vals))
  @inbounds for i = 1:length(vals)
  a[i] = vals[i]
@@ -486,9 +486,9 @@ function _collect_indices(indsA, A)
 end
 
 if isdefined(Core, :Inference)
- _default_eltype(itrt::ANY) = Core.Inference.return_type(first, Tuple{itrt})
+ _default_eltype(@nospecialize itrt) = Core.Inference.return_type(first, Tuple{itrt})
 else
- _default_eltype(itr::ANY) = Any
+ _default_eltype(@nospecialize itr) = Any
 end
 
 _array_for(::Type{T}, itr, ::HasLength) where {T} = Array{T,1}(Int(length(itr)::Integer))
@@ -694,7 +694,7 @@ function push!(a::Array{T,1}, item) where T
  return a
 end
 
-function push!(a::Array{Any,1}, item::ANY)
+function push!(a::Array{Any,1}, @nospecialize item)
  _growend!(a, 1)
  arrayset(a, item, length(a))
  return a

base/associative.jl

@@ -461,7 +461,7 @@ function sizehint!(t::ObjectIdDict, newsz)
  rehash!(t, newsz)
 end
 
-function setindex!(t::ObjectIdDict, v::ANY, k::ANY)
+function setindex!(t::ObjectIdDict, @nospecialize(v), @nospecialize(k))
  if t.ndel >= ((3*length(t.ht))>>2)
  rehash!(t, max(length(t.ht)>>1, 32))
  t.ndel = 0
@@ -470,22 +470,22 @@ function setindex!(t::ObjectIdDict, v::ANY, k::ANY)
  return t
 end
 
-get(t::ObjectIdDict, key::ANY, default::ANY) =
+get(t::ObjectIdDict, @nospecialize(key), @nospecialize(default)) =
  ccall(:jl_eqtable_get, Any, (Any, Any, Any), t.ht, key, default)
 
-function pop!(t::ObjectIdDict, key::ANY, default::ANY)
+function pop!(t::ObjectIdDict, @nospecialize(key), @nospecialize(default))
  val = ccall(:jl_eqtable_pop, Any, (Any, Any, Any), t.ht, key, default)
  # TODO: this can underestimate `ndel`
  val === default || (t.ndel += 1)
  return val
 end
 
-function pop!(t::ObjectIdDict, key::ANY)
+function pop!(t::ObjectIdDict, @nospecialize(key))
  val = pop!(t, key, secret_table_token)
  val !== secret_table_token ? val : throw(KeyError(key))
 end
 
-function delete!(t::ObjectIdDict, key::ANY)
+function delete!(t::ObjectIdDict, @nospecialize(key))
  pop!(t, key, secret_table_token)
  t
 end

base/base.jl

@@ -54,9 +54,9 @@ mutable struct MethodError <: Exception
  f
  args
  world::UInt
- MethodError(f::ANY, args::ANY, world::UInt) = new(f, args, world)
+ MethodError(@nospecialize(f), @nospecialize(args), world::UInt) = new(f, args, world)
 end
-MethodError(f::ANY, args::ANY) = MethodError(f, args, typemax(UInt))
+MethodError(@nospecialize(f), @nospecialize(args)) = MethodError(f, args, typemax(UInt))
 
 """
  EOFError()
@@ -122,7 +122,7 @@ ccall(:jl_get_system_hooks, Void, ())
 ==(w::WeakRef, v) = isequal(w.value, v)
 ==(w, v::WeakRef) = isequal(w, v.value)
 
-function finalizer(o::ANY, f::ANY)
+function finalizer(@nospecialize(o), @nospecialize(f))
  if isimmutable(o)
  error("objects of type ", typeof(o), " cannot be finalized")
  end
@@ -138,8 +138,8 @@ function finalizer(o::T, f::Ptr{Void}) where T
  Core.getptls(), o, f)
 end
 
-finalize(o::ANY) = ccall(:jl_finalize_th, Void, (Ptr{Void}, Any,),
- Core.getptls(), o)
+finalize(@nospecialize(o)) = ccall(:jl_finalize_th, Void, (Ptr{Void}, Any,),
+  Core.getptls(), o)
 
 gc(full::Bool=true) = ccall(:jl_gc_collect, Void, (Int32,), full)
 gc_enable(on::Bool) = ccall(:jl_gc_enable, Int32, (Int32,), on) != 0

base/boot.jl

@@ -183,16 +183,23 @@ else
 end
 
 function Typeof end
-(f::typeof(Typeof))(x::ANY) = isa(x,Type) ? Type{x} : typeof(x)
+ccall(:jl_toplevel_eval_in, Any, (Any, Any),
+ Core, quote
+ (f::typeof(Typeof))(x) = ($(_expr(:meta,:nospecialize,:x)); isa(x,Type) ? Type{x} : typeof(x))
+ end)
+
+macro nospecialize(x)
+ _expr(:meta, :nospecialize, x)
+end
+
+Expr(@nospecialize args...) = _expr(args...)
 
 abstract type Exception end
 mutable struct ErrorException <: Exception
  msg::AbstractString
  ErrorException(msg::AbstractString) = new(msg)
 end
 
-Expr(args::ANY...) = _expr(args...)
-
 macro _noinline_meta()
  Expr(:meta, :noinline)
 end
@@ -201,8 +208,8 @@ struct BoundsError <: Exception
  a::Any
  i::Any
  BoundsError() = new()
- BoundsError(a::ANY) = (@_noinline_meta; new(a))
- BoundsError(a::ANY, i) = (@_noinline_meta; new(a,i))
+ BoundsError(@nospecialize(a)) = (@_noinline_meta; new(a))
+ BoundsError(@nospecialize(a), i) = (@_noinline_meta; new(a,i))
 end
 struct DivideError <: Exception end
 struct OverflowError <: Exception end
@@ -218,8 +225,8 @@ struct InterruptException <: Exception end
 struct DomainError <: Exception
  val
  msg
- DomainError(val::ANY) = (@_noinline_meta; new(val))
- DomainError(val::ANY, msg::ANY) = (@_noinline_meta; new(val, msg))
+ DomainError(@nospecialize(val)) = (@_noinline_meta; new(val))
+ DomainError(@nospecialize(val), @nospecialize(msg)) = (@_noinline_meta; new(val, msg))
 end
 mutable struct TypeError <: Exception
  func::Symbol
@@ -232,7 +239,7 @@ struct InexactError <: Exception
  T::Type
  val
 
- InexactError(f::Symbol, T::ANY, val::ANY) = (@_noinline_meta; new(f, T, val))
+ InexactError(f::Symbol, @nospecialize(T), @nospecialize(val)) = (@_noinline_meta; new(f, T, val))
 end
 
 abstract type DirectIndexString <: AbstractString end
@@ -244,16 +251,16 @@ getptls() = ccall(:jl_get_ptls_states, Ptr{Void}, ())
 
 include(m::Module, fname::String) = ccall(:jl_load_, Any, (Any, Any), m, fname)
 
-eval(e::ANY) = eval(Main, e)
-eval(m::Module, e::ANY) = ccall(:jl_toplevel_eval_in, Any, (Any, Any), m, e)
+eval(@nospecialize(e)) = eval(Main, e)
+eval(m::Module, @nospecialize(e)) = ccall(:jl_toplevel_eval_in, Any, (Any, Any), m, e)
 
-kwfunc(f::ANY) = ccall(:jl_get_keyword_sorter, Any, (Any,), f)
+kwfunc(@nospecialize(f)) = ccall(:jl_get_keyword_sorter, Any, (Any,), f)
 
-kwftype(t::ANY) = typeof(ccall(:jl_get_kwsorter, Any, (Any,), t))
+kwftype(@nospecialize(t)) = typeof(ccall(:jl_get_kwsorter, Any, (Any,), t))
 
 mutable struct Box
  contents::Any
- Box(x::ANY) = new(x)
+ Box(@nospecialize(x)) = new(x)
  Box() = new()
 end
 
@@ -262,18 +269,18 @@ end
 mutable struct WeakRef
  value
  WeakRef() = WeakRef(nothing)
- WeakRef(v::ANY) = ccall(:jl_gc_new_weakref_th, Ref{WeakRef},
- (Ptr{Void}, Any), getptls(), v)
+ WeakRef(@nospecialize(v)) = ccall(:jl_gc_new_weakref_th, Ref{WeakRef},
+  (Ptr{Void}, Any), getptls(), v)
 end
 
 TypeVar(n::Symbol) =
  ccall(:jl_new_typevar, Ref{TypeVar}, (Any, Any, Any), n, Union{}, Any)
-TypeVar(n::Symbol, ub::ANY) =
+TypeVar(n::Symbol, @nospecialize(ub)) =
  ccall(:jl_new_typevar, Ref{TypeVar}, (Any, Any, Any), n, Union{}, ub)
-TypeVar(n::Symbol, lb::ANY, ub::ANY) =
+TypeVar(n::Symbol, @nospecialize(lb), @nospecialize(ub)) =
  ccall(:jl_new_typevar, Ref{TypeVar}, (Any, Any, Any), n, lb, ub)
 
-UnionAll(v::TypeVar, t::ANY) = ccall(:jl_type_unionall, Any, (Any, Any), v, t)
+UnionAll(v::TypeVar, @nospecialize(t)) = ccall(:jl_type_unionall, Any, (Any, Any), v, t)
 
 Void() = nothing
 
@@ -288,26 +295,26 @@ VecElement(arg::T) where {T} = VecElement{T}(arg)
 # used by lowering of splicing unquote
 splicedexpr(hd::Symbol, args::Array{Any,1}) = (e=Expr(hd); e.args=args; e)
 
-_new(typ::Symbol, argty::Symbol) = eval(:((::Type{$typ})(n::$argty) = $(Expr(:new, typ, :n))))
+_new(typ::Symbol, argty::Symbol) = eval(Core, :((::Type{$typ})(@nospecialize n::$argty) = $(Expr(:new, typ, :n))))
 _new(:LabelNode, :Int)
 _new(:GotoNode, :Int)
 _new(:NewvarNode, :SlotNumber)
-_new(:QuoteNode, :ANY)
+_new(:QuoteNode, :Any)
 _new(:SSAValue, :Int)
-eval(:((::Type{LineNumberNode})(l::Int) = $(Expr(:new, :LineNumberNode, :l, nothing))))
-eval(:((::Type{LineNumberNode})(l::Int, f::ANY) = $(Expr(:new, :LineNumberNode, :l, :f))))
-eval(:((::Type{GlobalRef})(m::Module, s::Symbol) = $(Expr(:new, :GlobalRef, :m, :s))))
-eval(:((::Type{SlotNumber})(n::Int) = $(Expr(:new, :SlotNumber, :n))))
-eval(:((::Type{TypedSlot})(n::Int, t::ANY) = $(Expr(:new, :TypedSlot, :n, :t))))
+eval(Core, :((::Type{LineNumberNode})(l::Int) = $(Expr(:new, :LineNumberNode, :l, nothing))))
+eval(Core, :((::Type{LineNumberNode})(l::Int, @nospecialize(f)) = $(Expr(:new, :LineNumberNode, :l, :f))))
+eval(Core, :((::Type{GlobalRef})(m::Module, s::Symbol) = $(Expr(:new, :GlobalRef, :m, :s))))
+eval(Core, :((::Type{SlotNumber})(n::Int) = $(Expr(:new, :SlotNumber, :n))))
+eval(Core, :((::Type{TypedSlot})(n::Int, @nospecialize(t)) = $(Expr(:new, :TypedSlot, :n, :t))))
 
 Module(name::Symbol=:anonymous, std_imports::Bool=true) = ccall(:jl_f_new_module, Ref{Module}, (Any, Bool), name, std_imports)
 
-Task(f::ANY) = ccall(:jl_new_task, Ref{Task}, (Any, Int), f, 0)
+Task(@nospecialize(f)) = ccall(:jl_new_task, Ref{Task}, (Any, Int), f, 0)
 
 # simple convert for use by constructors of types in Core
 # note that there is no actual conversion defined here,
 # so the methods and ccall's in Core aren't permitted to use convert
-convert(::Type{Any}, x::ANY) = x
+convert(::Type{Any}, @nospecialize(x)) = x
 convert(::Type{T}, x::T) where {T} = x
 cconvert(::Type{T}, x) where {T} = convert(T, x)
 unsafe_convert(::Type{T}, x::T) where {T} = x
@@ -382,16 +389,16 @@ function write(io::IO, x::String)
  return nb
 end
 
-show(io::IO, x::ANY) = ccall(:jl_static_show, Void, (Ptr{Void}, Any), io_pointer(io), x)
+show(io::IO, @nospecialize x) = ccall(:jl_static_show, Void, (Ptr{Void}, Any), io_pointer(io), x)
 print(io::IO, x::Char) = ccall(:jl_uv_putc, Void, (Ptr{Void}, Char), io_pointer(io), x)
 print(io::IO, x::String) = (write(io, x); nothing)
-print(io::IO, x::ANY) = show(io, x)
-print(io::IO, x::ANY, a::ANY...) = (print(io, x); print(io, a...))
+print(io::IO, @nospecialize x) = show(io, x)
+print(io::IO, @nospecialize(x), @nospecialize a...) = (print(io, x); print(io, a...))
 println(io::IO) = (write(io, 0x0a); nothing) # 0x0a = '\n'
-println(io::IO, x::ANY...) = (print(io, x...); println(io))
+println(io::IO, @nospecialize x...) = (print(io, x...); println(io))
 
-show(a::ANY) = show(STDOUT, a)
-print(a::ANY...) = print(STDOUT, a...)
-println(a::ANY...) = println(STDOUT, a...)
+show(@nospecialize a) = show(STDOUT, a)
+print(@nospecialize a...) = print(STDOUT, a...)
+println(@nospecialize a...) = println(STDOUT, a...)
 
 ccall(:jl_set_istopmod, Void, (Any, Bool), Core, true)

base/client.jl

@@ -142,7 +142,7 @@ end
 display_error(er, bt) = display_error(STDERR, er, bt)
 display_error(er) = display_error(er, [])
 
-function eval_user_input(ast::ANY, show_value)
+function eval_user_input(@nospecialize(ast), show_value)
  errcount, lasterr, bt = 0, (), nothing
  while true
  try

base/dates/Dates.jl

@@ -36,6 +36,7 @@ import ..Base: ==, div, fld, mod, rem, gcd, lcm, +, -, *, /, %
 import ..Base.broadcast
 
 using Base.Iterators
+using Base.@nospecialize
 
 include("types.jl")
 include("periods.jl")

base/dates/adjusters.jl

@@ -186,7 +186,7 @@ lastdayofquarter(dt::DateTime) = DateTime(lastdayofquarter(Date(dt)))
 struct DateFunction
  f::Function
  # validate boolean, single-arg inner constructor
- function DateFunction(f::ANY, dt::TimeType)
+ function DateFunction(@nospecialize(f), dt::TimeType)
  isa(f(dt), Bool) || throw(ArgumentError("Provided function must take a single TimeType argument and return true or false"))
  return new(f)
  end

base/deepcopy.jl

@@ -51,7 +51,7 @@ function deepcopy_internal(x::String, stackdict::ObjectIdDict)
  return y
 end
 
-function deepcopy_internal(x::ANY, stackdict::ObjectIdDict)
+function deepcopy_internal(@nospecialize(x), stackdict::ObjectIdDict)
  T = typeof(x)::DataType
  nf = nfields(x)
  (isbits(T) || nf == 0) && return x
@@ -78,7 +78,7 @@ function deepcopy_internal(x::Array, stackdict::ObjectIdDict)
  _deepcopy_array_t(x, eltype(x), stackdict)
 end
 
-function _deepcopy_array_t(x::ANY, T, stackdict::ObjectIdDict)
+function _deepcopy_array_t(@nospecialize(x), T, stackdict::ObjectIdDict)
  if isbits(T)
  return (stackdict[x]=copy(x))
  end

base/deprecated.jl

@@ -1114,7 +1114,7 @@ end
 @deprecate(SharedArray(filename::AbstractString, ::Type{T}, dims::NTuple, offset; kwargs...) where {T},
  SharedArray{T}(filename, dims, offset; kwargs...))
 
-@noinline function is_intrinsic_expr(x::ANY)
+@noinline function is_intrinsic_expr(@nospecialize(x))
  Base.depwarn("is_intrinsic_expr is deprecated. There are no intrinsic functions anymore.", :is_intrinsic_expr)
  return false
 end
@@ -1372,11 +1372,11 @@ _current_module() = ccall(:jl_get_current_module, Ref{Module}, ())
  depwarn("binding_module(symbol) is deprecated, use `binding_module(module, symbol)` instead.", :binding_module)
  return binding_module(_current_module(), s)
 end
-@noinline function expand(x::ANY)
+@noinline function expand(@nospecialize(x))
  depwarn("expand(x) is deprecated, use `expand(module, x)` instead.", :expand)
  return expand(_current_module(), x)
 end
-@noinline function macroexpand(x::ANY)
+@noinline function macroexpand(@nospecialize(x))
  depwarn("macroexpand(x) is deprecated, use `macroexpand(module, x)` instead.", :macroexpand)
  return macroexpand(_current_module(), x)
 end
@@ -1587,6 +1587,9 @@ end
 @deprecate readstring(cmd::AbstractCmd, stdin::Redirectable) readstring(pipeline(stdin, cmd))
 @deprecate eachline(cmd::AbstractCmd, stdin; chomp::Bool=true) eachline(pipeline(stdin, cmd), chomp=chomp)
 
+# ::ANY is deprecated in src/method.c
+# also remove all instances of `jl_ANY_flag` in src/
+
 # END 0.7 deprecations
 
 # BEGIN 1.0 deprecations

base/distributed/Distributed.jl

@@ -10,7 +10,7 @@ import Base: getindex, wait, put!, take!, fetch, isready, push!, length,
 using Base: Process, Semaphore, JLOptions, AnyDict, buffer_writes, wait_connected,
  VERSION_STRING, sync_begin, sync_add, sync_end, async_run_thunk,
  binding_module, notify_error, atexit, julia_exename, julia_cmd,
- AsyncGenerator, display_error, acquire, release, invokelatest
+ AsyncGenerator, display_error, acquire, release, invokelatest, @nospecialize
 
 # NOTE: clusterserialize.jl imports additional symbols from Base.Serializer for use
 

base/distributed/clusterserialize.jl

@@ -32,7 +32,7 @@ function lookup_object_number(s::ClusterSerializer, n::UInt64)
  return get(known_object_data, n, nothing)
 end
 
-function remember_object(s::ClusterSerializer, o::ANY, n::UInt64)
+function remember_object(s::ClusterSerializer, @nospecialize(o), n::UInt64)
  known_object_data[n] = o
  if isa(o, TypeName) && !haskey(object_numbers, o)
  # set up reverse mapping for serialize

base/distributed/remotecall.jl

@@ -484,7 +484,7 @@ Waits and fetches a value from `x` depending on the type of `x`:
 
 Does not remove the item fetched.
 """
-fetch(x::ANY) = x
+fetch(@nospecialize x) = x
 
 isready(rv::RemoteValue, args...) = isready(rv.c, args...)