occurrences: Replace ismacro Ref plumbing with is_macro0

Remove the `ismacro::Ref{Bool}` keyword from
`compute_binding_occurrences` / `!` and compute the same signal at
the stage-0 level via a new `is_macro0(st0)` helper (parallel to
`is_generated0`). The only production consumer was
`analyze_lowered_code!`, where `has_implicit_args` now uses
`is_macro0(st0) || is_generated0(st0)` directly.

While here, merge the `K"local"` / `K"global"` / `K"function_decl"`
decl-recording branches into a single arm and switch
`may_record_occurrence!` (renamed from `record_occurrence!`) to
return a `Bool` so the decl/def sites can use it as a predicate
for advancing `start_idx`.

Author: aviatesk

src/analysis/occurrence-analysis.jl

@@ -1,7 +1,7 @@
 """
     compute_binding_occurrences(
             ctx3::JL.VariableAnalysisContext, st3::Tree3, is_generated::Bool;
-            ismacro::Union{Nothing,Base.RefValue{Bool}} = nothing
+            include_global_bindings::Bool = false
         ) where Tree3<:JS.SyntaxTree
         -> binding_occurrences::Dict{JL.BindingInfo,Set{BindingOccurrence{Tree3}}}
 
@@ -19,7 +19,6 @@ information:
 # Arguments
 - `ctx3`: Variable analysis context from JuliaLowering containing binding information
 - `st3`: Lowered syntax tree (after scope resolution) to analyze
-- `ismacro`: Optional mutable reference to track if any function binding is a macro
 
 # Returns
 `binding_occurrences` is a dictionary mapping each non-internal local/argument binding to
@@ -34,7 +33,6 @@ a set of `BindingOccurrence` objects that record where and how the binding appea
 """
 function compute_binding_occurrences(
         ctx3::JL.VariableAnalysisContext, st3::Tree3, is_generated::Bool;
-        ismacro::Union{Nothing,Base.RefValue{Bool}} = nothing,
         include_global_bindings::Bool = false
     ) where Tree3<:JS.SyntaxTree
     occurrences = Dict{JL.BindingInfo,Set{BindingOccurrence{Tree3}}}()
