Avoid capturing stacktrace, just use rethrow instead

Author: aviatesk

src/macro_expansion.jl

@@ -79,21 +79,13 @@ struct MacroExpansionError
     ex::SyntaxTree
     msg::String
     position::Symbol
-    stacktrace::Vector{Base.StackTraces.StackFrame}
 end
 
 """
 `position` - the source position relative to the node - may be `:begin` or `:end` or `:all`
 """
 function MacroExpansionError(ex::SyntaxTree, msg::AbstractString; position=:all)
-    MacroExpansionError(nothing, ex, msg, position, scrub_expand_macro_stacktrace(stacktrace(backtrace())))
-end
-
-function scrub_expand_macro_stacktrace(stacktrace::Vector{Base.StackTraces.StackFrame})
-    idx = @something findfirst(stacktrace) do stackframe::Base.StackTraces.StackFrame
-        stackframe.func === :expand_macro && stackframe.file === Symbol(@__FILE__)
-    end error("`scrub_expand_macro_stacktrace` is expected to be called from `expand_macro`")
-    return stacktrace[1:idx-1]
+    MacroExpansionError(nothing, ex, msg, position)
 end
 
 function Base.showerror(io::IO, exc::MacroExpansionError)
@@ -156,12 +148,13 @@ function expand_macro(ctx::MacroExpansionContext, ex::SyntaxTree)
         # TODO: Allow invoking old-style macros for compat
         invokelatest(macfunc, macro_args...)
     catch exc
+        # TODO: Using rethrow() is kinda ugh. Is there a way to avoid it?
+        # NOTE: Although currently rethrow() is necessary to allow outside catchers to access full stacktrace information
         if exc isa MacroExpansionError
             # Add context to the error.
-            # TODO: Using rethrow() is kinda ugh. Is there a way to avoid it?
-            rethrow(MacroExpansionError(mctx, exc.ex, exc.msg, exc.position, exc.stacktrace))
+            rethrow(MacroExpansionError(mctx, exc.ex, exc.msg, exc.position))
         else
-            throw(MacroExpansionError(mctx, ex, "Error expanding macro", :all, scrub_expand_macro_stacktrace(stacktrace(catch_backtrace()))))
+            rethrow(MacroExpansionError(mctx, ex, "Error expanding macro", :all))
         end
     end
 

test/macros.jl

@@ -150,27 +150,28 @@ macro m_throw(x)
     :(\$(f_throw(x)))
 end
 """)
-let ret = try
+let (err, st) = try
         JuliaLowering.include_string(test_mod, "_never_exist = @m_throw 42")
-    catch err
-        err
+    catch e
+        e, stacktrace(catch_backtrace())
     end
-    @test ret isa JuliaLowering.MacroExpansionError
-    @test length(ret.stacktrace) == 2
-    @test ret.stacktrace[1].func === :f_throw
-    @test ret.stacktrace[2].func === Symbol("@m_throw")
+    @test err isa JuliaLowering.MacroExpansionError
+    # Check that `catch_backtrace` can capture the stacktrace of the macro functions
+    @test any(sf->sf.func===:f_throw, st)
+    @test any(sf->sf.func===Symbol("@m_throw"), st)
 end
 
 include("ccall_demo.jl")
 @test JuliaLowering.include_string(CCall, "@ccall strlen(\"foo\"::Cstring)::Csize_t") == 3
-let ret = try
+let (err, st) = try
         JuliaLowering.include_string(CCall, "@ccall strlen(\"foo\"::Cstring)")
     catch e
-        e
+        e, stacktrace(catch_backtrace())
     end
-    @test ret isa JuliaLowering.MacroExpansionError
-    @test ret.msg == "Expected a return type annotation like `::T`"
-    @test any(sf->sf.func===:ccall_macro_parse, ret.stacktrace)
+    @test err isa JuliaLowering.MacroExpansionError
+    @test err.msg == "Expected a return type annotation like `::T`"
+    # Check that `catch_backtrace` can capture the stacktrace of the macro function
+    @test any(sf->sf.func===:ccall_macro_parse, st)
 end
 
 end # module macros