From 2d34993586c0093b818f818e01700206ede7c0b7 Mon Sep 17 00:00:00 2001 From: agra Date: Sun, 7 Jun 2026 20:43:01 +0300 Subject: [PATCH] feat(lower): source-aware forward-alias fixpoint [stdlib E1.5] MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit resolveForwardIdentifierAliases now resolves a forward alias A :: B against B AS SEEN FROM A's own source via selectNominalLeaf (E1's source-keyed nominal leaf over type_aliases_by_source / moduleTypeAuthor), never the global type_alias_map / global findByName. The already-resolved guard is per-source (aliasResolvedInSource). .pending routes back into the fixpoint; .undeclared / .not_visible leave A unwritten (no global last-wins leak). This is the sequencing pin before E2: a global fixpoint binds A to a same-name B authored by a different module (e.g. a namespaced import that pollutes the global alias map last-wins), re-opening 0105 one layer down once shadows register. Writes stay on the unified putTypeAlias helper (E1 no-drift invariant); the single graph-walk in resolver.zig is untouched. Regression: examples/0750-modules-forward-alias-source-aware — a forward alias A :: B with main's own B :: u64 and a namespaced same-name B :: u8; A must bind main's u64 (300), not the global last-wins u8 (44). --- ...0750-modules-forward-alias-source-aware.sx | 31 ++++++++++ .../dep.sx | 10 ++++ ...50-modules-forward-alias-source-aware.exit | 1 + ...-modules-forward-alias-source-aware.stderr | 1 + ...-modules-forward-alias-source-aware.stdout | 3 + src/ir/lower.zig | 58 ++++++++++++++----- 6 files changed, 88 insertions(+), 16 deletions(-) create mode 100644 examples/0750-modules-forward-alias-source-aware.sx create mode 100644 examples/0750-modules-forward-alias-source-aware/dep.sx create mode 100644 examples/expected/0750-modules-forward-alias-source-aware.exit create mode 100644 examples/expected/0750-modules-forward-alias-source-aware.stderr create mode 100644 examples/expected/0750-modules-forward-alias-source-aware.stdout diff --git a/examples/0750-modules-forward-alias-source-aware.sx b/examples/0750-modules-forward-alias-source-aware.sx new file mode 100644 index 0000000..4f08b91 --- /dev/null +++ b/examples/0750-modules-forward-alias-source-aware.sx @@ -0,0 +1,31 @@ +// Source-aware forward-alias fixpoint (R5 §4, E1.5). A forward identifier alias +// `A :: B` must resolve its target `B` AS SEEN FROM ITS OWN SOURCE, not via the +// global `type_alias_map` (which is last-wins across every module). +// +// `main` authors a forward alias `A :: B` and its own `B :: u64`. The namespaced +// import `ns :: #import ".../dep.sx"` ALSO authors a top-level `B :: u8`; being +// scanned after main's `B`, dep's alias is what the GLOBAL `type_alias_map["B"]` +// ends up holding (last-wins). A global forward-alias fixpoint therefore bound +// `A` to dep's `u8` — re-opening 0105 one layer down. The source-aware fixpoint +// resolves `A`'s target against MAIN's source, binding the local `B :: u64`. +// +// Observable: a runtime 300 coerced into an `A`-typed slot round-trips as 300 +// when `A` is `u64` (correct) and truncates to 44 when `A` is wrongly `u8`. +// The direct reference `b : B` already resolves source-aware via E1's nominal +// leaf, so it pins the same `u64` for contrast. Regression (stdlib E1.5). +#import "modules/std.sx"; + +A :: B; +B :: u64; + +ns :: #import "0750-modules-forward-alias-source-aware/dep.sx"; + +main :: () -> s32 { + n : s64 = 300; + a : A = xx n; + b : B = xx n; + print("forward A (u64=300): {}\n", cast(s64) a); + print("direct B (u64=300): {}\n", cast(s64) b); + print("ns.width(): {}\n", ns.width()); + return 0; +} diff --git a/examples/0750-modules-forward-alias-source-aware/dep.sx b/examples/0750-modules-forward-alias-source-aware/dep.sx new file mode 100644 index 0000000..5e98c96 --- /dev/null +++ b/examples/0750-modules-forward-alias-source-aware/dep.sx @@ -0,0 +1,10 @@ +// Namespaced helper module. It authors a top-level type alias `B` whose +// spelling collides with the importer's own `B`. Because the import is +// NAMESPACED (`ns :: #import`), `dep.B` is NOT flat-visible to the importer — +// but its alias write still lands in the global `type_alias_map` (last-wins), +// which is exactly what the source-aware forward-alias fixpoint must ignore. +B :: u8; + +width :: () -> s32 { + return 8; +} diff --git a/examples/expected/0750-modules-forward-alias-source-aware.exit b/examples/expected/0750-modules-forward-alias-source-aware.exit new file mode 100644 index 0000000..573541a --- /dev/null +++ b/examples/expected/0750-modules-forward-alias-source-aware.exit @@ -0,0 +1 @@ +0 diff --git a/examples/expected/0750-modules-forward-alias-source-aware.stderr b/examples/expected/0750-modules-forward-alias-source-aware.stderr new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/examples/expected/0750-modules-forward-alias-source-aware.stderr @@ -0,0 +1 @@ + diff --git a/examples/expected/0750-modules-forward-alias-source-aware.stdout b/examples/expected/0750-modules-forward-alias-source-aware.stdout new file mode 100644 index 0000000..7b44149 --- /dev/null +++ b/examples/expected/0750-modules-forward-alias-source-aware.stdout @@ -0,0 +1,3 @@ +forward A (u64=300): 300 +direct B (u64=300): 300 +ns.width(): 8 diff --git a/src/ir/lower.zig b/src/ir/lower.zig index 114106e..ed0897c 100644 --- a/src/ir/lower.zig +++ b/src/ir/lower.zig @@ -1360,14 +1360,30 @@ pub const Lowering = struct { /// Resolve identifier-RHS type aliases whose target is declared LATER in the /// file. The forward scan above only registers an alias (`A :: B`) when `B` - /// is already in `type_alias_map` / the `TypeTable`; a forward target isn't - /// yet present, so `A` is left unregistered and its uses get falsely flagged - /// as an unknown type (issue 0069). Re-resolve to a fixpoint now that every - /// top-level name has been seen, so `A :: B; B :: s32;` converges the same as - /// the ordered `B :: s32; A :: B;`. A value const is never an `.identifier` - /// node (`NotAType :: 123` is an int literal), and an alias whose target is a - /// value const still misses both lookups, so neither this pass nor issue 0068 - /// can register a non-type name. + /// is already resolved as a type author; a forward target isn't yet present, + /// so `A` is left unregistered and its uses get falsely flagged as an unknown + /// type (issue 0069). Re-resolve to a fixpoint now that every top-level name + /// has been seen, so `A :: B; B :: s32;` converges the same as the ordered + /// `B :: s32; A :: B;`. A value const is never an `.identifier` node + /// (`NotAType :: 123` is an int literal), and an alias whose target is a value + /// const stays unresolved, so neither this pass nor issue 0068 can register a + /// non-type name. + /// + /// SOURCE-AWARE (R5 §4, E1.5). The target `B` is resolved AS SEEN FROM `A`'s + /// OWN source via the source-aware nominal leaf (`selectNominalLeaf` over + /// `type_aliases_by_source` / `moduleTypeAuthor` — E1), NEVER the global + /// `type_alias_map` / global `findByName`. The "already resolved" guard is + /// likewise per-source. When a same-name `B` is authored by a *different* + /// source (e.g. a namespaced import polluting the global alias map last-wins), + /// a global fixpoint would bind `A` to the wrong `B` and re-open 0105 one + /// layer down once E2 registers shadows; resolving against `A`'s source binds + /// the local `B`. The `.pending` outcome (B is itself a not-yet-resolved + /// forward alias) routes BACK into this fixpoint — `A` is skipped this round + /// and converges on a later iteration. `.undeclared` (no type author) and + /// `.not_visible` (a namespaced-only type, not bare-aliasable) leave `A` + /// unwritten; its uses surface the stub / diagnostic, never a silent global + /// leak. The write stays on the unified `putTypeAlias` helper (E1 no-drift + /// invariant — only the helper touches the maps). fn resolveForwardIdentifierAliases(self: *Lowering, decls: []const *const Node) void { var progressed = true; while (progressed) { @@ -1378,22 +1394,32 @@ pub const Lowering = struct { else => continue, }; if (cd.value.data != .identifier) continue; - if (self.program_index.type_alias_map.contains(cd.name)) continue; + const src = decl.source_file orelse self.main_file orelse continue; + if (self.aliasResolvedInSource(src, cd.name)) continue; const rhs_name = cd.value.data.identifier.name; - if (self.program_index.type_alias_map.get(rhs_name)) |chained| { - self.putTypeAlias(decl.source_file, cd.name, chained); - progressed = true; - } else { - const name_id = self.module.types.internString(rhs_name); - if (self.module.types.findByName(name_id)) |tid| { + switch (self.selectNominalLeaf(rhs_name, src, false)) { + .resolved => |tid| { self.putTypeAlias(decl.source_file, cd.name, tid); progressed = true; - } + }, + // B not yet a resolved type author from this source: a forward + // alias still pending (re-tried next round), an undeclared + // name, or a namespaced-only type that is not bare-aliasable. + // Leave A unwritten — no global last-wins leak. + .pending, .undeclared, .not_visible => {}, } } } } + /// TRUE iff `name` is already recorded as a type alias FROM `src` — the + /// per-source analogue of `type_alias_map.contains`, so the forward-alias + /// fixpoint resolves a same-name alias in each source independently (E1.5). + fn aliasResolvedInSource(self: *Lowering, src: []const u8, name: []const u8) bool { + if (self.program_index.type_aliases_by_source.get(src)) |inner| return inner.contains(name); + return false; + } + /// Try to convert an array literal's elements into a compile-time /// ConstantValue.aggregate. `array_ty` is the array's resolved TypeId; its /// element type drives type-aware serialization of struct-literal and