JuliaLowering: Set is_ambiguous_local for toplevel-assigned

globals in begin blocks

When a variable is assigned at toplevel within a `begin` block
and then reassigned inside a permeable scope (for/while/try)
in the same block, the inner assignment was creating a plain
local without setting `is_ambiguous_local`. This happened
because the variable was already resolved as `:global` (from
the toplevel assignment), so scope resolution took the
`b.kind === :global` path instead of the `b === nothing` path
where `is_ambiguous_local` was originally set.

Now the `b.kind === :global` fallback also sets
`is_ambiguous_local` when the scope is permeable and the
variable is in `soft_assignable_globals`.

The tests directly inspect `BindingInfo.is_ambiguous_local`
via `resolve_scopes` rather than testing observable runtime
behavior, because `is_ambiguous_local` is currently metadata
only — the runtime warning that flisp emitted for this case
has not yet been ported to JuliaLowering. The flag's primary
consumer is JETLS, which uses it to emit editor diagnostics.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: aviatesk

JuliaLowering/src/scope_analysis.jl

@@ -320,7 +320,8 @@ function enter_scope!(ctx, ex)
                 # assign-existing-global if this is an explicit global that
                 # isn't at top level, or if the soft scope exception applies
             else
-                declare_in_scope!(ctx, scope, ex, :local)
+                declare_in_scope!(ctx, scope, ex, :local;
+                    is_ambiguous_local = scope.is_permeable && vk in ctx.soft_assignable_globals)
             end
         elseif b.kind === :static_parameter
             throw(LoweringError(ex, "cannot overwrite a static parameter"))

JuliaLowering/test/scopes.jl

@@ -343,6 +343,78 @@ end
     end
 end
 
+# When a toplevel assignment precedes a permeable scope (for/while/try) within
+# the same toplevel thunk (e.g. inside a begin block), the inner assignment
+# should be marked as ambiguous_local, just like the case where the global
+# already existed before the expression was lowered.
+@testset "is_ambiguous_local for toplevel-assigned globals in begin blocks" begin
+    function resolve_and_get_bindings(mod::Module, ex)
+        est = JuliaLowering.expr_to_est(ex)
+        ctx1, ex1 = JuliaLowering.expand_forms_1(
+            mod, est, false, Base.get_world_counter())
+        ctx2, ex2 = JuliaLowering.expand_forms_2(ctx1, ex1)
+        ctx3, _ex3 = JuliaLowering.resolve_scopes(ctx2, ex2)
+        return ctx3.bindings.info
+    end
+
+    # Assignment in for loop within begin block after toplevel assignment
+    let bindings = resolve_and_get_bindings(Module(), quote
+            x = 1
+            for _ = 1:10
+                x = 2
+            end
+        end)
+        ambiguous = filter(b -> b.name == "x" && b.is_ambiguous_local, bindings)
+        @test length(ambiguous) == 1
+    end
+
+    # while loop
+    let bindings = resolve_and_get_bindings(Module(), quote
+            x = 1
+            while true
+                x = 2
+                break
+            end
+        end)
+        ambiguous = filter(b -> b.name == "x" && b.is_ambiguous_local, bindings)
+        @test length(ambiguous) == 1
+    end
+
+    # No ambiguity inside a function (hard scope)
+    let bindings = resolve_and_get_bindings(Module(), quote
+            x = 1
+            function f()
+                for _ = 1:10
+                    x = 2
+                end
+            end
+        end)
+        ambiguous = filter(b -> b.name == "x" && b.is_ambiguous_local, bindings)
+        @test isempty(ambiguous)
+    end
+
+    # No ambiguity when variable is not assigned at toplevel first
+    let bindings = resolve_and_get_bindings(Module(), quote
+            for _ = 1:10
+                y = 2
+            end
+        end)
+        ambiguous = filter(b -> b.name == "y" && b.is_ambiguous_local, bindings)
+        @test isempty(ambiguous)
+    end
+
+    # Explicit `global` should not produce ambiguous local
+    let bindings = resolve_and_get_bindings(Module(), quote
+            x = 1
+            for _ = 1:10
+                global x = 2
+            end
+        end)
+        ambiguous = filter(b -> b.name == "x" && b.is_ambiguous_local, bindings)
+        @test isempty(ambiguous)
+    end
+end
+
 # Note: Certain flisp (un)hygiene behaviour is yet to be implemented.
 # In flisp, with no escaping:
 # - Top-level functions are unhygienic and declared in the macro's module