ui: use stacktrace-like view for showing reports

Since the stacktrace view shown by Julia Base upon exception is more
familiar to general users, it would be better to use the same view for
showing JET's abstract stacktrace.

Previously JET tries to "infer" the textual code representation of the
call-sites of each stack-frame, but now JET does not need to do so, and
JET can show the method signature of each abstract stack-frame from
their `MethodInstance` that is already available. Therefore, this commit
may result in some performance improvement.

Note that JET still computes the textual code representation with type
annotations for each error point. We may replace that part with
TypedSyntax.jl in the future since it would be more robust and nicer.

\## Examples: `@report_call sum([])`

> Before
```julia
═════ 1 possible error found ═════
┌ @ reducedim.jl:996 Base.:(var"#sum#821")(:, pairs(NamedTuple()), #self#, a)
│┌ @ reducedim.jl:996 Base._sum(a, dims)
││┌ @ reducedim.jl:1000 Base.:(var"#_sum#823")(pairs(NamedTuple()), #self#, a, _3)
│││┌ @ reducedim.jl:1000 Base._sum(identity, a, :)
││││┌ @ reducedim.jl:1001 Base.:(var"#_sum#824")(pairs(NamedTuple()), #self#, f, a, _4)
│││││┌ @ reducedim.jl:1001 mapreduce(f, Base.add_sum, a)
││││││┌ @ reducedim.jl:357 Base.:(var"#mapreduce#814")(:, Base._InitialValue(), #self#, f, op, A)
│││││││┌ @ reducedim.jl:357 Base._mapreduce_dim(f, op, init, A, dims)
││││││││┌ @ reducedim.jl:365 Base._mapreduce(f, op, IndexStyle(A), A)
│││││││││┌ @ reduce.jl:432 Base.mapreduce_empty_iter(f, op, A, Base.IteratorEltype(A))
││││││││││┌ @ reduce.jl:380 Base.reduce_empty_iter(Base.MappingRF(f, op), itr, ItrEltype)
│││││││││││┌ @ reduce.jl:384 Base.reduce_empty(op, eltype(itr))
││││││││││││┌ @ reduce.jl:361 Base.mapreduce_empty(op.f, op.rf, T)
│││││││││││││┌ @ reduce.jl:372 Base.reduce_empty(op, T)
││││││││││││││┌ @ reduce.jl:352 Base.reduce_empty(+, T)
│││││││││││││││┌ @ reduce.jl:343 zero(T)
││││││││││││││││┌ @ missing.jl:106 Base.throw(Base.MethodError(zero, tuple(Base.Any)))
│││││││││││││││││ MethodError: no method matching zero(::Type{Any}): Base.throw(Base.MethodError(zero, tuple(Base.Any)::Tuple{DataType})::MethodError)
││││││││││││││││└──────────────────
```
> After
```julia
═════ 1 possible error found ═════
┌ sum(a::Vector{Any}) @ Base ./reducedim.jl:996
│┌ sum(a::Vector{Any}; dims::Colon, kw::Base.@kwargs{}) @ Base ./reducedim.jl:996
││┌ _sum(a::Vector{Any}, ::Colon) @ Base ./reducedim.jl:1000
│││┌ _sum(a::Vector{Any}, ::Colon; kw::Base.@kwargs{}) @ Base ./reducedim.jl:1000
││││┌ _sum(f::typeof(identity), a::Vector{Any}, ::Colon) @ Base ./reducedim.jl:1001
│││││┌ _sum(f::typeof(identity), a::Vector{Any}, ::Colon; kw::Base.@kwargs{}) @ Base ./reducedim.jl:1001
││││││┌ mapreduce(f::typeof(identity), op::typeof(Base.add_sum), A::Vector{Any}) @ Base ./reducedim.jl:357
│││││││┌ mapreduce(f::typeof(identity), op::typeof(Base.add_sum), A::Vector{Any}; dims::Colon, init::Base._InitialValue) @ Base ./reducedim.jl:357
││││││││┌ _mapreduce_dim(f::typeof(identity), op::typeof(Base.add_sum), ::Base._InitialValue, A::Vector{Any}, ::Colon) @ Base ./reducedim.jl:365
│││││││││┌ _mapreduce(f::typeof(identity), op::typeof(Base.add_sum), ::IndexLinear, A::Vector{Any}) @ Base ./reduce.jl:432
││││││││││┌ mapreduce_empty_iter(f::typeof(identity), op::typeof(Base.add_sum), itr::Vector{Any}, ItrEltype::Base.HasEltype) @ Base ./reduce.jl:380
│││││││││││┌ reduce_empty_iter(op::Base.MappingRF{typeof(identity), typeof(Base.add_sum)}, itr::Vector{Any}, ::Base.HasEltype) @ Base ./reduce.jl:384
││││││││││││┌ reduce_empty(op::Base.MappingRF{typeof(identity), typeof(Base.add_sum)}, ::Type{Any}) @ Base ./reduce.jl:361
│││││││││││││┌ mapreduce_empty(::typeof(identity), op::typeof(Base.add_sum), T::Type{Any}) @ Base ./reduce.jl:372
││││││││││││││┌ reduce_empty(::typeof(Base.add_sum), ::Type{Any}) @ Base ./reduce.jl:352
│││││││││││││││┌ reduce_empty(::typeof(+), ::Type{Any}) @ Base ./reduce.jl:343
││││││││││││││││┌ zero(::Type{Any}) @ Base ./missing.jl:106
│││││││││││││││││ MethodError: no method matching zero(::Type{Any}): Base.throw(Base.MethodError(zero, tuple(Base.Any)::Tuple{DataType})::MethodError)
││││││││││││││││└────────────────────
```

