Disallow Vararg in UnionAll

Author: Keno

base/boot.jl

@@ -253,7 +253,7 @@ TypeVar(n::Symbol, @nospecialize(lb), @nospecialize(ub)) = _typevar(n, lb, ub)
 
 UnionAll(v::TypeVar, @nospecialize(t)) = ccall(:jl_type_unionall, Any, (Any, Any), v, t)
 
-const Vararg{T, N} = VarargMarker{T, N}
+const Vararg = ccall(:jl_toplevel_eval_in, Any, (Any, Any), Core, _expr(:new, VarargMarker))
 
 # let the compiler assume that calling Union{} as a constructor does not need
 # to be considered ever (which comes up often as Type{<:T})

base/combinatorics.jl

@@ -307,7 +307,7 @@ julia> 2^2 * 3^3
 !!! compat "Julia 1.6"
     The method that accepts a tuple requires Julia 1.6 or later.
 """
-function nextprod(a::Union{Tuple{Vararg{<:Integer}},AbstractVector{<:Integer}}, x::Real)
+function nextprod(a::Union{Tuple{Vararg{Integer}},AbstractVector{<:Integer}}, x::Real)
     if x > typemax(Int)
         throw(ArgumentError("unsafe for x > typemax(Int), got $x"))
     end

base/compiler/tfuncs.jl

@@ -489,9 +489,8 @@ function typeof_concrete_vararg(t::DataType)
     for i = 1:np
         p = t.parameters[i]
         if i == np && isvarargtype(p)
-            pp = unwrap_unionall(p)
-            if isconcretetype(pp.T) && pp.N isa TypeVar
-                return rewrap_unionall(Type{Tuple{t.parameters[1:np-1]..., pp}}, p)
+            if isdefined(p, :T) && !isdefined(p, :N) && isconcretetype(p.T)
+                return Type{Tuple{t.parameters[1:np-1]..., Vararg{p.T, N}}} where N
             end
         elseif !isconcretetype(p)
             break
@@ -555,18 +554,32 @@ function typeassert_type_instance(@nospecialize(v), @nospecialize(t))
         widev = widenconst(v)
         if widev <: t
             return v
-        elseif typeintersect(widev, t) === Bottom
+        end
+        ti = typeintersect(widev, t)
+        if ti === Bottom
             return Bottom
         end
         @assert widev <: Tuple
         new_fields = Vector{Any}(undef, length(v.fields))
         for i = 1:length(new_fields)
-            new_fields[i] = typeassert_type_instance(v.fields[i], getfield_tfunc(t, Const(i)))
-            if new_fields[i] === Bottom
-                return Bottom
+            if isa(v.fields[i], Core.VarargMarker)
+                new_fields[i] = v.fields[i]
+            else
+                new_fields[i] = typeassert_type_instance(v.fields[i], getfield_tfunc(t, Const(i)))
+                if new_fields[i] === Bottom
+                    return Bottom
+                end
             end
         end
-        return tuple_tfunc(new_fields)
+        tt = tuple_tfunc(new_fields)
+        if isa(tt, PartialStruct)
+            if !(widenconst(tt) <: ti)
+                return PartialStruct(ti, tt.fields)
+            end
+        elseif !(tt <: ti)
+            return ti
+        end
+        return tt
     elseif isa(v, Conditional)
         if !(Bool <: t)
             return Bottom
@@ -1133,7 +1146,7 @@ function apply_type_tfunc(@nospecialize(headtypetype), @nospecialize args...)
         return Any
     end
     if !isempty(args) && isvarargtype(args[end])
-        return isvarargtype(headtype) ? Any : Type
+        return isvarargtype(headtype) ? Core.VarargMarker : Type
     end
     largs = length(args)
     if headtype === Union
@@ -1175,7 +1188,7 @@ function apply_type_tfunc(@nospecialize(headtypetype), @nospecialize args...)
         end
         return allconst ? Const(ty) : Type{ty}
     end
-    istuple = (headtype == Tuple)
+    istuple = isa(headtype, Type) && (headtype == Tuple)
     if !istuple && !isa(headtype, UnionAll) && !isvarargtype(headtype)
         return Union{}
     end
@@ -1260,11 +1273,11 @@ function apply_type_tfunc(@nospecialize(headtypetype), @nospecialize args...)
     catch ex
         # type instantiation might fail if one of the type parameters
         # doesn't match, which could happen if a type estimate is too coarse
-        return isvarargtype(headtype) ? Any : Type{<:headtype}
+        return isvarargtype(headtype) ? Core.VarargMarker : Type{<:headtype}
     end
     !uncertain && canconst && return Const(appl)
     if isvarargtype(appl)
-        return Any
+        return Core.VarargMarker
     end
     if istuple
         return Type{<:appl}
@@ -1316,7 +1329,7 @@ function tuple_tfunc(atypes::Vector{Any})
         x = atypes[i]
         # TODO ignore singleton Const (don't forget to update cache logic if you implement this)
         if !anyinfo
-            anyinfo = !isa(x, Type) || isType(x)
+            anyinfo = (!isa(x, Type) && !isvarargtype(x)) || isType(x)
         end
         if isa(x, Const)
             params[i] = typeof(x.val)

base/compiler/typelimits.jl

@@ -47,7 +47,7 @@ function is_derived_type(@nospecialize(t), @nospecialize(c), mindepth::Int)
         # also handle the var here, since this construct bounds the mindepth to the smallest possible value
         return is_derived_type(t, c.var.ub, mindepth) || is_derived_type(t, c.body, mindepth)
     elseif isa(c, Core.VarargMarker)
-        return is_derived_type(t, c.T, mindepth)
+        return is_derived_type(t, unwrapva(c), mindepth)
     elseif isa(c, DataType)
         if mindepth > 0
             mindepth -= 1
@@ -122,10 +122,9 @@ function _limit_type_size(@nospecialize(t), @nospecialize(c), sources::SimpleVec
         end
     elseif isa(t, Core.VarargMarker)
         isa(c, Core.VarargMarker) || return Vararg
-        VaT = _limit_type_size(t.T, c.T, sources, depth + 1, 0)
-        N = t.N
-        if isa(N, TypeVar) || N === c.N
-            return Vararg{VaT, N}
+        VaT = _limit_type_size(unwrapva(t), unwrapva(c), sources, depth + 1, 0)
+        if isdefined(t, :N) && (isa(t.N, TypeVar) || (isdefined(c, :N) && t.N === c.N))
+            return Vararg{VaT, t.N}
         end
         return Vararg{VaT}
     elseif isa(t, DataType)

base/compiler/typeutils.jl

@@ -196,7 +196,7 @@ function unioncomplexity(t::DataType)
     return c
 end
 unioncomplexity(u::UnionAll) = max(unioncomplexity(u.body), unioncomplexity(u.var.ub))
-unioncomplexity(t::Core.VarargMarker) = unioncomplexity(t.T)
+unioncomplexity(t::Core.VarargMarker) = isdefined(t, :T) ? unioncomplexity(t.T) : 0
 unioncomplexity(@nospecialize(x)) = 0
 
 function improvable_via_constant_propagation(@nospecialize(t))

base/essentials.jl

@@ -255,6 +255,14 @@ function rewrap_unionall(@nospecialize(t), @nospecialize(u))
     return UnionAll(u.var, rewrap_unionall(t, u.body))
 end
 
+function rewrap_unionall(t::Core.VarargMarker, u)
+    isdefined(t, :T) || return t
+    if !isdefined(t, :N) || (isdefined(t, :N) && t.N == u.var)
+        return Vararg{rewrap_unionall(t.T, u)}
+    end
+    Vararg{rewrap_unionall(t.T, u), t.N}
+end
+
 # replace TypeVars in all enclosing UnionAlls with fresh TypeVars
 function rename_unionall(@nospecialize(u))
     if !isa(u, UnionAll)
@@ -272,7 +280,6 @@ function rename_unionall(@nospecialize(u))
 end
 
 function isvarargtype(@nospecialize(t))
-    t = unwrap_unionall(t)
     return isa(t, Core.VarargMarker)
 end
 
@@ -285,18 +292,14 @@ function isvatuple(@nospecialize(t))
     return false
 end
 
-function unwrapva(@nospecialize(t))
-    # NOTE: this returns a related type, but it's NOT a subtype of the original tuple
-    t2 = unwrap_unionall(t)
-    return isvarargtype(t2) ? rewrap_unionall(t2.T, t) : t
-end
+unwrapva(t::Core.VarargMarker) = isdefined(t, :T) ? t.T : Any
+unwrapva(@nospecialize(t)) = t
 
-function unconstrain_vararg_length(@nospecialize(va))
+function unconstrain_vararg_length(va::Core.VarargMarker)
     # construct a new Vararg type where its length is unconstrained,
     # but its element type still captures any dependencies the input
     # element type may have had on the input length
-    T = unwrap_unionall(va).T
-    return rewrap_unionall(Vararg{T}, va)
+    return Vararg{unwrapva(va)}
 end
 
 typename(a) = error("typename does not apply to this type")

base/methodshow.jl

@@ -27,25 +27,14 @@ function argtype_decl(env, n, @nospecialize(sig::DataType), i::Int, nargs, isva:
         t === Any && return s, ""
     end
     if isvarargtype(t)
-        v1, v2 = nothing, nothing
-        if isa(t, UnionAll)
-            v1 = t.var
-            t = t.body
-            if isa(t, UnionAll)
-                v2 = t.var
-                t = t.body
-            end
-        end
-        ut = unwrap_unionall(t)::Core.VarargMarker
-        tt, tn = ut.T, ut.N
-        if isa(tn, TypeVar) && (tn === v1 || tn === v2)
-            if tt === Any || (isa(tt, TypeVar) && (tt === v1 || tt === v2))
+        if !isdefined(t, :N)
+            if unwrapva(t) === Any
                 return string(s, "..."), ""
             else
                 return s, string_with_env(env, tt) * "..."
             end
         end
-        return s, string_with_env(env, "Vararg{", tt, ", ", tn, "}")
+        return s, string_with_env(env, "Vararg{", t.T, ", ", t.N, "}")
     end
     return s, string_with_env(env, t)
 end

base/promotion.jl

@@ -157,9 +157,8 @@ function full_va_len(p)
     isempty(p) && return 0, true
     last = p[end]
     if isvarargtype(last)
-        N = unwrap_unionall(last).N
-        if isa(N, Int)
-            return length(p)::Int + N - 1, true
+        if isdefined(last, :N) && isa(last.N, Int)
+            return length(p)::Int + last.N - 1, true
         end
         return length(p)::Int, false
     end

base/reflection.jl

@@ -733,6 +733,9 @@ function to_tuple_type(@nospecialize(t))
     end
     if isa(t, Type) && t <: Tuple
         for p in unwrap_unionall(t).parameters
+            if isa(p, Core.VarargMarker)
+                p = p.T
+            end
             if !(isa(p, Type) || isa(p, TypeVar))
                 error("argument tuple type must contain only types")
             end

base/show.jl

@@ -2213,11 +2213,16 @@ function show(io::IO, tv::TypeVar)
 end
 
 function show(io::IO, vm::Core.VarargMarker)
-    print(io, "Vararg{")
-    show(io, vm.T)
-    print(io, ", ")
-    show(io, vm.N)
-    print(io, "}")
+    print(io, "Vararg")
+    if isdefined(vm, :T)
+        print(io, "{")
+        show(io, vm.T)
+        if isdefined(vm, :N)
+            print(io, ", ")
+            show(io, vm.N)
+        end
+        print(io, "}")
+    end
 end
 
 module IRShow