Tests: Shadowing is a passing case now, unbound reads are the error

globals_shadowing.py asserted the old rule, so it moves to
passing_tests/globals/shadowing.py and asserts the new one: the write
without `global` binds a local, and a second program still reads the
global's initializer. copy_to_local.py covers `x = a_global`, the read
shape that used to fail in the allocation pass.

globals_read_before_shadow.py takes over as the failing case, since a
read above the binding is what Python rejects, and the augassign test
keeps its xfail with the reason reworded to the UnboundLocalError it is.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: r41k0u

tests/failing_tests/globals_augassign_shadowing.py

@@ -1,6 +1,7 @@
-# `counter += 1` without `global counter` must be the same loud error as plain
-# assignment. Before direct lowering this slipped past the allocation pass
-# (which only walks Assign) and failed later with a misleading message.
+# `counter += 1` without `global counter` binds `counter` as a local and reads
+# it in the same statement, which is UnboundLocalError in Python. Plain
+# assignment shadows the global instead (see passing_tests/globals/shadowing.py);
+# this shape cannot, because it reads before it binds.
 from pythonbpf import bpf, section, bpfglobal, compile
 from ctypes import c_void_p, c_int64, c_uint64
 

tests/failing_tests/globals_read_before_shadow.py

@@ -0,0 +1,29 @@
+# The assignment below makes `counter` a local for the whole function, so the
+# read above it is an UnboundLocalError in Python -- not a read of the global.
+# There is no runtime here in which to raise that, so the compiler rejects the
+# program instead of silently loading an uninitialised slot.
+from pythonbpf import bpf, section, bpfglobal, compile
+from ctypes import c_void_p, c_int64, c_uint64
+
+
+@bpf
+@bpfglobal
+def counter() -> c_uint64:
+    return c_uint64(7)
+
+
+@bpf
+@section("tracepoint/raw_syscalls/sys_enter")
+def prog(ctx: c_void_p) -> c_int64:
+    print(f"counter {counter}")  # noqa: F821, F823 -- reads a local bound below
+    counter = 1  # noqa: F841 -- ...here, which is what makes the read unbound
+    return c_int64(0)
+
+
+@bpf
+@bpfglobal
+def LICENSE() -> str:
+    return "GPL"
+
+
+compile()

tests/passing_tests/globals/copy_to_local.py

@@ -0,0 +1,30 @@
+# Reading a global needs no declaration, in every shape a read can take --
+# including `x = a_global`, which resolves through the allocation pass rather
+# than the expression evaluator and so needs the globals table there too.
+from pythonbpf import bpf, section, bpfglobal, compile
+from ctypes import c_void_p, c_int64, c_uint64
+
+
+@bpf
+@bpfglobal
+def threshold() -> c_uint64:
+    return c_uint64(42)
+
+
+@bpf
+@section("tracepoint/raw_syscalls/sys_enter")
+def prog(ctx: c_void_p) -> c_int64:
+    limit = threshold
+    doubled = threshold * 2
+    if threshold > 10:
+        print(f"limit {limit} doubled {doubled}")
+    return c_int64(0)
+
+
+@bpf
+@bpfglobal
+def LICENSE() -> str:
+    return "GPL"
+
+
+compile()

tests/passing_tests/globals/shadowing.py

@@ -0,0 +1,38 @@
+# Python's scoping rule, applied to BPF globals: assigning a name without a
+# `global` statement creates a local that shadows the global for the whole
+# function body, and leaves the global's storage alone. `tick` therefore writes
+# a stack slot, and `read_back` still sees the initializer.
+from pythonbpf import bpf, section, bpfglobal, compile
+from ctypes import c_void_p, c_int64, c_uint64
+
+
+@bpf
+@bpfglobal
+def counter() -> c_uint64:
+    return c_uint64(7)
+
+
+@bpf
+@section("tracepoint/raw_syscalls/sys_enter")
+def tick(ctx: c_void_p) -> c_int64:
+    counter = 1  # noqa: F841 -- no `global`, so this is a local; that is the test
+    counter = counter + 1
+    print(f"local counter {counter}")
+    return c_int64(0)
+
+
+@bpf
+@section("tracepoint/syscalls/sys_enter_execve")
+def read_back(ctx: c_void_p) -> c_int64:
+    # No assignment here, so the bare name is the global: still 7.
+    print(f"global counter {counter}")
+    return c_int64(0)
+
+
+@bpf
+@bpfglobal
+def LICENSE() -> str:
+    return "GPL"
+
+
+compile()

tests/test_config.toml

@@ -33,12 +33,12 @@
 
 "failing_tests/xdp_pass.py" = {reason = "XDP program using vmlinux structs (struct_xdp_md) and complex map/struct interaction not yet supported", level = "ir"}
 
-"failing_tests/globals_shadowing.py" = {reason = "Assignment to a global name without a `global` statement is a deliberate compile error (would shadow the BPF global)", level = "ir"}
+"failing_tests/globals_read_before_shadow.py" = {reason = "Reading a name above the assignment that makes it a local shadowing a global is UnboundLocalError in Python, and a compile error here", level = "ir"}
 
 "failing_tests/globals_undeclared_name.py" = {reason = "`global x` naming something that is not a @bpfglobal is a compile error", level = "ir"}
 
 "failing_tests/globals_bad_type.py" = {reason = "Non-integer-scalar globals are not supported in milestone 1 (NotImplementedError by design)", level = "ir"}
 
-"failing_tests/globals_augassign_shadowing.py" = {reason = "Augmented assignment to a global name without a `global` statement is a deliberate compile error (would shadow the BPF global)", level = "ir"}
+"failing_tests/globals_augassign_shadowing.py" = {reason = "`x += 1` on a global name without `global` binds a local and reads it unbound: UnboundLocalError in Python, a compile error here", level = "ir"}
 
 "failing_tests/globals_parameter_and_global.py" = {reason = "A parameter may not be declared global (Python: name is parameter and global)", level = "ir"}