@@ -65,7 +63,7 @@ function compute_binding_occurrences(
 
     isempty(occurrences) && return occurrences
 
-    compute_binding_occurrences!(occurrences, ctx3, st3; ismacro, include_global_bindings)
+    compute_binding_occurrences!(occurrences, ctx3, st3; include_global_bindings)
 
     # In `@generated` functions, arguments are typically used only inside returned
     # quoted expressions (`:(...)`) which appear as `inert` nodes after lowering.
@@ -164,30 +162,31 @@ self-recursive calls, which have distinct byte ranges.
 """
 const SkipRecording = Dict{JL.BindingInfo,UnitRange{Int}}
 
-function record_occurrence!(occurrences::Dict{JL.BindingInfo,Set{BindingOccurrence{Tree3}}},
+function may_record_occurrence!(occurrences::Dict{JL.BindingInfo,Set{BindingOccurrence{Tree3}}},
         kind::Symbol, st::Tree3, ctx3::JL.VariableAnalysisContext;
         skip_recording::Union{Nothing,SkipRecording} = nothing
     ) where Tree3<:JS.SyntaxTree
     if JS.kind(st) === JS.K"BindingId"
         binfo = JL.get_binding(ctx3, st)
-        record_occurrence!(occurrences, kind, st, binfo; skip_recording)
+        _may_record_occurrence!(occurrences, kind, st, binfo; skip_recording)
+        return true
     end
-    return occurrences
+    return false
 end
 
-function record_occurrence!(occurrences::Dict{JL.BindingInfo,Set{BindingOccurrence{Tree3}}},
+function _may_record_occurrence!(occurrences::Dict{JL.BindingInfo,Set{BindingOccurrence{Tree3}}},
         kind::Symbol, st::Tree3, binfo::JL.BindingInfo;
         skip_recording::Union{Nothing,SkipRecording} = nothing
     ) where Tree3<:JS.SyntaxTree
-    haskey(occurrences, binfo) || return occurrences
+    haskey(occurrences, binfo) || return
     if !isnothing(skip_recording)
         skip_range = get(skip_recording, binfo, nothing)
         if skip_range !== nothing && JS.byte_range(st) == skip_range
-            return occurrences
+            return
         end
     end
     push!(occurrences[binfo], BindingOccurrence(st, kind))
-    return occurrences
+    occurrences
 end
 
 is_selffunc(b::JL.BindingInfo) = b.name == "#self#"
@@ -197,46 +196,25 @@ function compute_binding_occurrences!(
         occurrences::Dict{JL.BindingInfo,Set{BindingOccurrence{Tree3}}},
         ctx3::JL.VariableAnalysisContext, st3::Tree3;
         include_global_bindings::Bool = false,
-        ismacro::Union{Nothing,Base.RefValue{Bool}} = nothing,
         skip_recording_uses::Union{Nothing,SkipRecording} = nothing
     ) where Tree3<:JS.SyntaxTree
     stack = JS.SyntaxList(st3)
     while !isempty(stack)
         st = pop!(stack)
         k = JS.kind(st)
         nc = JS.numchildren(st)
-        if k === JS.K"local" || (include_global_bindings && k === JS.K"global")
-            if nc ≥ 1
-                record_occurrence!(occurrences, :decl, st[1], ctx3)
-                continue # avoid to recurse to skip recording use
-            end
-        end
-
         if k === JS.K"BindingId"
-            record_occurrence!(occurrences, :use, st, ctx3; skip_recording=skip_recording_uses)
+            may_record_occurrence!(occurrences, :use, st, ctx3; skip_recording=skip_recording_uses)
         end
 
         start_idx = 1
-        if k === JS.K"function_decl"
-            if nc ≥ 1
-                func = st[1]
-                if JS.kind(func) === JS.K"BindingId"
-                    binfo = JL.get_binding(ctx3, func)
-                    record_occurrence!(occurrences, :decl, func, binfo)
-                    if !isnothing(ismacro)
-                        ismacro[] |= startswith(binfo.name, "@")
-                    end
-                    start_idx = 2
-                end
+        if k in JS.KSet"local function_decl" || (include_global_bindings && k === JS.K"global")
+            if nc ≥ 1 && may_record_occurrence!(occurrences, :decl, st[1], ctx3)
+                start_idx = 2 # skip recording use
             end
         elseif k === JS.K"method_defs" || k === JS.K"constdecl"
-            if nc ≥ 1
-                local global_binding = st[1]
-                if JS.kind(global_binding) === JS.K"BindingId"
-                    binfo = JL.get_binding(ctx3, global_binding)
-                    record_occurrence!(occurrences, :def, global_binding, binfo)
-                    start_idx = 2
-                end
+            if nc ≥ 1 && may_record_occurrence!(occurrences, :def, st[1], ctx3)
+                start_idx = 2
             end
         elseif k === JS.K"block" && nc ≥ 1 && JS.kind(st[1]) === JS.K"function_decl"
             # This block wraps a function definition. Each function's own binding
@@ -266,11 +244,11 @@ function compute_binding_occurrences!(
             if !isempty(newly_added)
                 if isnothing(skip_recording_uses)
                     compute_binding_occurrences!(occurrences, ctx3, st;
-                        ismacro, skip_recording_uses = SkipRecording(newly_added))
+                        skip_recording_uses = SkipRecording(newly_added))
                 else
                     for br in newly_added; push!(skip_recording_uses, br); end
                     compute_binding_occurrences!(occurrences, ctx3, st;
-                        ismacro, skip_recording_uses)
+                        skip_recording_uses)
                     for (b, _) in newly_added; delete!(skip_recording_uses, b); end
                 end
                 continue
@@ -281,21 +259,21 @@ function compute_binding_occurrences!(
             if nc ≥ 2
                 arglist = st[1]
                 for i = 1:JS.numchildren(arglist)
-                    record_occurrence!(occurrences, :def, arglist[i], ctx3)
+                    may_record_occurrence!(occurrences, :def, arglist[i], ctx3)
                 end
                 start_idx = 2
                 if nc ≥ 3
                     sparamlist = st[2]
                     for i = 1:JS.numchildren(sparamlist)
-                        record_occurrence!(occurrences, :def, sparamlist[i], ctx3)
+                        may_record_occurrence!(occurrences, :def, sparamlist[i], ctx3)
                     end
                     start_idx = 3
                 end
             end
         elseif k === JS.K"="
             start_idx = 2 # the left hand side, i.e. "definition", does not account for usage
             if nc ≥ 1
-                record_occurrence!(occurrences, :def, st[1], ctx3)
+                may_record_occurrence!(occurrences, :def, st[1], ctx3)
                 if nc ≥ 2
                     rhs = st[2]
                     # In struct definitions, `local struct_name` is somehow introduced,
@@ -350,7 +328,7 @@ function compute_binding_occurrences!(
         end
     end
 
-    return occurrences, ismacro
+    return occurrences
 end
 
 function is_matching_global_binding(

src/diagnostic.jl

@@ -1176,14 +1176,13 @@ function analyze_lowered_code!(
         postprocessor::LSPostProcessor = LSPostProcessor()
     )
     (; ctx3, ctx4, st0, st3) = res
-    ismacro = Ref(false)
     binding_occurrences = compute_binding_occurrences(ctx3, st3, is_generated0(st0);
-        ismacro, include_global_bindings=true)
+        include_global_bindings=true)
+
     reported = Set{LoweringDiagnosticKey}() # to prevent duplicate reports for unused default or keyword arguments
     (kwarg_type_names, kwarg_locations) = compute_kwarg_type_annotation_names(st0)
 
-    has_implicit_args = ismacro[] || is_generated0(st0)
-
+    has_implicit_args = is_macro0(st0) || is_generated0(st0)
     analyze_unused_bindings!(
         diagnostics, fi, st0, ctx3, binding_occurrences, has_implicit_args, reported,
         kwarg_type_names, kwarg_locations;

src/utils/ast.jl

@@ -119,6 +119,8 @@ is_mainfunc0(st0::SyntaxTree0) = is_macrocall_st0(st0, "@main")
 
 is_generated0(st0::SyntaxTree0) = is_macrocall_st0(st0, "@generated")
 
+is_macro0(st0::SyntaxTree0) = JS.kind(st0) === JS.K"macro"
+
 # Simple (non-qualified) macro names whose new-style implementations in
 # `JuliaLowering/src/syntax_macros.jl` and `src/utils/jl-syntax-macros.jl`
 # preserve fine-grained source provenance during expansion. Unlike old-style

test/analysis/test_occurrence_analysis.jl

@@ -12,23 +12,16 @@ module lowering_module end
 with_binding_occurrences(callback, code::AbstractString; kwargs...) =
     with_binding_occurrences(callback, lowering_module, code; kwargs...)
 function with_binding_occurrences(callback, mod::Module, code::AbstractString;
-                                  ismacro_callback = nothing,
                                   remove_macrocalls::Bool = false,
                                   is_generated::Bool = false)
     st0 = jlparse(code; rule=:statement)
     if remove_macrocalls
         st0 = JETLS.remove_macrocalls(st0)
     end
     (; ctx3, st3) = JETLS.jl_lower_for_scope_resolution(mod, st0)
-    ismacro = isnothing(ismacro_callback) ? nothing : Ref(false)
-    binding_occurrences = JETLS.compute_binding_occurrences(ctx3, st3, is_generated; ismacro)
-    if !isnothing(ismacro_callback)
-        ismacro_callback(ismacro)
-    end
+    binding_occurrences = JETLS.compute_binding_occurrences(ctx3, st3, is_generated)
     callback(binding_occurrences)
 end
-nomacro_callback(ismacro) = @test !ismacro[]
-ismacro_callback(ismacro) = @test ismacro[]
 
 @testset "compute_binding_occurrences" begin
     with_binding_occurrences("""
@@ -37,7 +30,7 @@ ismacro_callback(ismacro) = @test ismacro[]
             println(x)
             return y
         end
-        """; ismacro_callback = nomacro_callback) do binding_occurrences
+        """) do binding_occurrences
         binfos = collect(keys(binding_occurrences))
         @test length(binfos) == 4
         let i = @something findfirst(binfo->binfo.name=="x", binfos)