\## Example 2
```julia
getprop(x) = x.nonexist;

report_call((Regex,)) do r
    getprop(r)
end
```

> Before
```julia
═════ 1 possible error found ═════
┌ @ REPL[30]:2 getprop(r)
│┌ @ REPL[29]:1 x.nonexist
││┌ @ Base.jl:37 Base.getfield(x, f)
│││ type Regex has no field nonexist
││└──────────────
```
> After
```julia
═════ 1 possible error found ═════
┌ (::var"#3#4")(r::Regex) @ Main ./REPL[12]:2
│┌ getprop(x::Regex) @ Main ./REPL[11]:1
││┌ getproperty(x::Regex, f::Symbol) @ Base ./Base.jl:37
│││ type Regex has no field nonexist: Base.getfield(x::Regex, f::Symbol)
││└────────────────────
```

Author: aviatesk

examples/find_unstable_api.jl

@@ -121,7 +121,6 @@ function JETInterface.print_report_message(io::IO, (; g)::UnstableAPI)
     msg = lazy"usage of unstable API `$mod.$name` found"
     print(io, "usage of unstable API `", mod, '.', name, "` found")
 end
-JETInterface.print_signature(::UnstableAPI) = false
 JETInterface.report_color(::UnstableAPI) = :yellow
 
 function (::UnstableAPIAnalysisPass)(::Type{UnstableAPI}, analyzer::UnstableAPIAnalyzer, sv, @nospecialize(e))

src/abstractinterpret/abstractanalyzer.jl

@@ -540,9 +540,9 @@ end
 @withmixedhash struct VirtualFrameNoLinfo
     file::Symbol
     line::Int
-    sig::Signature
+    # sig::Signature
     # linfo::MethodInstance # ignore the identity of `MethodInstance`
