fix(0115): source-aware global selection — own-wins for module globals

The globals registry (global_names) was last-wins across modules with no
per-importer gate: any module's bare K could read/write/type against an
unrelated module's same-named global (hash.sx's K table hijacked every
user K once std's namespace tail pulled hash into the program), and an
own const of an unsupported shape borrowed another module's const and
panicked at the unresolved-type tripwire.

- var_decl joins RawDeclRef: module globals are selectable raw authors.
- selectGlobalAuthor (the globals analogue of F2's selectModuleConst):
  own author wins, one flat-visible author resolves, >=2 distinct flat
  authors diagnose loudly, authored-but-not-visible diagnoses, and a
  compiler-synthesized global (no raw author) emits untracked. A var_decl
  author whose per-source registration was deduped at flat-merge (two
  modules declaring the same extern symbol) serves the symbol's
  registration.
- All bare-identifier global sites route through it: value read, addr-of,
  assignment (store + compound), lvalue address, fn-ptr call, call param
  typing, and expression type inference.
- selectModuleConst gains .own_opaque: an own const author with no
  materialized per-source value (e.g. an array '::' const) blocks
  borrowing another module's same-named const — the read diagnoses
  cleanly instead of panicking.
- The fn-as-VALUE arm admits raw-facts-only authors: an own fn whose name
  a flat-merge collision dropped from the global decl list (first-wins)
  now resolves via author selection for func_ref/closure/Any shapes too.

Regressions: examples 0835 (own const vs flat array global), 0836 (main
const vs namespaced array global, incl. inference), 0837 (own array
const never borrows cross-module — clean unresolved).
This commit is contained in:
agra
2026-06-11 10:47:30 +03:00
parent 37bea63302
commit 0b13498e25
26 changed files with 288 additions and 32 deletions

View File

@@ -9,6 +9,7 @@ const unescape = @import("../../unescape.zig");
const errors = @import("../../errors.zig");
const program_index_mod = @import("../program_index.zig");
const ProtocolMethodInfo = program_index_mod.ProtocolMethodInfo;
const GlobalInfo = program_index_mod.GlobalInfo;
const CallResolver = @import("../calls.zig").CallResolver;
const TypeId = types.TypeId;
@@ -542,7 +543,7 @@ pub fn lowerCall(self: *Lowering, c_in: *const ast.Call) Ref {
}
}
// May be a global variable holding a function pointer
if (self.program_index.global_names.get(id.name)) |gi| {
if (self.resolveGlobalRef(id.name, c.callee.span)) |gi| {
if (!gi.ty.isBuiltin()) {
const gti = self.module.types.get(gi.ty);
if (gti == .function) {
@@ -2176,12 +2177,20 @@ pub fn resolveCallParamTypes(self: *Lowering, c: *const ast.Call, sel_author: ?*
return types_list.items;
}
// Check global function pointer variables
if (self.program_index.global_names.get(bare_name)) |gi| {
if (!gi.ty.isBuiltin()) {
const ti = self.module.types.get(gi.ty);
if (ti == .function) {
return ti.function.params;
// Check global function pointer variables (quiet author-aware lookup —
// param typing only; the call site diagnoses ambiguity / visibility)
if (self.program_index.global_names.get(bare_name)) |gi_global| {
const gi: ?GlobalInfo = switch (self.selectGlobalAuthor(bare_name)) {
.resolved => |g| g,
.untracked => gi_global,
else => null,
};
if (gi) |g| {
if (!g.ty.isBuiltin()) {
const ti = self.module.types.get(g.ty);
if (ti == .function) {
return ti.function.params;
}
}
}
}