In errorshow UI, filter out frames for _include implementation

This simplifies stack traces for include() which were made much more
complex by moving jl_parse_eval_all to the Julia layer.

Author: c42f

base/errorshow.jl

@@ -681,6 +681,42 @@ function is_kw_sorter_name(name::Symbol)
     return !startswith(sn, '#') && endswith(sn, "##kw")
 end
 
+# For improved user experience, filter out frames for include() implementation
+# - see #33065. See also #35371 for extended discussion of internal frames.
+function _simplify_include_frames(trace)
+    kept_frames = trues(length(trace))
+    i = length(trace)
+    first_ignored = nothing
+    while i >= 1
+        frame,_ = trace[i]
+        mod = parentmodule(frame)
+        if isnothing(first_ignored)
+            if mod === Base && frame.func === :_include
+                # Hide include() machinery by default
+                first_ignored = i
+            end
+        else
+            # Hack: allow `mod==nothing` as a workaround for inlined functions.
+            # TODO: Fix this by improving debug info.
+            if mod in (Base,Core,nothing) && 1+first_ignored-i <= 5
+                if frame.func == :eval
+                    @debug "Ignoring frames" removed=trace[i:first_ignored]
+                    kept_frames[i:first_ignored] .= false
+                    first_ignored = nothing
+                end
+            else
+                # Bail out to avoid hiding frames in unexpected circumstances
+                first_ignored = nothing
+            end
+        end
+        i -= 1
+    end
+    if !isnothing(first_ignored)
+        kept_frames[i:first_ignored] .= false
+    end
+    trace[kept_frames]
+end
+
 function process_backtrace(t::Vector, limit::Int=typemax(Int); skipC = true)
     n = 0
     last_frame = StackTraces.UNKNOWN
@@ -721,7 +757,7 @@ function process_backtrace(t::Vector, limit::Int=typemax(Int); skipC = true)
     if n > 0
         push!(ret, (last_frame, n))
     end
-    return ret
+    return _simplify_include_frames(ret)
 end
 
 function show_exception_stack(io::IO, stack::Vector)

base/stacktraces.jl

@@ -268,22 +268,29 @@ function show(io::IO, frame::StackFrame; full_path::Bool=false)
     end
 end
 
+function Base.parentmodule(frame::StackFrame)
+    if frame.linfo isa MethodInstance
+        def = frame.linfo.def
+        if def isa Module
+            return def
+        else
+            @assert def isa Method
+            return def.module
+        end
+    else
+        # Bug: currently the module is not available for inlined frames and
+        # frames arising from the interpreter.
+        nothing
+    end
+end
+
 """
     from(frame::StackFrame, filter_mod::Module) -> Bool
 
 Returns whether the `frame` is from the provided `Module`
 """
 function from(frame::StackFrame, m::Module)
-    finfo = frame.linfo
-    result = false
-
-    if finfo isa MethodInstance
-        frame_m = finfo.def
-        isa(frame_m, Method) && (frame_m = frame_m.module)
-        result = nameof(frame_m) === nameof(m)
-    end
-
-    return result
+    parentmodule(frame) == m
 end
 
 end

test/errorshow.jl

@@ -704,3 +704,14 @@ for (func,str) in ((TestMethodShadow.:+,":+"), (TestMethodShadow.:(==),":(==)"),
     end::MethodError
     @test occursin("You may have intended to import Base.$str", sprint(Base.showerror, ex))
 end
+
+# Test that implementation detail of include() is hidden from the user by default
+let bt = try
+        include("testhelpers/include_error.jl")
+    catch
+        catch_backtrace()
+    end
+    bt_str = sprint(Base.show_backtrace, bt)
+    @test occursin(" include(", bt_str)
+    @test !occursin(" _include(", bt_str)
+end

test/testhelpers/include_error.jl

@@ -0,0 +1 @@
+error("Expected exception while running include")