fatal error in type inference (type bound)

[mcabbott]

I got the above error locally with #40996, which I have never seen before.

CI sees it too, here: https://build.julialang.org/#/builders/7/builds/5932/steps/5/logs/stdio (17f851b)

arrayops                           (5) |         failed at 2021-11-13T02:50:50.671
Error During Test at /buildworker/worker/tester_linuxaarch64/build/share/julia/test/arrayops.jl:1149
  Got exception outside of a @test
  fatal error in type inference (type bound)
  Stacktrace:
    [1] mapslices(f::Main.Test99Main_arrayops.var"#18#31", A::Matrix{Int64}; dims::Int64)
      @ Base ./abstractarray.jl:2803
    [2] macro expansion
      @ /buildworker/worker/tester_linuxaarch64/build/share/julia/test/arrayops.jl:1196 [inlined]

[LilithHafner]

Reproducers (first two from @mcabbott):

julia> mapslices(tuple, [1 2; 3 4], dims=1)
1×2 Matrix{Tuple{Vector{Int64}}}:
 ([1, 3],)  ([2, 4],)

julia> mapslices(x -> tuple(x), [1 2; 3 4], dims=1)
ERROR: fatal error in type inference (type bound)
Stacktrace:
 [1] mapslices(f::var"#5#6", A::Matrix{Int64}; dims::Int64)
   @ Base ./abstractarray.jl:2896
 [2] top-level scope
   @ REPL[13]:1

julia> mapslices(argmax, rand(10,10); dims=2)
ERROR: fatal error in type inference (type bound)
Stacktrace:
 [1] mapslices(f::typeof(argmax), A::Matrix{Float64}; dims::Int64)
   @ Base ./abstractarray.jl:2896
 [2] top-level scope
   @ REPL[14]:1

[mcabbott]

One more example, in which ndims seems to change the regime?

julia> mapslices(findmin, rand(3); dims=1)  # works in 1D, and infers
1-element Vector{Tuple{Float64, Int64}}:
 (0.10724568875730223, 3)

julia> @code_warntype mapslices(findmin, rand(3); dims=1)
...
Body::Vector{Tuple{Float64, Int64}}

julia> mapslices(findmin, rand(3,3); dims=1)  # errors in 2D
ERROR: fatal error in type inference (type bound)

julia> mapslices(findmin, rand(3,3,3); dims=1) |> summary  # works in 3D, but does not infer
"1×3×3 Array{Tuple{Float64, Int64}, 3}"

julia> @code_warntype mapslices(findmin, rand(3,3,3); dims=1)
...
Body::Any

[martinholters]

Reduction based on the x -> tuple(x) above:

julia> function f(dims)
           idx1 = ntuple(d -> d in dims ? (:) : 1, 2)
           Aslice = [1 2; 3 4][idx1...]
           r1 = (x -> tuple(x))(Aslice)
           _res1 = similar(Aslice, typeof(r1), Base.reduced_indices(Aslice, 1:ndims(Aslice)))
           _res1[begin] = r1
       end
f (generic function with 1 method)

julia> f(1)
ERROR: fatal error in type inference (type bound)

With @code_warntype one finds that the call to similar is inferred as VecOrMat{Tuple{Int64}}, but the element type should actually be Tuple{Vector{Int64}}. (Or, from the imprecise inference of the argument, I think it should be inferred as Union{VecOrMat{Tuple{Int64}}, VecOrMat{Tuple{Vector{Int64}}}}.)

Indeed, I find the following:

julia> T1 = Type{Tuple{Int64}};

julia> T2 = Type{Tuple{Vector{Int64}}};

julia> only(code_typed(similar, (Vector{Int64}, T1, Tuple{Base.OneTo{Int64}})))[2] # ok
Vector{Tuple{Int64}} (alias for Array{Tuple{Int64}, 1})

julia> only(code_typed(similar, (Vector{Int64}, T2, Tuple{Base.OneTo{Int64}})))[2] # ok
Vector{Tuple{Vector{Int64}}} (alias for Array{Tuple{Array{Int64, 1}}, 1})

julia> only(code_typed(similar, (Vector{Int64}, Union{T1, T2}, Tuple{Base.OneTo{Int64}})))[2] # should be the union of the above?
Vector{Tuple{Int64}} (alias for Array{Tuple{Int64}, 1})

And:

julia> code_warntype(similar, (Vector{Int64}, Union{T1, T2}, Tuple{Base.OneTo{Int64}}))
MethodInstance for similar(::Vector{Int64}, ::Union{Type{Tuple{Vector{Int64}}}, Type{Tuple{Int64}}}, ::Tuple{Base.OneTo{Int64}})
  from similar(a::AbstractArray, ::Type{T}, dims::Tuple{Union{Integer, Base.OneTo}, Vararg{Union{Integer, Base.OneTo}}}) where T
     @ Base abstractarray.jl:815
Static Parameters
  T = Tuple{Int64}
Arguments
  #self#::Core.Const(similar)
  a::Vector{Int64}
  _::Union{Type{Tuple{Vector{Int64}}}, Type{Tuple{Int64}}}
  dims::Tuple{Base.OneTo{Int64}}
Body::Vector{Tuple{Int64}}
1 ─ %1 = $(Expr(:static_parameter, 1))::Core.Const(Tuple{Int64})
│   %2 = Base.to_shape(dims)::Tuple{Int64}
│   %3 = Base.similar(a, %1, %2)::Vector{Tuple{Int64}}
└──      return %3

Note the discrepancy between T/$(Expr(:static_parameter, 1)) and the type of _. Interestingly, a rather similar-looking similar method works as desired:

julia> code_warntype(similar, (Vector{Int64}, Union{T1, T2}, Int64))
MethodInstance for similar(::Vector{Int64}, ::Union{Type{Tuple{Vector{Int64}}}, Type{Tuple{Int64}}}, ::Int64)
  from similar(a::AbstractArray, ::Type{T}, dims::Union{Integer, AbstractUnitRange}...) where T
     @ Base abstractarray.jl:809
Static Parameters
  T <: Any
Arguments
  #self#::Core.Const(similar)
  a::Vector{Int64}
  _::Union{Type{Tuple{Vector{Int64}}}, Type{Tuple{Int64}}}
  dims::Tuple{Int64}
Body::Union{Vector{Tuple{Vector{Int64}}}, Vector{Tuple{Int64}}}
1 ─ %1 = $(Expr(:static_parameter, 1))::Union{Type{Tuple{Vector{Int64}}}, Type{Tuple{Int64}}}
│   %2 = Base.to_shape(dims)::Tuple{Int64}
│   %3 = Base.similar(a, %1, %2)::Union{Vector{Tuple{Vector{Int64}}}, Vector{Tuple{Int64}}}
└──      return %3

Here $(Expr(:static_parameter, 1)) is indeed the union of the possible types of _.

[N5N3]

Looks like a bug in jl_matching_methods

f(::Type{T}, ::Union{Nothing,Int,Missing}) where {T} = T
tt = Tuple{typeof(f),Union{Type{Int},Type{Float16}},Nothing}
match = Base._methods_by_ftype(tt, -1, typemax(UInt))[1]
match.sparams # svec(Int64) wrong

g(::Type{T}, ::Any) where {T} = T
tt = Tuple{typeof(g),Union{Type{Int},Type{Float16}},Nothing}
match = Base._methods_by_ftype(tt, -1, Base.get_world_counter())[1]
match.sparams #svec(T) # correct

[vtjnash]

Duplicate of #41096 (comment)