Optionally generated branches ignore errors

[cstjean]

When run interactively, or inside a file,

julia> function foo()
          if @generated
              error("some bug in code generation")
          else
              det(rand(100,100))
          end
      end
foo (generic function with 2 methods)

julia> foo()
3.0930222047

I know - the compiler is allowed to pick whichever branch it wants, so technically there's nothing wrong here. But this behavior (skipping to the alternative branch whenever there's an error in codegen) makes development really tricky, since nothing will suggest that there's anything wrong, assuming that the non-generated branch is correct.

I don't know how Julia decides which branch to run, but my expectation was that it would either run the codegen in the generated branch first (thus triggering the error), or at least run inference on the code-generation code (thus seeing that its output-type is Union{} - in which case it's clear that something's wrong). Could we get an error in those cases?

More generally, it'd be nice to have some guidelines about the compiler's decision process for optionally generated functions, because otherwise it's hard to rely on for performance. Perhaps that's a separate issue though.

[JeffBezanson]

I think the first thing to do is this patch:

--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -682,7 +682,7 @@ function code_lowered(@nospecialize(f), @nospecialize(t = Tuple); 
     return map(method_instances(f, t)) do m
         if generated && isgenerated(m)
             if isa(m, Core.MethodInstance)
-                return Core.Compiler.get_staged(m)
+                return ccall(:jl_code_for_staged, Any, (Any,), m)::CodeInfo
             else # isa(m, Method)
                 error("Could not expand generator for `@generated` method ", m, ". ",

Then at least code_lowered will expose such errors when you ask for the generated form.

[maleadt]

Dup of #25707