Spurious deprecation warning from Vararg !<: Type

[timholy]

I don't understand why this function definition seems prohibited (running with --depwarn=error):

julia> struct CenterIndexedArray{T,N,A<:AbstractArray} <: AbstractArray{T,N}
           data::A
           halfsize::NTuple{N,Int}

           function CenterIndexedArray{T,N,A}(data::A) where {T,N,A<:AbstractArray}
               new{T,N,A}(data, _halfsize(data))
           end
       end

julia> CenterIndexedArray(A::AbstractArray{T,N}) where {T,N} = CenterIndexedArray{T,N,typeof(A)}(A)
CenterIndexedArray

julia> CenterIndexedArray{T,N}(::UndefInitializer, sz::Vararg{<:Integer,N}) where {T,N} =
           CenterIndexedArray(Array{T,N}(undef, sz...))
ERROR: Wrapping `Vararg` directly in UnionAll is deprecated (wrap the tuple instead).
Stacktrace:
 [1] UnionAll(v::TypeVar, t::Any)
   @ Core ./boot.jl:257
 [2] top-level scope
   @ REPL[3]:1

xref #38136, CC @Keno

[KristofferC]

Does it work to write Vararg{Integer,N} instead?

[timholy]

Ah, yes it does. Not sure whether this should be problematic, though. Or if it is, we need a clearer error message.

[KristofferC]

Yeah, the error message is not great; I just remember that this error message means to remove the <:. Maybe just adding a small example would be enough, for example:

e.g. write Vararg{T, N} instead of Vararg{<:T, N}.

[Keno]

Vararg{<:Integer,N} is syntax for Vararg{T,N} where T<:Integer, which is no longer allowed, you need to write Tuple{Vararg{T,N}} where T<:Integer.

[Keno]

(In a method signature the Tuple is implicit).

[timholy]

Isn't it:

• f(::Tuple{Vararg{Any}}) matches f((1,)) but not f(1)
• f(::Vararg{Any}) matches f(1) or f((1,))

So wrapping in Tuple is not neutral with respect to dispatch.

[Keno]

The first one's signature is Tuple{typeof(f), Tuple{Vararg{Any}}}.
The second one is Tuple{typeof(f), Vararg{Any}}. The point is that you're not allowed to write
Tuple{typeof(f), Vararg{T} where T} anymore, you have to write Tuple{typeof(f), Vararg{T}} where T.
Of course, the error message is a bit confusing, because the Tuple{} of the signature is hidden behind
a syntax rewrite, but it's hard to give a much better error, because by the time we can detect this, the
difference is no longer there.

[timholy]

I see the point of confusion: I was thinking of just the arg, you were using the whole signature tuple-type.

While we may not be able to give a definitive prescription, there don't seem to be that many options. Would it be acceptable to add a second line,

You may need to write `f(x::Vararg{T})` rather than `f(x::Vararg{<:T})` or `f(x::Vararg{T}) where T` instead of `f(x::Vararg{T} where T)`

[Keno]

Sure