correct precise_container_types to handle TypeConstructor correctly

Author: vtjnash

base/essentials.jl

@@ -41,27 +41,28 @@ macro generated(f)
     end
 end
 
+argtail(x, rest...) = rest
+tail(x::Tuple) = argtail(x...)
 
-tuple_type_head(::Type{Union{}}) = throw(MethodError(tuple_type_head, (Union{},)))
-function tuple_type_head{T<:Tuple}(::Type{T})
+tuple_type_head(T::TypeConstructor) = tuple_type_head(T.body)
+function tuple_type_head(T::DataType)
     @_pure_meta
-    T.parameters[1]
+    T.name === Tuple.name || throw(MethodError(tuple_type_head, (T,)))
+    return T.parameters[1]
 end
-
-isvarargtype(t::ANY) = isa(t,DataType)&&is((t::DataType).name,Vararg.name)
-isvatuple(t::DataType) = (n = length(t.parameters); n > 0 && isvarargtype(t.parameters[n]))
-unwrapva(t::ANY) = isvarargtype(t) ? t.parameters[1] : t
-
-function tuple_type_tail{T<:Tuple}(::Type{T})
+tuple_type_tail(T::TypeConstructor) = tuple_type_tail(T.body)
+function tuple_type_tail(T::DataType)
     @_pure_meta
+    T.name === Tuple.name || throw(MethodError(tuple_type_tail, (T,)))
     if isvatuple(T) && length(T.parameters) == 1
         return T
     end
-    Tuple{argtail(T.parameters...)...}
+    return Tuple{argtail(T.parameters...)...}
 end
 
-argtail(x, rest...) = rest
-tail(x::Tuple) = argtail(x...)
+isvarargtype(t::ANY) = isa(t, DataType) && is((t::DataType).name, Vararg.name)
+isvatuple(t::DataType) = (n = length(t.parameters); n > 0 && isvarargtype(t.parameters[n]))
+unwrapva(t::ANY) = isvarargtype(t) ? t.parameters[1] : t
 
 convert{T<:Tuple{Any,Vararg{Any}}}(::Type{T}, x::Tuple{Any, Vararg{Any}}) =
     tuple(convert(tuple_type_head(T),x[1]), convert(tuple_type_tail(T), tail(x))...)

base/inference.jl

@@ -873,16 +873,19 @@ function precise_container_types(args, types, vtypes::VarTable, sv)
         ai = args[i]
         ti = types[i]
         tti = widenconst(ti)
-        if isa(ai,Expr) && ai.head === :call && (abstract_evals_to_constant(ai.args[1], svec, vtypes, sv) ||
-                                                 abstract_evals_to_constant(ai.args[1], tuple, vtypes, sv))
+        if isa(tti, TypeConstructor)
+            tti = tti.body
+        end
+        if isa(ai, Expr) && ai.head === :call && (abstract_evals_to_constant(ai.args[1], svec, vtypes, sv) ||
+                                                  abstract_evals_to_constant(ai.args[1], tuple, vtypes, sv))
             aa = ai.args
             result[i] = Any[ (isa(aa[j],Expr) ? aa[j].typ : abstract_eval(aa[j],vtypes,sv)) for j=2:length(aa) ]
             if _any(isvarargtype, result[i])
                 return nothing
             end
-        elseif isa(ti, Union)
+        elseif isa(tti, Union)
             return nothing
-        elseif ti ⊑ Tuple
+        elseif tti <: Tuple
             if i == n
                 if isvatuple(tti) && length(tti.parameters) == 1
                     result[i] = Any[Vararg{tti.parameters[1].parameters[1]}]
@@ -894,7 +897,7 @@ function precise_container_types(args, types, vtypes::VarTable, sv)
             else
                 return nothing
             end
-        elseif ti⊑AbstractArray && i==n
+        elseif tti <: AbstractArray && i == n
             result[i] = Any[Vararg{eltype(tti)}]
         else
             return nothing
@@ -1264,7 +1267,7 @@ function tmerge(typea::ANY, typeb::ANY)
     typea, typeb = widenconst(typea), widenconst(typeb)
     typea === typeb && return typea
     if (typea <: Tuple) && (typeb <: Tuple)
-        if length(typea.parameters) == length(typeb.parameters) && !isvatuple(typea) && !isvatuple(typeb)
+        if isa(typea, DataType) && isa(typeb, DataType) && length(typea.parameters) == length(typeb.parameters) && !isvatuple(typea) && !isvatuple(typeb)
             return typejoin(typea, typeb)
         end
         return Tuple

base/tuple.jl

@@ -41,7 +41,7 @@ first(t::Tuple) = t[1]
 # eltype
 
 eltype(::Type{Tuple{}}) = Bottom
-eltype{T,_}(::Type{NTuple{_,T}}) = T
+eltype{T}(::Type{Tuple{Vararg{T}}}) = T
 
 # front (the converse of tail: it skips the last entry)
 

test/inference.jl

@@ -252,3 +252,9 @@ end
 let g() = Int <: Real ? 1 : ""
     @test Base.return_types(g, Tuple{}) == [Int]
 end
+
+typealias NInt{N} Tuple{Vararg{Int, N}}
+@test Base.eltype(NInt) === Int
+fNInt(x::NInt) = (x...)
+gNInt() = fNInt(x)
+@test Base.return_types(gNInt, ()) == Any[NInt]