Add unwrap_error and recommend it for introspecting compiler errors

The error hint tells users to catch the exception as `err` and call
`code_typed(err; interactive=true)`, but in the REPL the `err` global is a
`Base.ExceptionStack`, and errors from `include`d files are wrapped in
`LoadError`, so that advice often fails. Provide `GPUCompiler.unwrap_error`
to strip these wrappers and update the hint to use it, instead of committing
type piracy on the `InteractiveUtils` reflection functions.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: vchuravy

src/error.jl

@@ -25,6 +25,19 @@ end
 Base.show(io::IO, err::KernelError) = showerror(io, err)
 
 
+"""
+    unwrap_error(err)
+
+Unwrap a compiler exception from container exceptions such as the REPL's `err` global
+(a `Base.ExceptionStack`) or the `LoadError` thrown by `include`, so that it can be
+passed to reflection functions like `code_typed`. Other exceptions are returned as-is.
+"""
+unwrap_error(err) = err
+unwrap_error(err::Base.ExceptionStack) =
+    isempty(err.stack) ? err : unwrap_error(last(err.stack).exception)
+unwrap_error(err::LoadError) = unwrap_error(err.error)
+
+
 struct InternalCompilerError <: Exception
     job::CompilerJob
     message::String

src/validation.jl

@@ -153,7 +153,8 @@ function Base.showerror(io::IO, err::InvalidIRError)
     printstyled(io, "Hint"; bold = true, color = :cyan)
     printstyled(
         io,
-        ": catch this exception as `err` and call `code_typed(err; interactive = true)` to",
+        ": catch this exception as `err` and call",
+        " `code_typed(GPUCompiler.unwrap_error(err); interactive = true)` to",
         " introspect the erroneous code with Cthulhu.jl";
         color = :cyan,
     )

test/native.jl

@@ -1,3 +1,5 @@
+using InteractiveUtils
+
 @testset "reflection" begin
     job, _ = Native.create_job(identity, (Int,))
 
@@ -622,6 +624,25 @@ end
     end
 end
 
+@testset "unwrap_error" begin
+    mod = @eval module $(gensym())
+        foobar(i) = println(i)
+    end
+
+    stack = try
+        Native.code_execution(mod.foobar, Tuple{Int})
+        nothing
+    catch
+        current_exceptions()
+    end
+    @test stack isa Base.ExceptionStack
+    err = GPUCompiler.unwrap_error(stack)
+    @test err isa GPUCompiler.InvalidIRError
+    @test GPUCompiler.unwrap_error(err) === err
+    @test GPUCompiler.unwrap_error(LoadError("foo.jl", 1, err)) === err
+    @test only(code_typed(GPUCompiler.unwrap_error(stack))) isa Pair
+end
+
 @testset "invalid LLVM IR (ccall)" begin
     mod = @eval module $(gensym())
         function foobar(p)