Error when trying to show an error

[glwagner]

I found this error

SYSTEM (REPL): showing an error caused an error
ERROR: TypeError: in typeassert, expected Symbol, got a value of type GlobalRef

from the MWE below. The MWE contains an error (undefined reference), but the error message cannot be printed.

using Reactant

mutable struct TestClock{I}
    iteration :: I
end

mutable struct TestSimulation{C, I}
    clock :: C
    stop_iteration :: I
    running :: Bool
end

function test_run!(sim)
    @info "Running..."
    while sim.running
        @trace if sim.clock.iteration >= sim.stop_iteration
            @info "Stopping simulation."
            sim.running = false
        else
            # Error:
            clock.iteration += 1 # time step

            # Correct:
            # sim.clock.iteration += 1 # time step
        end
    end
    return nothing
end

clock = TestClock(ConcreteRNumber(0))
simulation = TestSimulation(clock, 3, true)

r_run! = @compile sync=true test_run!(simulation)
r_run!(simulation)

[glwagner]

Hmm, I think the issue is associated with @info

            @info "Stopping simulation."

[wsmoses]

@jumerckx can you take a look at this?

[jumerckx]

With #794 this gives a different error

Stacktrace

ERROR: UndefVarError: `�J�]���Ѝ�` not defined in local scope
Suggestion: check for an assignment to a local variable that shadows a global of the same name.
Stacktrace:
  [1] macro expansion
    @ ~/Reactant.jl/lib/ReactantCore/src/ReactantCore.jl:375 [inlined]
  [2] step!
    @ ~/Reactant.jl/scratch/ocean.jl:16 [inlined]
  [3] step!(none::TestSimulation{TestClock{…}, Reactant.TracedRNumber{…}, Reactant.TracedRNumber{…}})
    @ Reactant ./<missing>:0
  [4] getproperty
    @ ./Base.jl:49 [inlined]
  [5] step!
    @ ~/Reactant.jl/scratch/ocean.jl:15 [inlined]
  [6] call_with_reactant(::typeof(step!), ::TestSimulation{…})
    @ Reactant ~/Reactant.jl/src/utils.jl:0
  [7] make_mlir_fn(f::Function, args::Vector{…}, kwargs::Tuple{}, name::String, concretein::Bool; toscalar::Bool, return_dialect::Symbol, args_in_result::Symbol, construct_function_without_args::Bool, do_transpose::Bool)
    @ Reactant.TracedUtils ~/Reactant.jl/src/TracedUtils.jl:261
  [8] make_mlir_fn
    @ ~/Reactant.jl/src/TracedUtils.jl:153 [inlined]
  [9] while_loop(cond_fn::var"#31#32", body_fn::typeof(step!), args::TestSimulation{…})
    @ Reactant.Ops ~/Reactant.jl/src/Ops.jl:1700
 [10] traced_while
    @ ~/Reactant.jl/src/ControlFlow.jl:12 [inlined]
 [11] traced_while(none::var"#31#32", none::typeof(step!), none::Tuple{TestSimulation{…}})
    @ Reactant ./<missing>:0
 [12] traced_while
    @ ~/Reactant.jl/src/ControlFlow.jl:12 [inlined]
 [13] call_with_reactant(::Reactant.MustThrowError, ::typeof(ReactantCore.traced_while), ::var"#31#32", ::typeof(step!), ::Tuple{…})
    @ Reactant ~/Reactant.jl/src/utils.jl:0
 [14] test_run!
    @ ~/Reactant.jl/scratch/ocean.jl:26 [inlined]
 [15] test_run!(none::TestSimulation{TestClock{…}, Reactant.TracedRNumber{…}, Reactant.TracedRNumber{…}})
    @ Reactant ./<missing>:0
 [16] test_run!
    @ ~/Reactant.jl/scratch/ocean.jl:26 [inlined]
 [17] call_with_reactant(::typeof(test_run!), ::TestSimulation{…})
    @ Reactant ~/Reactant.jl/src/utils.jl:0
 [18] make_mlir_fn(f::Function, args::Tuple{…}, kwargs::Tuple{}, name::String, concretein::Bool; toscalar::Bool, return_dialect::Symbol, args_in_result::Symbol, construct_function_without_args::Bool, do_transpose::Bool)
    @ Reactant.TracedUtils ~/Reactant.jl/src/TracedUtils.jl:261
 [19] make_mlir_fn
    @ ~/Reactant.jl/src/TracedUtils.jl:153 [inlined]
 [20] compile_mlir!(mod::Reactant.MLIR.IR.Module, f::Function, args::Tuple{…}, callcache::Dict{…}; optimize::Bool, no_nan::Bool, backend::String)
    @ Reactant.Compiler ~/Reactant.jl/src/Compiler.jl:600
 [21] compile_mlir!
    @ ~/Reactant.jl/src/Compiler.jl:575 [inlined]
 [22] (::Reactant.Compiler.var"#7#8"{@Kwargs{no_nan::Bool, optimize::Bool}, typeof(test_run!), Tuple{TestSimulation{…}}})()
    @ Reactant.Compiler ~/Reactant.jl/src/Compiler.jl:494
 [23] context!(f::Reactant.Compiler.var"#7#8"{@Kwargs{…}, typeof(test_run!), Tuple{…}}, ctx::Reactant.MLIR.IR.Context)
    @ Reactant.MLIR.IR ~/Reactant.jl/src/mlir/IR/Context.jl:76
 [24] compile_mlir(f::Function, args::Tuple{…}; client::Nothing, kwargs::@Kwargs{…})
    @ Reactant.Compiler ~/Reactant.jl/src/Compiler.jl:491
 [25] top-level scope
    @ ~/Reactant.jl/src/Compiler.jl:1013
Some type information was truncated. Use `show(err)` to see complete types.

This is not too surprising, @info et. al. expand into a lot of code that is difficult to trace through, especially within traced_while/if. I haven't dug deep into what exactly is going wrong, though.
Even still, printing would only occur at compile time, as the code is being traced, so it's purely for debugging.
For debug printing in functions that are being traced, I would just resort to println (or even Core.println as a last resort), those should work.

[glwagner]

You could print an error that says something like "@info was found on line X, but @info is not allowed in traced functions"

[avik-pal]

You could print an error that says something like "@info was found on line X, but @info is not allowed in traced functions"

We won't be able to detect @info/@warn, etc. Those get expanded into Base.CoreLogging, but there isn't a nice way to tell if it originated from those macros.

In this case, we might be able to call macroexpand inside our trace macro to fix it.