-    VirtualFrameNoLinfo(vf::VirtualFrame) = new(vf.file, vf.line, vf.sig)
+    VirtualFrameNoLinfo(vf::VirtualFrame) = new(vf.file, vf.line#=, vf.sig=#)
 end
 @withmixedhash struct DefaultReportIdentity
     T::DataType

src/abstractinterpret/inferenceerrorreport.jl

@@ -50,7 +50,6 @@ collected during abstract interpration, not collected from actual execution.
 @withmixedhash struct VirtualFrame
     file::Symbol
     line::Int
-    sig::Signature
     linfo::MethodInstance
 end
 
@@ -71,17 +70,15 @@ const INFERENCE_ERROR_REPORT_FIELD_DECLS = [
 
 # get location information at the given program counter (or a current counter if not specified)
 function get_virtual_frame(state::StateAtPC)
-    sig = get_sig(state)
     file, line = get_file_line(state)
     linfo = isa(state, MethodInstance) ? state : first(state).linfo
-    return VirtualFrame(file, line, sig, linfo)
+    return VirtualFrame(file, line, linfo)
 end
 get_virtual_frame(sv::InferenceState) = get_virtual_frame((sv, get_currpc(sv)))
 get_virtual_frame(caller::InferenceResult) = get_virtual_frame(get_linfo(caller))
 function get_virtual_frame(linfo::MethodInstance)
-    sig = get_sig(linfo)
     file, line = get_file_line(linfo)
-    return VirtualFrame(file, line, sig, linfo)
+    return VirtualFrame(file, line, linfo)
 end
 
 get_file_line(s::StateAtPC) = get_file_line(get_lin(s)::LineInfoNode)
@@ -97,8 +94,11 @@ end
 # signature
 # ---------
 
-get_sig(mi::MethodInstance) = Signature(Any[mi])
 @inline get_sig(s::StateAtPC, @nospecialize(x=get_stmt(s))) = Signature(get_sig_nowrap(s, x))
+get_sig(sv::InferenceState) = get_sig((sv, get_currpc(sv)))
+
+get_sig(mi::MethodInstance) = Signature(Any[mi])
+get_sig(caller::InferenceResult) = get_sig(get_linfo(caller))
 
 function get_sig_nowrap(@nospecialize args...)
     sig = Any[]
@@ -529,7 +529,9 @@ Base.show(io::IO, ::MIME"application/prs.juno.inline", report::InferenceErrorRep
 # the default constructor to create a report from abstract interpretation
 function (T::Type{<:InferenceErrorReport})(state, @nospecialize(spec_args...))
     vf = get_virtual_frame(state)
-    return T([vf], vf.sig, spec_args...)
+    vst = VirtualFrame[vf]
+    sig = get_sig(state)
+    return T(vst, sig, spec_args...)
 end
 
 # utility

src/analyzers/jetanalyzer.jl

@@ -516,15 +516,17 @@ This is reported only when it's not caught by control flow.
 end
 function UncaughtExceptionReport(sv::InferenceState, throw_calls::Vector{Tuple{Int,Expr}})
     vf = get_virtual_frame(sv.linfo)
-    sig = Any[]
+    vst = VirtualFrame[vf]
+    sigs = Any[]
     ncalls = length(throw_calls)
     for (i, (pc, call)) in enumerate(throw_calls)
         call_sig = get_sig_nowrap((sv, pc), call)
-        append!(sig, call_sig)
-        i ≠ ncalls && push!(sig, ", ")
+        append!(sigs, call_sig)
+        i ≠ ncalls && push!(sigs, ", ")
     end
+    sig = Signature(sigs)
     single_error = ncalls == 1
-    return UncaughtExceptionReport([vf], Signature(sig), single_error)
+    return UncaughtExceptionReport(vst, sig, single_error)
 end
 function print_report_message(io::IO, r::UncaughtExceptionReport)
     msg = r.single_error ? "may throw" : "may throw either of"
@@ -845,7 +847,6 @@ function print_report_message(io::IO, r::UndefVarErrorReport)
     end
     print(io, " is not defined")
 end
-print_signature(::UndefVarErrorReport) = false
 
 # undefined global variable report passes
 
@@ -1105,10 +1106,8 @@ abstract type AbstractBuiltinErrorReport <: InferenceErrorReport end
     @nospecialize(f)
     argtypes::Argtypes
     msg::AbstractString
-    print_signature::Bool = false
 end
 print_report_message(io::IO, r::BuiltinErrorReport) = print(io, r.msg)
-print_signature(r::BuiltinErrorReport) = r.print_signature
 const GENERAL_BUILTIN_ERROR_MSG = "invalid builtin function call"
 
 @static if VERSION ≥ v"1.10.0-DEV.197"
@@ -1218,7 +1217,7 @@ function (::BasicPass)(::Type{AbstractBuiltinErrorReport}, analyzer::JETAnalyzer
     end
     if @static VERSION >= v"1.10.0-DEV.197" ? (ret isa IntrinsicError) : false
         msg = LazyString(f, ": ", ret.reason)
-        report = BuiltinErrorReport(sv, f, argtypes, msg, #=print_signature=#true)
+        report = BuiltinErrorReport(sv, f, argtypes, msg)
         add_new_report!(analyzer, sv.result, report)
         return true
     end
@@ -1388,7 +1387,7 @@ function handle_invalid_builtins!(analyzer::JETAnalyzer, sv::InferenceState, @no
     # we don't bail out using `basic_filter` here because the native tfuncs are already very permissive
     if ret === Bottom
         msg = GENERAL_BUILTIN_ERROR_MSG
-        report = BuiltinErrorReport(sv, f, argtypes, msg, #=print_signature=#true)
+        report = BuiltinErrorReport(sv, f, argtypes, msg)
         add_new_report!(analyzer, sv.result, report)
         return true
     end
@@ -1401,7 +1400,6 @@ end
     msg::String = "this builtin function call may throw"
 end
 print_report_message(io::IO, r::UnsoundBuiltinErrorReport) = print(io, r.msg)
-print_signature(::UnsoundBuiltinErrorReport) = true
 
 function (::SoundPass)(::Type{AbstractBuiltinErrorReport}, analyzer::JETAnalyzer, sv::InferenceState, @nospecialize(f), argtypes::Argtypes, @nospecialize(rt))
     @assert !(f === throw) "`throw` calls should be handled either by the report pass of `SeriousExceptionReport` or `UncaughtExceptionReport`"

src/ui/print.jl

@@ -255,33 +255,98 @@ function print_stack(io, report, config, wrote_linfos, depth = 1)
     push!(wrote_linfos, linfo_hash)
 
     # print current frame and go into deeper
-    should_print && print_frame(io, frame, config, depth)
+    if should_print
+        color = RAIL_COLORS[(depth)%N_RAILS+1]
+        print_rails(io, depth-1)
+        printstyled(io, "┌ "; color)
+        print_frame_sig(io, frame)
+        print(io, " ")
+        print_frame_loc(io, frame, config, color)
+        println(io)
+    end
     print_stack(io, report, config, wrote_linfos, depth + 1)
 end
 
-function print_frame(io, frame, config, depth, color = RAIL_COLORS[(depth)%N_RAILS+1])
-    print_rails(io, depth-1)
+function print_frame_sig(io, frame)
+    mi = frame.linfo
+    m = mi.def
+    if m isa Module
+        Base.show_mi(io, mi, #=from_stackframe=#true)
+    else
+        show_spec_sig(IOContext(io, :backtrace=>true), m, mi.specTypes)
+    end
+end
 
-    s = string("┌ @ ", (config.fullpath ? tofullpath : identity)(string(frame.file)), ':', frame.line)
-    printstyled(io, s, ' '; color)
-    print_signature(io, frame.sig, config)
-    println(io)
+function print_frame_loc(io, frame, config, color)
+    def = frame.linfo.def
+    mod = def isa Module ? def : def.module
+    path = String(frame.file)
+    if config.fullpath
+        path = tofullpath(path)
+    elseif !isabspath(path)
+        path = "./" * path
+    end
+    printstyled(io, "@ "; color)
+    # IDEA use the same coloring as the Base stacktrace?
+    # modulecolor = get!(Base.STACKTRACE_FIXEDCOLORS, mod) do
+    #     popfirst!(Base.STACKTRACE_MODULECOLORS)
+    # end
+    modulecolor = color
+    printstyled(io, mod; color = modulecolor)
+    printstyled(io, ' ', path, ':', frame.line; color)
+end
 
-    return length(s) # the length of frame info string
+@static if VERSION ≥ v"1.10.0-DEV.1394"
+using Base.StackTraces: show_spec_sig
+else
+function show_spec_sig(io::IO, m::Method, @nospecialize(sig::Type))
+    if get(io, :limit, :false)::Bool
+        if !haskey(io, :displaysize)
+            io = IOContext(io, :displaysize => displaysize(io))
+        end
+    end
+    argnames = Base.method_argnames(m)
+    argnames = replace(argnames, :var"#unused#" => :var"")
+    if m.nkw > 0
+        # rearrange call kw_impl(kw_args..., func, pos_args...) to func(pos_args...; kw_args)
+        kwarg_types = Any[ fieldtype(sig, i) for i = 2:(1+m.nkw) ]
+        uw = Base.unwrap_unionall(sig)::DataType
+        pos_sig = Base.rewrap_unionall(Tuple{uw.parameters[(m.nkw+2):end]...}, sig)
+        kwnames = argnames[2:(m.nkw+1)]
+        for i = 1:length(kwnames)
+            str = string(kwnames[i])::String
+            if endswith(str, "...")
+                kwnames[i] = Symbol(str[1:end-3])
+            end
+        end
+        Base.show_tuple_as_call(io, m.name, pos_sig;
+                                demangle=true,
+                                kwargs=zip(kwnames, kwarg_types),
+                                argnames=argnames[m.nkw+2:end])
+    else
+        Base.show_tuple_as_call(io, m.name, sig; demangle=true, argnames)
+    end
 end
+end # @static if VERSION ≥ v"1.10.0-DEV.1394"
 
 function print_error_frame(io, report, config, depth)
     frame = report.vst[depth]
-
     color = report_color(report)
-    len = print_frame(io, frame, config, depth, color)
+
+    print_rails(io, depth-1)
+    printstyled(io, "┌ "; color)
+    print_frame_sig(io, frame)
+    print(io, " ")
+    print_frame_loc(io, frame, config, color)
+    println(io)
+
     print_rails(io, depth-1)
     printstyled(io, "│ "; color)
     print_report(io, report)
     println(io)
 
     print_rails(io, depth-1)
-    printlnstyled(io, '└', '─'^len; color)
+    printlnstyled(io, '└', '─'^20; color)
 end
 
 function print_report(io::IO, report::InferenceErrorReport)

src/ui/vscode.jl

@@ -3,14 +3,14 @@ module VSCode
 import ..JET:
     gen_postprocess,
     tofullpath,
-    print_signature,
     AbstractAnalyzer,
     JETToplevelResult,
     ToplevelErrorReport,
     JETCallResult,
     InferenceErrorReport,
     get_reports,
-    print_report
+    print_report,
+    print_frame_sig
 
 # common
 # ======
@@ -102,8 +102,7 @@ function vscode_diagnostics(analyzer::Analyzer,
                             line = showpoint.line,
                             severity = 1, # 0: Error, 1: Warning, 2: Information, 3: Hint
                             relatedInformation = map((order ? identity : reverse)(report.vst)) do frame
-                                sig = sprint(print_signature, frame.sig, (; annotate_types = true))
-                                return (; msg = postprocess(sig),
+                                return (; msg = postprocess(sprint(print_frame_sig, frame)),
                                           path = tovscodepath(frame.file),
                                           line = frame.line,
                                           )