Improve precision of tmeet for vararg PartialStruct

Author: martinholters

base/compiler/typelimits.jl

@@ -602,17 +602,24 @@ function tmeet(@nospecialize(v), @nospecialize(t))
             return Bottom
         end
         @assert widev <: Tuple
-        new_fields = Vector{Any}(undef, length(v.fields))
-        for i = 1:length(new_fields)
-            if isa(v.fields[i], Core.TypeofVararg)
-                new_fields[i] = v.fields[i]
-            else
-                new_fields[i] = tmeet(v.fields[i], widenconst(getfield_tfunc(t, Const(i))))
-                if new_fields[i] === Bottom
-                    return Bottom
-                end
+        if isa(ti, DataType) && ti.name === Tuple.name
+            num_fields = length(ti.parameters)
+            isva = isvatuple(ti)
+        else
+            nfields_ti = nfields_tfunc(ti)
+            isva = !isa(nfields_ti, Const)
+            num_fields = isva ? length(v.fields) : (nfields_ti::Const).val
+        end
+        new_fields = Vector{Any}(undef, num_fields)
+        for i = 1:num_fields
+            new_fields[i] = tmeet(getfield_tfunc(v, Const(i)), widenconst(getfield_tfunc(ti, Const(i))))
+            if new_fields[i] === Bottom
+                return Bottom
             end
         end
+        if isva && isvarargtype(v.fields[end])
+            new_fields[end] = Vararg{new_fields[end]}
+        end
         return tuple_tfunc(new_fields)
     elseif isa(v, Conditional)
         if !(Bool <: t)

test/compiler/inference.jl

@@ -3146,6 +3146,18 @@ function splat_lotta_unions()
 end
 @test Core.Compiler.return_type(splat_lotta_unions, Tuple{}) >: Tuple{Int,Int,Int}
 
+# issue #38971 and related precision issues
+f28971() = (1, [2,3]...)::Tuple{Int,Int,Int}
+@test @inferred(f28971()) == (1, 2, 3)
+g28971(::Type{T}) where {T} = (1, Number[2,3]...)::T
+@test Base.return_types(g28971, Tuple{Type{Tuple{Vararg{Int}}}})[1] == Tuple{Int,Vararg{Int}}
+@test Base.return_types(g28971, Tuple{Type{Tuple{Int,Vararg{Int}}}})[1] == Tuple{Int,Vararg{Int}}
+@test Base.return_types(g28971, Tuple{Type{Tuple{Int,Int,Vararg{Int}}}})[1] == Tuple{Int,Int,Vararg{Int}}
+@test Base.return_types(g28971, Tuple{Type{Union{Tuple{Int,Int,Int},Tuple{Vararg{Float64}}}}})[1] == Tuple{Int,Int,Int}
+let T = Union{Tuple{Int,Int,Int},Tuple{Int,Vararg{Float64}}}
+    @test T <: Base.return_types(g28971, Tuple{Type{T}})[1] <: Tuple{Int,Vararg{Union{Int,Float64}}}
+end
+
 # Bare Core.Argument in IR
 @eval f_bare_argument(x) = $(Core.Argument(2))
 @test Base.return_types(f_bare_argument, (Int,))[1] == Int