New `Internal error: stack overflow in type inference` when testing some packages

[KristofferC]

When testing the EBayes or GroupedErrors packages they now error with Internal error: stack overflow in type inference. Some example of that are:

Ebayes (https://s3.amazonaws.com/julialang-reports/nanosoldier/pkgeval/by_hash/c9a32f4_vs_e4ee485/EBayes.primary.log):

Internal error: stack overflow in type inference of fit(Distributions.Normal{Float64}, EBayes.SURE, EBayes.FixedLocation{Float64}, StructArrays.StructArray{EBayes.NormalSample{Float64}, 1, NamedTuple{(:Z, :σ), Tuple{Array{Float64, 1}, Array{Float64, 1}}}, Int64}).
This might be caused by recursion over very long tuples or argument lists.
Internal error: stack overflow in type inference of fit(Distributions.Normal{Float64}, EBayes.SURE, EBayes.GrandMeanLocation{Float64}, StructArrays.StructArray{EBayes.NormalSample{Float64}, 1, NamedTuple{(:Z, :σ), Tuple{Array{Float64, 1}, Array{Float64, 1}}}, Int64}).

GroupedErrors (https://s3.amazonaws.com/julialang-reports/nanosoldier/pkgeval/by_hash/c9a32f4_vs_e4ee485/GroupedErrors.primary.log):

│   diff =
│    Warning: Diff output requires color.
│    Internal error: stack overflow in type inference of repr(DataFrames.DataFrame).
│    This might be caused by recursion over very long tuples or argument lists.

[inkydragon]

bisect.

• good DEV.1300 fbbe9ed
• bad DEV.1301 15d7bd8 <----- (Simplify mul! dispatch #49806)

EBayes.jl

test with

• Julia Version 1.10.0-alpha1 Commit f8ad15f
• With debug; FORCE_ASSERTIONS=1, LLVM_ASSERTIONS=1

version

Julia Version 1.10.0-alpha1
Commit f8ad15f7b1 (2023-07-06 10:36 UTC)
DEBUG build
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 16 × Intel(R) Core(TM) i7-10700 CPU @ 2.90GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-15.0.7 (ORCJIT, skylake)
  Threads: 1 on 16 virtual cores

test code
copy from: https://github.com/nignatiadis/EBayes.jl/blob/18bba5739a5a8cdde673fb8c2df95e5bbe919e2f/test/tests_sure.jl#L12-L17

using EBayes

function fit()
@show "before code start"
normal_normal_sim = EBayes.NormalNormalSimulation();
sim_res = rand(normal_normal_sim);
ss = NormalSamples(sim_res);
# ---- original args
predictor=Normal()
method=SURE()
loc=GrandMeanLocation()
optimizer = EBayes.IPNewton()
# --- function body
fitted_loc=0.04
x0 = EBayes.optim_start_point(predictor, method, loc, fitted_loc, ss);
f_diff = EBayes.optim_objective(predictor, method, loc, fitted_loc, ss, x0);
dfc = EBayes.TwiceDifferentiableConstraints([0.0], [Inf]);
EBayes.optimize(f_diff, dfc, x0, optimizer);
end

fit();

output

julia> fit();
Internal error: stack overflow in type inference of fit().
This might be caused by recursion over very long tuples or argument lists.
"before code start" = "before code start"

julia>

@code_warntype fit() gives StackOverflowError

Details

julia> @code_warntype fit()
ERROR: StackOverflowError:
Stacktrace:
   [1] _methods_by_ftype(t::Any, mt::Nothing, lim::Int64, world::UInt64, ambig::Bool, min::Core.Compiler.RefValue{…}, max::Core.Compiler.RefValue{…}, has_ambig::Core.Compiler.RefValue{…})
     @ Core.Compiler ./reflection.jl:1029
   [2] _findall(sig::Type, mt::Nothing, world::UInt64, limit::Int64)
     @ Core.Compiler ./compiler/methodtable.jl:105 [inlined]
   [3] findall(sig::Type, table::Core.Compiler.InternalMethodTable; limit::Int64)
     @ Core.Compiler ./compiler/methodtable.jl:74 [inlined]
   [4] findall(sig::Type, table::Core.Compiler.CachedMethodTable{Core.Compiler.InternalMethodTable}; limit::Int64)
     @ Core.Compiler ./compiler/methodtable.jl:119
   [5] find_matching_methods(𝕃::Core.Compiler.InferenceLattice{…}, argtypes::Vector{…}, atype::Any, method_table::Core.Compiler.CachedMethodTable{…}, max_union_splitting::Int64, max_methods::Int64)
     @ Core.Compiler ./compiler/abstractinterpretation.jl:288
   [6]
     @ Core.Compiler ./compiler/abstractinterpretation.jl:24
   [7]
     @ Core.Compiler ./compiler/abstractinterpretation.jl:2052
   [8]
     @ Core.Compiler ./compiler/abstractinterpretation.jl:2134
   [9]
     @ Core.Compiler ./compiler/abstractinterpretation.jl:2127
  [10] abstract_call(interp::Core.Compiler.NativeInterpreter, arginfo::Core.Compiler.ArgInfo, sv::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/abstractinterpretation.jl:2311
  [11] abstract_eval_call(interp::Core.Compiler.NativeInterpreter, e::Expr, vtypes::Vector{…}, sv::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/abstractinterpretation.jl:2327
  [12] abstract_eval_statement_expr(interp::Core.Compiler.NativeInterpreter, e::Expr, vtypes::Vector{…}, sv::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/abstractinterpretation.jl:2337
  [13] abstract_eval_statement(interp::Core.Compiler.NativeInterpreter, e::Any, vtypes::Vector{…}, sv::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/abstractinterpretation.jl:2581
  [14] abstract_eval_basic_statement(interp::Core.Compiler.NativeInterpreter, stmt::Any, pc_vartable::Vector{…}, frame::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/abstractinterpretation.jl:2870
  [15] typeinf_local(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/abstractinterpretation.jl:3055
  [16] typeinf_nocycle(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/abstractinterpretation.jl:3143
  [17] _typeinf(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/typeinfer.jl:247
  [18] typeinf(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/typeinfer.jl:216
  [19]
     @ Core.Compiler ./compiler/typeinfer.jl:930
  [20]
     @ Core.Compiler ./compiler/abstractinterpretation.jl:629
  [21]
     @ Core.Compiler ./compiler/abstractinterpretation.jl:95
--- the last 15 lines are repeated 11 more times ---
 [187]
     @ Core.Compiler ./compiler/abstractinterpretation.jl:2052
 [188]
     @ Core.Compiler ./compiler/abstractinterpretation.jl:2134
 [189]
     @ Core.Compiler ./compiler/abstractinterpretation.jl:2127
 [190] abstract_call(interp::Core.Compiler.NativeInterpreter, arginfo::Core.Compiler.ArgInfo, sv::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/abstractinterpretation.jl:2311
 [191] abstract_eval_call(interp::Core.Compiler.NativeInterpreter, e::Expr, vtypes::Vector{…}, sv::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/abstractinterpretation.jl:2327
 [192] abstract_eval_statement_expr(interp::Core.Compiler.NativeInterpreter, e::Expr, vtypes::Vector{…}, sv::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/abstractinterpretation.jl:2337
 [193] abstract_eval_statement(interp::Core.Compiler.NativeInterpreter, e::Any, vtypes::Vector{…}, sv::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/abstractinterpretation.jl:2581
 [194] abstract_eval_basic_statement(interp::Core.Compiler.NativeInterpreter, stmt::Any, pc_vartable::Vector{…}, frame::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/abstractinterpretation.jl:2870
 [195] typeinf_local(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/abstractinterpretation.jl:3055
 [196] typeinf_nocycle(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/abstractinterpretation.jl:3143
 [197] _typeinf(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/typeinfer.jl:247
 [198] typeinf(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)
     @ Core.Compiler ./compiler/typeinfer.jl:216
 [199]
     @ Core.Compiler ./compiler/typeinfer.jl:995
 [200]
     @ Core.Compiler ./compiler/typeinfer.jl:948
 [201] code_typed_by_type(tt::Type; optimize::Bool, debuginfo::Symbol, world::UInt64, interp::Core.Compiler.NativeInterpreter)
     @ Base ./reflection.jl:1400
 [202] code_typed(f::Any, types::Any; kwargs::@Kwargs{optimize::Bool})
     @ Base ./reflection.jl:1358
 [203] code_warntype(io::Base.TTY, f::Any, t::Any; debuginfo::Symbol, optimize::Bool, kwargs::@Kwargs{})
     @ InteractiveUtils ~/jl/julia/usr/share/julia/stdlib/v1.10/InteractiveUtils/src/codeview.jl:79
 [204] code_warntype(io::Base.TTY, f::Any, t::Any)
     @ InteractiveUtils ~/jl/julia/usr/share/julia/stdlib/v1.10/InteractiveUtils/src/codeview.jl:75
 [205] code_warntype(f::Any, t::Any; kwargs::@Kwargs{})
     @ InteractiveUtils ~/jl/julia/usr/share/julia/stdlib/v1.10/InteractiveUtils/src/codeview.jl:157

[KristofferC]

bisect.

I didn't really get the formatting, which commit was the one causing it?

[inkydragon]

This one: Simplify mul! dispatch 15d7bd8 (#49806) @dkarrasch

Maybe there is a loop in the dispatch of those functions.

[dkarrasch]

I can reproduce the error when calling fit(), but copy-pasting the entire function body works without any issues. However, since the error refers to type inference, I put a @inferred in front of every function call. It turns out that the call of EBayes.optim_start_point yields the following error:

ERROR: return type Vector{Float64} does not match inferred return type Vector

The corresponding code is https://github.com/nignatiadis/EBayes.jl/blob/18bba5739a5a8cdde673fb8c2df95e5bbe919e2f/src/sure.jl#L50-L62, and it is correctly inferred on v1.9. Checking with @code_warntype I get on v1.9

julia> @code_warntype EBayes.optim_start_point(predictor, method, loc, fitted_loc, ss)
MethodInstance for EBayes.optim_start_point(::Normal{Float64}, ::SURE, ::GrandMeanLocation{Float64}, ::Float64, ::StructArrays.StructVector{NormalSample{Float64}, NamedTuple{(:Z, :σ), Tuple{Vector{Float64}, Vector{Float64}}}, Int64})
  from optim_start_point(predictor::Normal, sure::SURE, loc::EBayes.EBayesShrinkageLocation, fitted_loc, ss::StructArrays.StructArray{NormalSample{T}} where T) @ EBayes ~/.julia/packages/EBayes/YKk0V/src/sure.jl:50
Arguments
  #self#::Core.Const(EBayes.optim_start_point)
  predictor::Normal{Float64}
  sure::Core.Const(SURE())
  loc::GrandMeanLocation{Float64}
  fitted_loc::Float64
  ss::StructArrays.StructVector{NormalSample{Float64}, NamedTuple{(:Z, :σ), Tuple{Vector{Float64}, Vector{Float64}}}, Int64}
Locals
  x0::Union{Float64, Vector{Float64}}
  σs_squared::Vector{Float64}
  Zs::Vector{Float64}
  μs::Vector{Float64}
Body::Vector{Float64}
1 ─       (μs = EBayes.predict(loc, fitted_loc, ss))
│         (Zs = EBayes.response(ss))
│         (σs_squared = EBayes.var(ss))
│   %4  = EBayes.:-::Core.Const(-)
│   %5  = EBayes.:^::Core.Const(^)
│   %6  = Base.broadcasted(EBayes.:-, Zs, μs)::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(-), Tuple{Vector{Float64}, Vector{Float64}}}
│   %7  = Core.apply_type(Base.Val, 2)::Core.Const(Val{2})
│   %8  = (%7)()::Core.Const(Val{2}())
│   %9  = Base.broadcasted(Base.literal_pow, %5, %6, %8)::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.literal_pow), Tuple{Base.RefValue{typeof(^)}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(-), Tuple{Vector{Float64}, Vector{Float64}}}, Base.RefValue{Val{2}}}}
│   %10 = Base.broadcasted(%4, %9, σs_squared)::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(-), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.literal_pow), Tuple{Base.RefValue{typeof(^)}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(-), Tuple{Vector{Float64}, Vector{Float64}}}, Base.RefValue{Val{2}}}}, Vector{Float64}}}
│   %11 = Base.materialize(%10)::Vector{Float64}
│   %12 = EBayes.mean(%11)::Float64
│   %13 = EBayes.max(%12, 0.0001)::Float64
│         (x0 = EBayes.sqrt(%13))
│         (x0 = Base.vect(x0::Float64))
└──       return x0::Vector{Float64}

and on v1.10-alpha

julia> @code_warntype EBayes.optim_start_point(predictor, method, loc, fitted_loc, ss)
MethodInstance for EBayes.optim_start_point(::Normal{Float64}, ::SURE, ::GrandMeanLocation{Float64}, ::Float64, ::StructArrays.StructVector{NormalSample{Float64}, @NamedTuple{Z::Vector{Float64}, σ::Vector{Float64}}, Int64})
  from optim_start_point(predictor::Normal, sure::SURE, loc::EBayes.EBayesShrinkageLocation, fitted_loc, ss::StructArrays.StructArray{NormalSample{T}} where T) @ EBayes ~/.julia/packages/EBayes/YKk0V/src/sure.jl:50
Arguments
  #self#::Core.Const(EBayes.optim_start_point)
  predictor::Normal{Float64}
  sure::Core.Const(SURE())
  loc::GrandMeanLocation{Float64}
  fitted_loc::Float64
  ss::StructArrays.StructVector{NormalSample{Float64}, @NamedTuple{Z::Vector{Float64}, σ::Vector{Float64}}, Int64}
Locals
  x0::Any
  σs_squared::Vector{Float64}
  Zs::Vector{Float64}
  μs::Vector{Float64}
Body::Vector
1 ─       (μs = EBayes.predict(loc, fitted_loc, ss))
│         (Zs = EBayes.response(ss))
│         (σs_squared = EBayes.var(ss))
│   %4  = EBayes.:-::Core.Const(-)
│   %5  = EBayes.:^::Core.Const(^)
│   %6  = Base.broadcasted(EBayes.:-, Zs, μs)::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(-), Tuple{Vector{Float64}, Vector{Float64}}}
│   %7  = Core.apply_type(Base.Val, 2)::Core.Const(Val{2})
│   %8  = (%7)()::Core.Const(Val{2}())
│   %9  = Base.broadcasted(Base.literal_pow, %5, %6, %8)::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.literal_pow), Tuple{Base.RefValue{typeof(^)}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(-), Tuple{Vector{Float64}, Vector{Float64}}}, Base.RefValue{Val{2}}}}
│   %10 = Base.broadcasted(%4, %9, σs_squared)::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(-), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.literal_pow), Tuple{Base.RefValue{typeof(^)}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(-), Tuple{Vector{Float64}, Vector{Float64}}}, Base.RefValue{Val{2}}}}, Vector{Float64}}}
│   %11 = Base.materialize(%10)::Any
│   %12 = EBayes.mean(%11)::Any
│   %13 = EBayes.max(%12, 0.0001)::Any
│         (x0 = EBayes.sqrt(%13))
│         (x0 = Base.vect(x0))
└──       return x0::Vector

Notably, matrix-vector products are not even involved here. The issue with the stack overflow occurs only if we include the last step, the call to optimize. That one, by itself, is also not inferred, both on v1.9 and v1.10:

julia> @code_warntype EBayes.optimize(f_diff, dfc, x0, optimizer)
MethodInstance for Optim.optimize(::NLSolversBase.TwiceDifferentiable{Float64, Vector{Float64}, Matrix{Float64}, Vector{Float64}}, ::NLSolversBase.TwiceDifferentiableConstraints{NLSolversBase.var"#97#100", NLSolversBase.var"#98#101", NLSolversBase.var"#99#102", Float64}, ::Vector{Float64}, ::Optim.IPNewton{typeof(Optim.backtrack_constrained_grad), Symbol})
  from optimize(d::NLSolversBase.AbstractObjective, constraints::NLSolversBase.AbstractConstraints, initial_x::AbstractArray, method::Optim.ConstrainedOptimizer) @ Optim ~/.julia/packages/Optim/UkDyx/src/multivariate/solvers/constrained/ipnewton/interior.jl:187
Arguments
  #self#::Core.Const(Optim.optimize)
  d::NLSolversBase.TwiceDifferentiable{Float64, Vector{Float64}, Matrix{Float64}, Vector{Float64}}
  constraints::NLSolversBase.TwiceDifferentiableConstraints{NLSolversBase.var"#97#100", NLSolversBase.var"#98#101", NLSolversBase.var"#99#102", Float64}
  initial_x::Vector{Float64}
  method::Optim.IPNewton{typeof(Optim.backtrack_constrained_grad), Symbol}
Locals
  @_6::Optim.Options
Body::Optim.MultivariateOptimizationResults{Optim.IPNewton{typeof(Optim.backtrack_constrained_grad), Symbol}, _A, Vector{Float64}, Float64, Float64, Vector{Optim.OptimizationState{Float64, Optim.IPNewton{typeof(Optim.backtrack_constrained_grad), Symbol}}}, Nothing} where _A
1 ─ %1  = Base.NamedTuple()::Core.Const(NamedTuple())
│   %2  = Optim.default_options(method)::Union{Dict{Symbol, Bool}, Dict{Symbol, Integer}}
│   %3  = Base.merge(%1, %2)::NamedTuple
│   %4  = Base.isempty(%3)::Bool
└──       goto #3 if not %4
2 ─       (@_6 = Optim.Options())
└──       goto #4
3 ─       (@_6 = Core.kwcall(%3, Optim.Options))
4 ┄ %9  = @_6::Optim.Options
│   %10 = (#self#)(d, constraints, initial_x, method, %9)::Optim.MultivariateOptimizationResults{Optim.IPNewton{typeof(Optim.backtrack_constrained_grad), Symbol}, _A, Vector{Float64}, Float64, Float64, Vector{Optim.OptimizationState{Float64, Optim.IPNewton{typeof(Optim.backtrack_constrained_grad), Symbol}}}, Nothing} where _A
└──       return %10

But I somehow fail to see how #49806 could be related here. I need to investigate GroupErrors.jl.

[dkarrasch]

Could it be that the actually "bad" commit is the one before, DEV.1300 fbbe9ed? At least in the PR description, it talks about _methods_by_ftype, the ones we see in the @code_warntype fit(), where the stack overflow occurs. @vtjnash

EDIT: Hm, no, locally the fit() call passes without complaints on DEV.1300.

[maleadt]

I can reproduce on fbbe9ed. I'll try bisecting again.

[inkydragon]

I'm doing a manual bisect on Windows using the binaries built on CI.
Then compiled from source on Ubuntu for further confirmation.

There may be some minor differences due to different platforms.

When I was digging into other issues,
I've run into situations where the error appears, disappeared and then re-appeared.
Maybe these two commits aren't where the error was really introduced.

[dkarrasch]

Sadly, locally, my commit (1301) fails, whereas the previous one (1300) works fine:

julia> versioninfo()
Julia Version 1.10.0-DEV.1301
Commit 15d7bd872a* (2023-05-15 14:42 UTC)
Platform Info:
  OS: macOS (x86_64-apple-darwin21.6.0)
  CPU: 4 × Intel(R) Core(TM) i5-6500 CPU @ 3.20GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-15.0.7 (ORCJIT, skylake)
  Threads: 1 on 4 virtual cores

[maleadt]

The problematic type intersection:

using LinearAlgebra

a = Tuple{typeof(Base.eltype), Union{Type{var"#s177"} where var"#s177"<:DenseArray{Base.Complex{T}, 1}, Type{Base.ReinterpretArray{Base.Complex{T}, 1, S, A, IsReshaped}} where S where IsReshaped where A<:Union{Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T}, Type{Base.ReshapedArray{Base.Complex{T}, 1, A, MI}} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64}}} where A<:Union{Base.ReinterpretArray{T, N, S, A, IsReshaped} where S where IsReshaped where A<:Union{Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T} where N where T, Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T}, Type{Base.SubArray{Base.Complex{T}, 1, A, I, L}} where L where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex{N} where N, Base.AbstractRange{var"#s127"} where var"#s127"<:Union{Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}, Base.ReshapedArray{T, N, A, Tuple{}} where A<:(Base.AbstractUnitRange{T} where T) where N where T, Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}}} where A<:Union{Base.ReinterpretArray{T, N, S, A, IsReshaped} where S where IsReshaped where A<:Union{Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T} where N where T, Base.ReshapedArray{T, N, A, MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64}}} where A<:Union{Base.ReinterpretArray{T, N, S, A, IsReshaped} where S where IsReshaped where A<:Union{Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T} where N where T, Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T} where N where T, DenseArray{T, N} where N where T}} where T<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}

