sx/issues/0115-same-name-const-scalar-array-collision.md

0115 — same-name consts of different shapes collide across modules (panic / silent clobber)

RESOLVED (2026-06-11). Root cause: the globals registry (global_names) is last-wins across modules and every read/write/addr/ call site consulted it with no source-awareness; var_decl was not even a selectable raw author. Fix: var_decl joins RawDeclRef; selectGlobalAuthor (the globals analogue of F2's selectModuleConst) selects the author own-wins / one-flat-visible / ambiguous-loudly and serves the AUTHOR's per-source global; all bare-identifier global sites (read, addr-of, assignment, fn-ptr call, type inference) route through it. selectModuleConst gained .own_opaque so an own const author with no materialized value (unsupported shape, e.g. an array :: const) blocks borrowing another module's same-named const instead of panicking. The fn-as-VALUE arm admits raw-facts-only authors (an own fn dropped from the global decl list by a flat-merge collision — the 0601 test case). Regression tests: examples/0835, 0836, 0837. The co-blockers also landed: dead-global elimination at emit (unreferenced plain-data globals are not emitted) and 1055/1056 no longer pin global error ordinals — the full std namespace tail is enabled on top.

Symptom. When two modules in one program declare a same-named module const with DIFFERENT shapes (scalar K : s64 : 4 vs array K : [4]s64 : .[...]), resolution conflates them instead of selecting per-author:

• Observed (minimal repro below): compiler PANIC — unresolved type reached LLVM emission (src/backend/llvm/types.zig:175, the .unresolved sentinel tripwire).
• Observed (full std-tail topology): SILENT WRONG VALUES — a module's own scalar K reads as the other module's array global (prints the array's address or the whole array). Seen corpus-wide when hash :: #import "modules/std/hash.sx" (hash.sx declares the SHA-256 K : [64]s64 table) is added to the std.sx namespace tail: examples 0786/0787/0788/0789/0791/0793/0794 (same-name-const family), 0162, 0168 all read hash's K instead of their own.
• Expected: own-wins / per-author const selection (the documented F2 semantics — readme "Own-wins holds at every one of those sites") applies regardless of the consts' shapes; no cross-shape leakage, no panic.

This blocks the PLAN-STDLIB "full tail" follow-up: fs/process/socket/ json/cli/hash/test cannot join the std.sx namespace tail until same-name consts are robust across every module pulled into every program.

Reproduction (panic variant — minimal, standalone)

// h.sx
K : [4]s64 : .[11, 22, 33, 44];
use_k :: () -> s64 { K[2] }

// main.sx
#import "modules/std.sx";
h :: #import "h.sx";
K : s64 : 4;
main :: () { print("K={} h.use_k={}\n", K, h.use_k()); }

Run main.sx → panic unresolved type reached LLVM emission. Expected: prints K=4 h.use_k=33.

Reproduction (silent-clobber variant — full topology)

Add the full tail to library/modules/std.sx after the existing mem/xml/log lines:

fs :: #import "modules/std/fs.sx";
process :: #import "modules/std/process.sx";
socket :: #import "modules/std/socket.sx";
json :: #import "modules/std/json.sx";
cli :: #import "modules/std/cli.sx";
hash :: #import "modules/std/hash.sx";
test :: #import "modules/std/test.sx";

Run bash tests/run_examples.sh → ~50 failures. The const-family failures (0786 prints a=4318334368 b=4318334368, 0162 prints the whole 64-entry array for K=...) are this bug. (A flat-importing main + a namespaced array-K module WITHOUT the tail topology resolves correctly — the silent variant needs the tail's shape, where hash.sx itself flat-imports std.sx. The panic variant above is the minimal entry point.)

Co-blockers observed in the same experiment (note, possibly separate issues)

1. Eager emission bloat: with the tail in place, every program emits hash's 64-entry @K table plus @OS/@ARCH/@POINTER_SIZE globals even when unused (visible in every pinned .ir snapshot). Tail modules' globals should emit lazily (only when referenced).
2. 0601-comptime-meta prints nothing (comptime meta machinery breaks with the tail in place — root cause unknown, possibly same-name generic/comptime fn last-wins: isPlainFreeFn excludes generic / comptime authors from own-wins rerouting).
3. 1055/1056 errors-enum-value: user-visible error ints shift when tail modules' error sets join the global error-tag registry (numbering coupling, arguably inherent; snapshot fragility at minimum).

Investigation prompt

Same-name module consts are selected own-wins via selectModuleConst (F2, src/ir/lower/expr.zig ~1641) over module_const_map — but ARRAY consts lower as GLOBALS (@K = internal global [4 x s64]), registered in a different, still last-wins registry (find it: grep the lowering for where a top-level array const becomes a module global — likely lowerGlobalDecl / the global-var map in src/ir/lower/decl.zig). The panic happens because the scalar K's type resolution reads the OTHER author's array shape (or vice versa) and poisons to .unresolved.

The fix likely needs:

1. Source-aware selection for the globals registry, mirroring selectModuleConst (own-wins, ≥2 flat-visible authors → loud ambiguity) — including the MIXED scalar/array case where the two authors live in different registries today.
2. The 0786-family examples already pin scalar/scalar own-wins; add a scalar-vs-array pin (the minimal repro above) once fixed.

Verification: run the panic repro (expect K=4 h.use_k=33), then add the full tail to std.sx and run bash tests/run_examples.sh — the const family (0786/0787/0788/0789/0791/0793/0794, 0162, 0168) must pass; the remaining tail failures decompose into co-blockers 1-3 above (file separately if they persist).