hide internally created methods in stacktraces that occur as a result of argument forwarding

[KristofferC]

Inspired by #49044, I tried to make a small incremental improvement. This hides some frames that are automatically generated in kw... forwarding.

Running

julia> sum([])

and looking at the stacktrace we have before:

[12] #_sum#810
@ ./reducedim.jl:999 [inlined]
[13] _sum
@ ./reducedim.jl:999 [inlined]
[14] #_sum#809
@ ./reducedim.jl:998 [inlined]
[15] _sum
@ ./reducedim.jl:998 [inlined]
[16] #sum#807
@ ./reducedim.jl:994 [inlined]
[17] sum(a::Vector{Any})
@ Base ./reducedim.jl:994
[18] top-level scope
@ REPL[1]:1

and after:

 [11] _sum
    @ ./reducedim.jl:999 [inlined]
 [12] _sum
    @ ./reducedim.jl:998 [inlined]
 [13] sum(a::Vector{Any})
    @ Base ./reducedim.jl:994
 [14] top-level scope
    @ REPL[5]:1

The "MWE" for this is

f(g, a; kw...) = error();
@inline f(a; kw...) = f(identity, a; kw...);
f(1)

which before shows as

julia> f(1)
ERROR: 
Stacktrace:
 [1] error()
   @ Base ./error.jl:44
 [2] f(g::Function, a::Int64; kw::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
   @ Main ./REPL[1]:1
 [3] f(g::Function, a::Int64)
   @ Main ./REPL[1]:1
 [4] #f#4
   @ ./REPL[2]:1 [inlined]
 [5] f(a::Int64)
   @ Main ./REPL[2]:1
 [6] top-level scope
   @ REPL[3]:1

and after (frame 4 above removed).

julia> f(1)
ERROR: 
Stacktrace:
 [1] error()
   @ Base ./error.jl:44
 [2] f(g::Function, a::Int64; kw::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
   @ Main ./REPL[7]:1
 [3] f(g::Function, a::Int64)
   @ Main ./REPL[7]:1
 [4] f(a::Int64)
   @ Main ./REPL[6]:1
 [5] top-level scope
   @ REPL[8]:1

---

There are more cases to detect, for example:

julia> g(x, y=1, z=2) = error()
g (generic function with 3 methods)

julia> g(1)
ERROR: 
Stacktrace:
 [1] error()
   @ Base ./error.jl:44
 [2] g(x::Int64, y::Int64, z::Int64)
   @ Main ./REPL[5]:1
 [3] g(x::Int64)
   @ Main ./REPL[5]:1
 [4] top-level scope
   @ REPL[6]:1

could maybe hide [3] (or [2]??) but it is also a bit hard to not also filter out "real" calls.

[vtjnash]

Can we move the kwcall hiding into the same place (instead of the process_backtrace function below), using this same approach of looking at the parent too?

[KristofferC]

What would the kwcall check in the parent?

Looking at

julia> f(; a, b) = error()

julia> f(a=3)
ERROR: UndefKeywordError: keyword argument `b` not assigned
Stacktrace:
 [1] kwcall(::NamedTuple{(:a,), Tuple{Int64}}, ::typeof(f))
   @ Main ./REPL[2]:1
 [2] top-level scope
   @ REPL[4]:1

there doesn't even really seem to be a parent to the kwcall?

[timholy]

Thanks for tackling this!

[KristofferC]

Looking at another case of non ideal stacktraces:

f(g, a; kw...) = error();
f(a; kw...) = f(identity, a; kw...);
f(1; kw=3)

giving

ERROR: 
Stacktrace:
 [1] error()
   @ Base ./error.jl:44
 [2] f(g::Function, a::Int64; kw::Base.Pairs{Symbol, Int64, Tuple{Symbol}, NamedTuple{(:kw,), Tuple{Int64}}})
   @ Main ./REPL[1]:1
 [3] f(a::Int64; kw::Base.Pairs{Symbol, Int64, Tuple{Symbol}, NamedTuple{(:kw,), Tuple{Int64}}})
   @ Main ./REPL[2]:1
 [4] top-level scope
   @ REPL[4]:1
 [5] top-level scope
   @ ~/julia/usr/share/julia/stdlib/v1.10/REPL/src/REPL.jl:1410

seems like the printing of the kw arg could be improved. But that doesn't really have anything to do with collapsing frames.

[timholy]

The new code LGTM. Merge at will.

[vtjnash]

Seems like you meant just last_params[(last_m.nkw+2):end] here, since the rest doesn't generally make sense

[KristofferC]

I took it from here:

julia/base/stacktraces.jl

Line 232 in 703b3f8

pos_sig = Base.rewrap_unionall(Tuple{uw.parameters[(def.nkw+2):end]...}, sig)

[vtjnash]

That is useful if you want to do subtyping queries, but it doesn't seem like you wanted to?

[vtjnash]

You potentially could phrase it as a subtyping query though, by adding Vararg to the shorter one