@@ -92,7 +85,7 @@ ismacro_callback(ismacro) = @test ismacro[]
         macro m(x, y)
             return Expr(:block, __source__, esc(x))
         end
-        """; ismacro_callback = ismacro_callback) do binding_occurrences
+        """) do binding_occurrences
         binfos = collect(keys(binding_occurrences))
         @test length(binfos) == 4
         let i = @something findfirst(binfo->binfo.name=="x", binfos)
@@ -148,7 +141,7 @@ ismacro_callback(ismacro) = @test ismacro[]
             function func1(::TTT1) where TTT1<:Integer
                 return zero(TTT1)
             end
-            """; ismacro_callback = nomacro_callback) do binding_occurrences
+            """) do binding_occurrences
             binfos = collect(keys(binding_occurrences))
             # there are two different bindings representing the `TTT1`, one for defineing the
             # signature type and the other for static parameter binding within the method body
@@ -175,7 +168,7 @@ ismacro_callback(ismacro) = @test ismacro[]
         end
         """
         for code in (code1, code2)
-            with_binding_occurrences(code; ismacro_callback = nomacro_callback) do binding_occurrences
+            with_binding_occurrences(code) do binding_occurrences
                 binfos = collect(keys(binding_occurrences))
                 # there are two different bindings representing each for `TTT1` and `TTT2`,
                 # one for defineing the signature type and the other for static parameter binding within the method body
@@ -214,7 +207,7 @@ ismacro_callback(ismacro) = @test ismacro[]
                 end
                 println(xxx)
             end
-            """; ismacro_callback = nomacro_callback) do binding_occurrences
+            """) do binding_occurrences
             binfos = collect(keys(binding_occurrences))
             idxs = findall(binfo->binfo.name=="xxx", binfos)
             @test length(idxs) == 2
@@ -240,7 +233,7 @@ ismacro_callback(ismacro) = @test ismacro[]
             function func(xxx::TTT)::Float64 where TTT<:Integer
                 return sin(xxx)
             end
-            """; ismacro_callback = nomacro_callback) do binding_occurrences
+            """) do binding_occurrences
             binfos = collect(keys(binding_occurrences))
             idx = only(findall(binfo->binfo.name=="xxx", binfos))
             occurrences = binding_occurrences[binfos[idx]]
@@ -253,23 +246,23 @@ ismacro_callback(ismacro) = @test ismacro[]
     end
 
     @testset "keyword arguments" begin
-        with_binding_occurrences("func(a; kw) = kw"; ismacro_callback = nomacro_callback) do binding_occurrences
+        with_binding_occurrences("func(a; kw) = kw") do binding_occurrences
             @test !any(binding_occurrences) do (binding, occurrences)
                 binding.name == "a" && binding.kind === :argument && any(o->o.kind===:use, occurrences)
             end
             @test any(binding_occurrences) do (binding, occurrences)
                 binding.name == "kw" && binding.kind === :argument && any(o->o.kind===:use, occurrences)
             end
         end
-        with_binding_occurrences("func(a; kw) = a"; ismacro_callback = nomacro_callback) do binding_occurrences
+        with_binding_occurrences("func(a; kw) = a") do binding_occurrences
             @test any(binding_occurrences) do (binding, occurrences)
                 binding.name == "a" && binding.kind === :argument && any(o->o.kind===:use, occurrences)
             end
             @test !any(binding_occurrences) do (binding, occurrences)
                 binding.name == "kw" && binding.kind === :argument && any(o->o.kind===:use, occurrences)
             end
         end
-        with_binding_occurrences("func(a; kw) = nothing"; ismacro_callback = nomacro_callback) do binding_occurrences
+        with_binding_occurrences("func(a; kw) = nothing") do binding_occurrences
             @test !any(binding_occurrences) do (binding, occurrences)
                 binding.name == "a" && binding.kind === :argument && any(o->o.kind===:use, occurrences)
             end

test/utils/test_jl_syntax_macros.jl

@@ -254,9 +254,8 @@ end
             world = Base.get_world_counter()
             res = JETLS.jl_lower_for_scope_resolution(lowering_module, st0, world;
                 recover_from_macro_errors=false, convert_closures=true)
-            ismacro = Ref(false)
             binding_occurrences = JETLS.compute_binding_occurrences(
-                res.ctx3, res.st3, false; ismacro, include_global_bindings=true)
+                res.ctx3, res.st3, false; include_global_bindings=true)
 
             xxx_binfo = nothing
             for (binfo, _) in binding_occurrences