Inference for splatting numbers (and more)

base/compiler/abstractinterpretation.jl

@@ -370,37 +370,57 @@ function precise_container_type(@nospecialize(arg), @nospecialize(typ), vtypes::
     elseif tti0 <: Array
         return Any[Vararg{eltype(tti0)}]
     else
-        return Any[abstract_iteration(typ, vtypes, sv)]
+        return abstract_iteration(typ, vtypes, sv)
     end
 end
 
 # simulate iteration protocol on container type up to fixpoint
 function abstract_iteration(@nospecialize(itertype), vtypes::VarTable, sv::InferenceState)
-    tm = _topmod(sv)
-    if !isdefined(tm, :iterate) || !isconst(tm, :iterate)
-        return Vararg{Any}
+    if !isdefined(Main, :Base) || !isdefined(Main.Base, :iterate) || !isconst(Main.Base, :iterate)
+        return Any[Vararg{Any}]
     end
-    iteratef = getfield(tm, :iterate)
+    iteratef = getfield(Main.Base, :iterate)
     stateordonet = abstract_call(iteratef, (), Any[Const(iteratef), itertype], vtypes, sv)
     # Return Bottom if this is not an iterator.
     # WARNING: Changes to the iteration protocol must be reflected here,
     # this is not just an optimization.
-    stateordonet === Bottom && return Bottom
+    stateordonet === Bottom && return Any[Bottom]
     valtype = statetype = Bottom
-    while valtype !== Any
+    ret = Any[]
+    stateordonet = widenconst(stateordonet)
+    while !(Nothing <: stateordonet) && length(ret) < sv.params.MAX_TUPLETYPE_LEN
+        if !isa(stateordonet, DataType) || !(stateordonet <: Tuple) || isvatuple(stateordonet) || length(stateordonet.parameters) != 2
+            break
+        end
+        if stateordonet.parameters[2] <: statetype
+            # infinite (or failing) iterator
+            return Any[Bottom]
+        end
+        valtype = stateordonet.parameters[1]
+        statetype = stateordonet.parameters[2]
+        push!(ret, valtype)
+        stateordonet = abstract_call(iteratef, (), Any[Const(iteratef), itertype, statetype], vtypes, sv)
         stateordonet = widenconst(stateordonet)
-        nounion = Nothing <: stateordonet ? typesubtract(stateordonet, Nothing) : stateordonet
+    end
+    if stateordonet === Nothing
+        return ret
+    end
+    while valtype !== Any
+        nounion = typesubtract(stateordonet, Nothing)
         if !isa(nounion, DataType) || !(nounion <: Tuple) || isvatuple(nounion) || length(nounion.parameters) != 2
-            return Vararg{Any}
+            valtype = Any
+            break
         end
         if nounion.parameters[1] <: valtype && nounion.parameters[2] <: statetype
             break
         end
         valtype = tmerge(valtype, nounion.parameters[1])
         statetype = tmerge(statetype, nounion.parameters[2])
         stateordonet = abstract_call(iteratef, (), Any[Const(iteratef), itertype, statetype], vtypes, sv)
+        stateordonet = widenconst(stateordonet)
     end
-    return Vararg{valtype}
+    push!(ret, Vararg{valtype})
+    return ret
 end
 
 # do apply(af, fargs...), where af is a function value
@@ -422,6 +442,9 @@ function abstract_apply(@nospecialize(aft), fargs::Vector{Any}, aargtypes::Vecto
         ctypes´ = []
         for ti in (splitunions ? uniontypes(aargtypes[i]) : Any[aargtypes[i]])
             cti = precise_container_type(fargs[i], ti, vtypes, sv)
+            if _any(t -> t === Bottom, cti)
+                continue
+            end
             for ct in ctypes
                 if isvarargtype(ct[end])
                     tail = tuple_tail_elem(unwrapva(ct[end]), cti)

base/number.jl

@@ -233,7 +233,8 @@ julia> widemul(Float32(3.), 4.)
 """
 widemul(x::Number, y::Number) = widen(x)*widen(y)
 
-iterate(x::Number, done = false) = done ? nothing : (x, true)
+iterate(x::Number) = (x, nothing)
+iterate(x::Number, ::Any) = nothing
 isempty(x::Number) = false
 in(x::Number, y::Number) = x == y
 

test/compiler/compiler.jl

@@ -1707,3 +1707,17 @@ function h27316()
     return x
 end
 @test Tuple{Tuple{Vector{Int}}} <: Base.return_types(h27316, Tuple{})[1] == Union{Vector{Int}, Tuple{Any}} # we may be able to improve this bound in the future
+
+# PR 27434, inference when splatting iterators with type-based state
+splat27434(x) = (x...,)
+struct Iterator27434
+    x::Int
+    y::Int
+    z::Int
+end
+Base.iterate(i::Iterator27434) = i.x, Val(1)
+Base.iterate(i::Iterator27434, ::Val{1}) = i.y, Val(2)
+Base.iterate(i::Iterator27434, ::Val{2}) = i.z, Val(3)
+Base.iterate(::Iterator27434, ::Any) = nothing
+@test @inferred splat27434(Iterator27434(1, 2, 3)) == (1, 2, 3)
+@test Core.Compiler.return_type(splat27434, Tuple{typeof(Iterators.repeated(1))}) == Union{}

test/core.jl

@@ -6235,3 +6235,8 @@ function f27597(y)
 end
 @test f27597([1]) == [1]
 @test f27597([]) == 1:0
+
+# issue #22291
+wrap22291(ind) = (ind...,)
+@test @inferred(wrap22291(1)) == (1,)
+@test @inferred(wrap22291((1, 2))) == (1, 2)