b = Tuple{typeof(Base.eltype), Type{var"#s16"} where var"#s16"<:(Union{Base.LogicalIndex{T, var"#s6"} where var"#s6"<:Src, Base.ReinterpretArray{T, N, var"#s1", var"#s2", IsReshaped} where IsReshaped where var"#s2"<:Union{Base.SubArray{var"#s3", var"#s4", var"#s13", I, L} where L where I where var"#s4" where var"#s3", var"#s13"} where var"#s1" where var"#s13"<:Src, Base.ReshapedArray{T, N, var"#s5", MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64}}} where var"#s5"<:Union{Base.ReinterpretArray{var"#s2", var"#s1", var"#s1", var"#s2", IsReshaped} where IsReshaped where var"#s2"<:Union{Base.SubArray{var"#s3", var"#s4", var"#s14", I, L} where L where I where var"#s4" where var"#s3", var"#s14"} where var"#s1" where var"#s1" where var"#s2", Base.SubArray{var"#s4", var"#s3", var"#s14", I, L} where L where I where var"#s3" where var"#s4", var"#s14"} where var"#s14"<:Src, Base.SubArray{T, N, var"#s6", I, L} where L where I where var"#s6"<:Union{Base.ReinterpretArray{var"#s3", var"#s2", var"#s1", var"#s2", IsReshaped} where IsReshaped where var"#s2"<:Union{Base.SubArray{var"#s3", var"#s4", var"#s15", I, L} where L where I where var"#s4" where var"#s3", var"#s15"} where var"#s1" where var"#s2" where var"#s3", Base.ReshapedArray{var"#s5", var"#s4", var"#s5", MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64}}} where var"#s5"<:Union{Base.ReinterpretArray{var"#s2", var"#s1", var"#s1", var"#s2", IsReshaped} where IsReshaped where var"#s2"<:Union{Base.SubArray{var"#s3", var"#s4", var"#s15", I, L} where L where I where var"#s4" where var"#s3", var"#s15"} where var"#s1" where var"#s1" where var"#s2", Base.SubArray{var"#s4", var"#s3", var"#s15", I, L} where L where I where var"#s3" where var"#s4", var"#s15"} where var"#s4" where var"#s5", var"#s15"} where var"#s15"<:Src, LinearAlgebra.Adjoint{T, var"#s2"} where var"#s2"<:Dst, LinearAlgebra.Diagonal{T, var"#s11"} where var"#s11"<:Dst, LinearAlgebra.LowerTriangular{T, var"#s7"} where var"#s7"<:Dst, LinearAlgebra.Transpose{T, var"#s1"} where var"#s1"<:Dst, LinearAlgebra.Tridiagonal{T, var"#s12"} where var"#s12"<:Dst, LinearAlgebra.UnitLowerTriangular{T, var"#s8"} where var"#s8"<:Dst, LinearAlgebra.UnitUpperTriangular{T, var"#s10"} where var"#s10"<:Dst, LinearAlgebra.UpperTriangular{T, var"#s9"} where var"#s9"<:Dst, Base.PermutedDimsArrays.PermutedDimsArray{T, N, var"#s5", var"#s4", var"#s3"} where var"#s3"<:Src where var"#s4" where var"#s5"} where Dst where Src where N)} where T

