`Base.is_valid_identifier` infers much more poorly versus Scheme lowering

[topolarity]

The JET.jl avi/demo branch (https://github.com/aviatesk/JET.jl/tree/avi/demo) includes a prototype / proof-of-concept pipeline that exercises JuliaLowering for its code pipeline.

Scheme lowering does OK with Base.is_valid_identifier, if I test via normal JET.jl:

julia> @report_opt Base.is_valid_identifier(:foo)
No errors detected

JL's AST interpolation seems to lead to inference problems if using the avi/demo branch of JET.jl:

julia> @report_opt Base.is_valid_identifier(:foo)
═════ 17 possible errors found ═════

The problems seem to center around the interpolate_ast AST function. In contrast, Scheme lowering seems to require no runtime function injection:

julia> @code_lowered Base.is_valid_identifier(:foo)
CodeInfo(
1 ─ %1  = Base.isidentifier
│   %2  =   dynamic (%1)(sym)
└──       goto #3 if not %2
2 ─       return %2
3 ─ %5  = Base._isoperator
│   %6  =   dynamic (%5)(sym)
└──       goto #7 if not %6
4 ─ %8  = Base.:!
│   %9  = Base.in
│   %10 = Base.Symbol
│   %11 =   dynamic (%10)("'")
│   %12 =   builtin Core.tuple(%11, :(::), :?)
│   %13 =   dynamic (%9)(sym, %12)
│   %14 =   dynamic (%8)(%13)
└──       goto #6 if not %14
5 ─ %16 = Base.:!
│   %17 = Base.is_syntactic_operator
│   %18 =   dynamic (%17)(sym)
│   %19 =   dynamic (%16)(%18)
└──       return %19
6 ─       return false
7 ─       return false
)

Full JET stacktrace

julia> @report_opt Base.is_valid_identifier(:foo)
═════ 17 possible errors found ═════
┌ is_valid_identifier(sym::Symbol) @ Base ./:1778
│┌ interpolate_ast(::Type{JuliaLowering.SyntaxTree}, ::JuliaLowering.SyntaxTree{JuliaLowering.SyntaxGraph{Dict{…}}}) @ JuliaLowering ./:152
││┌ _setup_interpolation(::Type{…}, ex::JuliaLowering.SyntaxTree{…}, values::Tuple{}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/runtime.jl:123
│││ failed to optimize due to recursion: JuliaLowering._setup_interpolation(::Type{…}, ::JuliaLowering.SyntaxTree{…}, ::Tuple{})
││└────────────────────
│┌ interpolate_ast(::Type{JuliaLowering.SyntaxTree}, ::JuliaLowering.SyntaxTree{JuliaLowering.SyntaxGraph{Dict{…}}}) @ JuliaLowering ./:156
││┌ copy_ast(ctx::JuliaLowering.InterpolationContext, ex::JuliaLowering.SyntaxTree{JuliaLowering.SyntaxGraph{Dict{…}}}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:438
│││┌ copy_ast(ctx::JuliaLowering.InterpolationContext, ex::JuliaLowering.SyntaxTree{…}; copy_source::Bool) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:442
││││┌ _copy_ast(graph2::JuliaLowering.SyntaxGraph, graph1::JuliaLowering.SyntaxGraph{…}, id1::Int64, seen::Dict{…}, copy_source::Bool) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:453
│││││┌ get(ex::JuliaLowering.SyntaxTree{JuliaLowering.SyntaxGraph{Dict{Symbol, Any}}}, name::Symbol, default::Nothing) @ JuliaLowering ./:252
││││││ runtime dispatch detected: JuliaLowering.get(%3::Any, %7::Int64, default::Nothing)::Any
│││││└────────────────────
││││┌ _copy_ast(graph2::JuliaLowering.SyntaxGraph, graph1::JuliaLowering.SyntaxGraph{…}, id1::Int64, seen::Dict{…}, copy_source::Bool) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:464
│││││┌ kwcall(::NamedTuple{…}, ::typeof(JuliaLowering.setattr!), graph::JuliaLowering.SyntaxGraph, id::Int64) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/syntax_graph.jl:150
││││││┌ setattr!(graph::JuliaLowering.SyntaxGraph, id::Int64; attrs::Base.Pairs{…} where {…}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/syntax_graph.jl:151
│││││││┌ iterate(::Base.Pairs{Symbol, _A, Nothing, A} where {_A, A<:(NamedTuple{(:source,), <:Tuple{Any}})}) @ Base.Iterators ./iterators.jl:290
││││││││ runtime dispatch detected: Base.Iterators._pairs_elt(p::Base.Pairs{Symbol, _A, Nothing, A} where {_A, A<:(NamedTuple{(:source,), <:Tuple{Any}})}, :source)::Pair{Symbol}
│││││││└────────────────────
││││││┌ setattr!(graph::JuliaLowering.SyntaxGraph, id::Int64; attrs::Base.Pairs{…} where {…}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/syntax_graph.jl:153
│││││││┌ getattr(graph::JuliaLowering.SyntaxGraph{<:Dict}, name::Symbol) @ JuliaLowering ./:134
││││││││┌ getindex(h::Dict, key::Symbol) @ Base ./dict.jl:476
│││││││││┌ ht_keyindex(h::Dict, key::Symbol) @ Base ./dict.jl:249
││││││││││┌ ==(w::Symbol, v::WeakRef) @ Base ./:36
│││││││││││ runtime dispatch detected: isequal(w::Symbol, %1::Any)::Bool
││││││││││└────────────────────
│┌ interpolate_ast(::Type{JuliaLowering.SyntaxTree}, ::JuliaLowering.SyntaxTree{JuliaLowering.SyntaxGraph{Dict{…}}}) @ JuliaLowering ./:157
││┌ ==(w::WeakRef, v::JuliaSyntax.Kind) @ Base ./:35
│││ runtime dispatch detected: isequal(%1::Any, v::JuliaSyntax.Kind)::Bool
││└────────────────────
│┌ interpolate_ast(::Type{JuliaLowering.SyntaxTree}, ::JuliaLowering.SyntaxTree{JuliaLowering.SyntaxGraph{Dict{…}}}) @ JuliaLowering ./:167
││┌ _interpolate_ast(ctx::JuliaLowering.InterpolationContext, ex::JuliaLowering.SyntaxTree, depth::Int64) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/runtime.jl:113
│││┌ _interpolated_value(ctx::JuliaLowering.InterpolationContext, srcref::JuliaLowering.SyntaxTree, ex::Any) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/runtime.jl:74
││││┌  @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/macro_expansion.jl:325
│││││┌ makenode(ctx::JuliaLowering.InterpolationContext, srcref::Tuple{…}, proto::JuliaLowering.SyntaxTree, children::Vararg{…}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:134
││││││┌ makenode(ctx::JuliaLowering.InterpolationContext, srcref::Tuple{…}, proto::JuliaLowering.SyntaxTree, children::Vararg{…}; attrs::@Kwargs{}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:135
│││││││┌ _makenode(ctx::JuliaLowering.InterpolationContext, srcref::Tuple{…}, proto::JuliaLowering.SyntaxTree, children::Tuple{…}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:130
││││││││┌ _makenode(ctx::JuliaLowering.InterpolationContext, srcref::Tuple{…}, proto::JuliaLowering.SyntaxTree, children::Tuple{…}; attrs::@Kwargs{}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:131
│││││││││┌ _makenode(ctx::Any, srcref::Any, proto::JuliaLowering.SyntaxTree, children::Any; attrs::@Kwargs{}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:131
││││││││││┌ _makenode(graph::JuliaLowering.SyntaxGraph, srcref::Any, proto::JuliaLowering.SyntaxTree, children::Any) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:122
│││││││││││┌ _makenode(graph::JuliaLowering.SyntaxGraph, srcref::Any, proto::JuliaLowering.SyntaxTree, children::Any; attrs::@Kwargs{}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:124
││││││││││││┌ setchildren!(graph::JuliaLowering.SyntaxGraph, id::Int64, children::Any) @ JuliaLowering ./:110
│││││││││││││┌ append!(a::Vector{Int64}, iter::Any) @ Base ./:1357
││││││││││││││┌ _append!(a::Vector{Int64}, ::Union{Base.HasLength, Base.HasShape}, iter::Any) @ Base ./:1366
│││││││││││││││┌ push!(a::Vector{Int64}, item::Any) @ Base ./array.jl:1285
││││││││││││││││ runtime dispatch detected: convert(::Int64, item::Any)::Any
│││││││││││││││└────────────────────
││││┌ iterate(g::Base.Generator{…} where {…}, s::Tuple{…}) @ Base ./:45
│││││┌ iterate(A::JuliaLowering.SyntaxList, state::Tuple{Base.OneTo{Int64}, Int64}) @ Base ./abstractarray.jl:1235
││││││┌ getindex(v::JuliaLowering.SyntaxList, i::Int64) @ JuliaLowering ./:725
│││││││┌ JuliaLowering.SyntaxTree(graph::JuliaLowering.SyntaxGraph, node::JuliaSyntax.SyntaxNode) @ JuliaLowering ./:450
││││││││┌ kwcall(::@NamedTuple{…}, ::typeof(JuliaLowering.ensure_attributes!), graph::JuliaLowering.SyntaxGraph) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/syntax_graph.jl:52
│││││││││┌ ensure_attributes!(graph::JuliaLowering.SyntaxGraph; kws::Base.Pairs) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/syntax_graph.jl:53
││││││││││┌ iterate(::Base.Pairs) @ Base.Iterators ./iterators.jl:290
│││││││││││┌ _pairs_elt(p::Base.Pairs, idx::Any) @ Base.Iterators ./iterators.jl:283
││││││││││││ runtime dispatch detected: (%4::Any)[idx::Any]::Any
│││││││││││└────────────────────
│││││││┌ JuliaLowering.SyntaxTree(graph::JuliaLowering.SyntaxGraph, node::JuliaSyntax.SyntaxNode) @ JuliaLowering ./:452
││││││││┌ _convert_nodes(graph::JuliaLowering.SyntaxGraph, node::JuliaSyntax.SyntaxNode) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/syntax_graph.jl:188
│││││││││┌ kwcall(::NamedTuple{…}, ::typeof(JuliaLowering.setattr!), graph::JuliaLowering.SyntaxGraph, id::Int64) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/syntax_graph.jl:150
││││││││││┌ setattr!(graph::JuliaLowering.SyntaxGraph, id::Int64; attrs::Base.Pairs{…} where {…}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/syntax_graph.jl:151
│││││││││││┌ iterate(::Base.Pairs{Symbol, _A, Nothing, A} where {_A, A<:(NamedTuple{(:value,), <:Tuple{Any}})}) @ Base.Iterators ./iterators.jl:290
││││││││││││ runtime dispatch detected: Base.Iterators._pairs_elt(p::Base.Pairs{Symbol, _A, Nothing, A} where {_A, A<:(NamedTuple{(:value,), <:Tuple{Any}})}, :value)::Pair{Symbol}
│││││││││││└────────────────────
││││││││┌ _convert_nodes(graph::JuliaLowering.SyntaxGraph, node::JuliaSyntax.SyntaxNode) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/syntax_graph.jl:193
│││││││││┌ map(f::JuliaLowering.var"#_convert_nodes##0#_convert_nodes##1"{JuliaLowering.SyntaxGraph{…}} where Attrs, A::Nothing) @ Base ./:3402
││││││││││ runtime dispatch detected: Base.Generator(f::JuliaLowering.var"#_convert_nodes##0#_convert_nodes##1"{JuliaLowering.SyntaxGraph{Attrs}} where Attrs, A::Nothing)::Base.Generator{…} where F<:(JuliaLowering.var"#_convert_nodes##0#_convert_nodes##1"{…} where Attrs)
│││││││││└────────────────────
│││││││││┌ map(f::JuliaLowering.var"#_convert_nodes##0#_convert_nodes##1"{JuliaLowering.SyntaxGraph{…}} where Attrs, A::Nothing) @ Base ./:3402
││││││││││ runtime dispatch detected: collect(%1::Base.Generator{…} where F<:(JuliaLowering.var"#_convert_nodes##0#_convert_nodes##1"{…} where Attrs))
│││││││││└────────────────────
│││││││││┌ map(f::JuliaLowering.var"#_convert_nodes##0#_convert_nodes##1", A::Array) @ Base ./:3372
││││││││││┌ collect_similar(cont::Array, itr::Base.Generator) @ Base ./:732
│││││││││││┌ _collect(c::Array, itr::Base.Generator, ::Base.EltypeUnknown, isz::Base.SizeUnknown) @ Base ./:805
││││││││││││┌ grow_to!(dest::Vector, itr::Base.Generator) @ Base ./:867
│││││││││││││┌ grow_to!(dest::Vector, itr::Base.Generator, st::Any) @ Base ./array.jl:891
││││││││││││││┌ push_widen(dest::Vector, el::Any) @ Base ./:877
│││││││││││││││┌ append!(a::Vector, iter::Vector) @ Base ./:1357
││││││││││││││││┌ _append!(a::Vector, ::Base.HasShape{1}, iter::Vector) @ Base ./:1365
│││││││││││││││││┌ iterate(A::Vector) @ Base ./array.jl:901
││││││││││││││││││┌ iterate(A::Vector, i::Int64) @ Base ./array.jl:901
│││││││││││││││││││ runtime dispatch detected: (A::Vector)[i::Int64]::Any
││││││││││││││││││└────────────────────
│││││││││││┌ _collect(c::Array, itr::Base.Generator, ::Base.EltypeUnknown, isz::Union{Base.HasLength, Base.HasShape}) @ Base ./array.jl:820
││││││││││││┌ collect_to_with_first!(dest::AbstractArray, v1::Any, itr::Base.Generator, st::Any) @ Base ./array.jl:824
│││││││││││││┌ LinearIndices(inds::CartesianIndices) @ Base.IteratorsMD ./multidimensional.jl:591
││││││││││││││┌ all(f::Base.IteratorsMD.var"#22#23", itr::NTuple{N, OrdinalRange{Int64, Int64}} where N) @ Base ./anyall.jl:214
│││││││││││││││┌ _all_tuple(f::Base.IteratorsMD.var"#22#23", anymissing::Bool, x::OrdinalRange{…}, rest::Vararg{…}) @ Base ./anyall.jl:227
││││││││││││││││┌ _all_tuple(f::Base.IteratorsMD.var"#22#23", anymissing::Bool, x::OrdinalRange{…}, rest::Vararg{…}) @ Base ./anyall.jl:218
│││││││││││││││││ runtime dispatch detected: f::Base.IteratorsMD.var"#22#23"(x::OrdinalRange{Int64, Int64})::Bool
││││││││││││││││└────────────────────
││││││││││││┌ collect_to_with_first!(dest::Any, v1::Any, itr::Base.Generator, st::Any) @ Base ./:831
│││││││││││││┌ grow_to!(dest::AbstractDict{K, V}, itr::Base.Generator, st::Any) where {K, V} @ Base ./abstractdict.jl:629
││││││││││││││┌ merge!(d::AbstractDict, others::AbstractDict) @ Base ./abstractdict.jl:227
│││││││││││││││┌ kwcall(::@NamedTuple{shrink::Bool}, ::typeof(sizehint!), d::WeakKeyDict, newsz::Any) @ Base ./weakkeydict.jl:73
││││││││││││││││┌ sizehint!(d::WeakKeyDict, newsz::Any; shrink::Bool) @ Base ./weakkeydict.jl:73
│││││││││││││││││┌ kwcall(::@NamedTuple{shrink::Bool}, ::typeof(sizehint!), d::Dict{WeakRef}, newsz::Any) @ Base ./dict.jl:193
││││││││││││││││││┌ sizehint!(d::Dict{WeakRef}, newsz::Any; shrink::Bool) @ Base ./dict.jl:199
│││││││││││││││││││┌ rehash!(h::Dict{WeakRef}, newsz::Any) @ Base ./dict.jl:168
││││││││││││││││││││┌ hashindex(key::WeakRef, sz::Any) @ Base ./:128
│││││││││││││││││││││┌ hash(x::WeakRef) @ Base ./:28
││││││││││││││││││││││┌ hash(w::WeakRef, h::UInt64) @ Base ./:29
│││││││││││││││││││││││ runtime dispatch detected: hash(%1::Any, h::UInt64)::Any
││││││││││││││││││││││└────────────────────
│││┌ _interpolated_value(ctx::JuliaLowering.InterpolationContext, srcref::JuliaLowering.SyntaxTree, ex::Any) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/runtime.jl:79
││││┌ makeleaf(ctx::JuliaLowering.InterpolationContext, srcref::JuliaLowering.SyntaxTree, k::JuliaSyntax.Kind, value::String) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:142
│││││┌ makeleaf(ctx::JuliaLowering.InterpolationContext, srcref::JuliaLowering.SyntaxTree, k::JuliaSyntax.Kind, value::String; kws::@Kwargs{}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:157
││││││┌ string(::String, ::JuliaSyntax.Kind, ::String) @ Base ./strings/io.jl:193
│││││││ failed to optimize due to recursion: string(::String, ::JuliaSyntax.Kind, ::String)
││││││└────────────────────
│││┌ _interpolated_value(ctx::JuliaLowering.InterpolationContext, srcref::Any, ex::Any) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/runtime.jl:74
││││┌ append_sourceref(ctx::JuliaLowering.InterpolationContext, ex::JuliaLowering.SyntaxTree, secondary_prov::Any) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/macro_expansion.jl:325
│││││┌ makenode(ctx::JuliaLowering.InterpolationContext, srcref::Tuple{…}, proto::JuliaLowering.SyntaxTree, children::Vararg{…}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:134
││││││┌ makenode(ctx::JuliaLowering.InterpolationContext, srcref::Tuple{…}, proto::JuliaLowering.SyntaxTree, children::Vararg{…}; attrs::@Kwargs{}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:135
│││││││┌ _makenode(ctx::JuliaLowering.InterpolationContext, srcref::Tuple{…}, proto::JuliaLowering.SyntaxTree, children::Tuple{…}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:130
││││││││┌ _makenode(ctx::JuliaLowering.InterpolationContext, srcref::Tuple{…}, proto::JuliaLowering.SyntaxTree, children::Tuple{…}; attrs::@Kwargs{}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:131
│││││││││┌ _makenode(graph::JuliaLowering.SyntaxGraph, srcref::Tuple{…}, proto::JuliaLowering.SyntaxTree, children::Tuple{…}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:122
││││││││││┌ _makenode(graph::JuliaLowering.SyntaxGraph, srcref::Tuple{…}, proto::JuliaLowering.SyntaxTree, children::Tuple{…}; attrs::@Kwargs{}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:127
│││││││││││┌ kwcall(::NamedTuple{…}, ::typeof(JuliaLowering.setattr!), graph::JuliaLowering.SyntaxGraph, id::Int64) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/syntax_graph.jl:150
││││││││││││┌ setattr!(graph::JuliaLowering.SyntaxGraph, id::Int64; attrs::Base.Pairs{…} where {…}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/syntax_graph.jl:151
│││││││││││││┌ iterate(::Base.Pairs{Symbol, T, Nothing, A} where {T, A<:(NamedTuple{(:source,), <:Tuple{Tuple{Int64, Vararg{Any}}}})}) @ Base.Iterators ./iterators.jl:290
││││││││││││││ runtime dispatch detected: Base.Iterators._pairs_elt(p::Base.Pairs{Symbol, T, Nothing, A} where {T, A<:(NamedTuple{(:source,), <:Tuple{Tuple{Int64, Vararg{Any}}}})}, :source)::Pair{Symbol}
│││││││││││││└────────────────────
││┌ _interpolate_ast(ctx::JuliaLowering.InterpolationContext, ex::JuliaLowering.SyntaxTree, depth::Int64) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/runtime.jl:116
│││┌ _interpolate_ast(ctx::JuliaLowering.InterpolationContext, ex::Any, depth::Int64) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/runtime.jl:120
││││┌ _interp_makenode(ctx::JuliaLowering.InterpolationContext, ex::Any, args::JuliaLowering.SyntaxList{…} where Attrs) @ JuliaLowering ./:48
│││││┌ makenode(ctx::JuliaLowering.InterpolationContext, srcref::Any, proto::Any, children::JuliaLowering.SyntaxList{…} where Attrs) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:134
││││││┌ makenode(ctx::JuliaLowering.InterpolationContext, srcref::Any, proto::Any, children::JuliaLowering.SyntaxList{…} where Attrs; attrs::@Kwargs{}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:135
│││││││┌ _makenode(ctx::JuliaLowering.InterpolationContext, srcref::Any, proto::Any, children::Vector{Int64}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:130
││││││││┌ _makenode(ctx::JuliaLowering.InterpolationContext, srcref::Any, proto::Any, children::Vector{Int64}; attrs::@Kwargs{}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:131
│││││││││┌ _makenode(ctx::Any, srcref::Any, proto::Any, children::Array; attrs::@Kwargs{}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:131
││││││││││┌ _makenode(graph::JuliaLowering.SyntaxGraph, srcref::Any, proto::Any, children::Array) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:122
│││││││││││┌ _makenode(graph::JuliaLowering.SyntaxGraph, srcref::Any, proto::Any, children::Array; attrs::@Kwargs{}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/ast.jl:124
││││││││││││┌ setchildren!(graph::JuliaLowering.SyntaxGraph, id::Int64, children::Array) @ JuliaLowering ./:110
│││││││││││││┌ append!(a::Vector{Int64}, iter::Array) @ Base ./:1357
││││││││││││││┌ _append!(a::Vector{Int64}, ::Base.HasShape, iter::Array) @ Base ./:1365
│││││││││││││││┌ iterate(A::Array) @ Base ./array.jl:901
││││││││││││││││ runtime dispatch detected: #self#::typeof(iterate)(A::Array, 1)::Union{Nothing, Tuple{Any, Int64}}
│││││││││││││││└────────────────────
│┌ interpolate_ast(::Type{JuliaLowering.SyntaxTree}, ::JuliaLowering.SyntaxTree{JuliaLowering.SyntaxGraph{Dict{…}}}) @ JuliaLowering /home/topolarity/.julia-jet/packages/JuliaLowering/A0OwQ/src/runtime.jl:151
││ failed to optimize due to recursion: JuliaLowering.interpolate_ast(::Type{…}, ::JuliaLowering.SyntaxTree{…})
│└────────────────────

[aviatesk]

This is interesting.
As far as I understand, when JL encounters a quote expression, it inserts interpolate_ast to convert it into a SyntaxTree. This conversion method itself is written internally in JL, and its implementation seems to be recursive, thus resulting in these reports.
The native lowerer just returns the quote expression as is, so these errors aren't reported.
Fully optimizing JL's implementation might make these errors disappear naturally.
But at this stage of JL development, the best approach might be for JET to simply ignore errors from JL's internal conversion functions.

[topolarity]

Fully optimizing JL's implementation might make these errors disappear naturally.

I think it'd be worth reviewing why we need this extra runtime code in the first place (I'll leave @mlechu / @c42f to comment on that) - Optimizing the code is good, but avoiding it entirely would be even better 👍

But at this stage of JL development, the best approach might be for JET to simply ignore errors from JL's internal conversion functions.

I think we should probably just leave them. They are real issues for both --trim and performance-minded users until we fix them in JL

[c42f]

I think it'd be worth reviewing why we need this extra runtime code in the first place

The reason for interpolate_ast was that existing lowering generates a deeply nested set of calls to Core._expr - basically spitting out the entire AST to be interpolated but as code. I thought this seemed somewhat excessive when we could inert-quote the AST instead and simply spit out the $-escaped parts for a runtime function to interpolate into the quoted AST. It also felt more natural to keep the original AST intact when dealing with attributes and provenance.

As an example, compare:

julia> Meta.@lower quote
           x = 1
           begin
               y = 2
               begin
                   z = 3
                   w = f(x, y, g(z, $a))
               end
           end
       end
:($(Expr(:thunk, CodeInfo(
1 ─ %1  = $(Expr(:copyast, :($(QuoteNode(:(x = 1))))))
│   %2  = $(Expr(:copyast, :($(QuoteNode(:(y = 2))))))
│   %3  = $(Expr(:copyast, :($(QuoteNode(:(z = 3))))))
│   %4  = Main.a
│   %5  =   builtin Core._expr(:call, :g, :z, %4)
│   %6  =   builtin Core._expr(:call, :f, :x, :y, %5)
│   %7  =   builtin Core._expr(:(=), :w, %6)
│   %8  =   builtin Core._expr(:block, $(QuoteNode(:(#= REPL[2]:6 =#))), %3, $(QuoteNode(:(#= REPL[2]:7 =#))), %7)
│   %9  =   builtin Core._expr(:block, $(QuoteNode(:(#= REPL[2]:4 =#))), %2, $(QuoteNode(:(#= REPL[2]:5 =#))), %8)
│   %10 =   builtin Core._expr(:block, $(QuoteNode(:(#= REPL[2]:2 =#))), %1, $(QuoteNode(:(#= REPL[2]:3 =#))), %9)
└──       return %10
))))

vs

Lowering> quote
              x = 1
              begin
                  y = 2
                  begin
                      z = 3
                      w = f(x, y, g(z, $a))
                  end
              end
          end
1   Main.a
2   (call core.tuple %₁)
3   (call JuliaLowering.interpolate_ast SyntaxTree (inert (block (= x 1) (block (= y 2) (block (= z 3) (= w (call f x y (call g z ($ a)))))))) %₂)
4   (return %₃)

Optimizing the code is good, but avoiding it entirely would be even better

In cases where we don't have any interpolations we could - and perhaps should - elide the interpolate_ast() part entirely. We would need an equivalent of Expr(:copyast) for those cases when expr_compat_mode=false

[aviatesk]

Yeah, I think avoiding interpolate_ast and taking an approach like fl-lowerer would be the easiest solution, but it's alos a shame that JL's valuable provenance information would be lost in such cases.
Alternatively, we could put a lot of effort into type inference debugging to make interpolate_ast completely trimmable (i.e., make its entire call graph statically resolvable). That said, I don't think we should do that right now, especially with so many code changes happening.

JL being fully integrated into base and trimming JL-generated code is still a long way off, and the immediate use case of JL will likely be code utilities like JET and Revise. So, my opinion on this is that we can probably pend this issue for now, and until JL is actually integrated into base, it should be fine from a trim analyzer perspective as far as JET suppresses errors by special-casing interpolate_ast.

As @c42f mentioned, JL would also make it easier to change the generated code based on the trimming mode, so there seem to be various approaches we could take.