typeintersect(a, b)

Hangs on 1.10, works fine on 1.9.

[maleadt]

Further reduced:

a = Tuple{typeof(Base.eltype), Union{Type{<:DenseArray}, Type{Base.ReinterpretArray{T}} where T}}
b = Tuple{typeof(Base.eltype), Type{X} where X<:(Union{Base.ReinterpretArray{T, Y} where Y<:Union{SubArray{Z} where U, Z} where Z<:Src} where Src)} where T
typeintersect(a, b)

The free typevar U is important here. Bisect also blames #48228, cc @vtjnash @N5N3.

Confirmed that #48228 also causes the EBayes.jl inference overflow.

[inkydragon]

GroupedErrors.jl

• Julia Version 1.10.0-alpha1
  test code:

using GroupedErrors
using IndexedTables
using ShiftedArrays

# https://github.com/piever/GroupedErrors.jl/blob/50788643fbfece16e3ae32894e9eaa2a58c9a420/test/runtests.jl#L83-L96
v = [0, 0];
t = table([0, 0], ShiftedArray.((v,), [0, -1]), names = [:x, :y]);

fn_xx = arg_x -> arg_x.x;
gacross = GroupedErrors._across(t, fn_xx);
fn_argc = _ -> (-1:1);
fn_yy = arg_y -> arg_y.y;
gx = GroupedErrors._x(gacross, fn_argc, :discrete);
gy = GroupedErrors._y(gx, fn_yy);
ProcessedTable(gy);
# Internal error: stack overflow in type inference

Internal error: stack overflow in type inference of #_locreg#77(Function, typeof(GroupedErrors._locreg), Base.Val{:discrete}, Base.UnitRange{Int64}, IndexedTables.IndexedTable{StructArrays.StructArray{NamedTuple{(:across, :x, :y), Tuple{Int64, Base.UnitRange{Int64}, ShiftedArrays.ShiftedArray{Int64, Base.Missing, 1, Array{Int64, 1}}}}, 1, NamedTuple{(:across, :x, :y), Tuple{Array{Int64, 1}, Array{Base.UnitRange{Int64}, 1}, Array{ShiftedArrays.ShiftedArray{Int64, Base.Missing, 1, Array{Int64, 1}}, 1}}}, Int64}}).
This might be caused by recursion over very long tuples or argument lists.

[maleadt]

The GroupedErrors.jl case bisects to the same PR.