bb8f7dc5ec
attempt-3 closed the leaf + parameterized-head leaks but several more
sites still resolved an UNQUALIFIED type name via the global
type_alias_map / findByName / type_bridge.resolveAstType without the
single-hop visibility gate, so a 2-flat-hop bare type leaked through:
- resolveTypeArg (reflection / size_of / align_of / type_name / type_eq):
identifier + type_expr leaves now gate via headTypeLeak; the wrapped /
structural forms (*T, [N]T, []T, ?T, fn-ptr, tuple) route through the
already-gated resolveTypeWithBindings so each inner leaf recurses the
source-aware resolveNominalLeaf.
- resolveTupleLiteralTypeArg: each element leaf is resolved through the
source-aware resolver before the delegated build, so (COnly, s64) is
gated.
- resolveArrayLiteralType (T.[...] typed array/vector-literal head):
identifier + type_expr leaves gate via headTypeLeak.
- type-as-value lowerExpr identifier (x: Type = COnly, x == COnly).
- type-category match arm (case COnly:).
Qualified ns.X / 1-hop / source-pinned library-internal references stay
exempt (the gate falls through for reachable / unauthored names, and
returns the existing "unresolved type" diagnostic for genuinely-undeclared
names). README notes the type gate holds wherever a bare type name is
named. New regressions 0765 (2-hop reject) / 0766 (1-hop pass).
28 lines
1.3 KiB
Plaintext
28 lines
1.3 KiB
Plaintext
// `#import` is non-transitive for a type named in a REFLECTION / type-arg slot
|
|
// (`size_of(T)`, `size_of(*T)`) and in a TYPED ARRAY-LITERAL annotation
|
|
// (`T.[...]`), exactly like a bare leaf annotation (0763), a parameterized head
|
|
// (0764), and values/functions (0706): when A imports B and B imports C, A must
|
|
// NOT see C's top-level types here either. This file imports `b.sx` (which
|
|
// imports `c.sx`) and references C's `Nums` / `COnly` in those positions — each
|
|
// is rejected with a "type ... is not visible; #import the module that declares
|
|
// it" diagnostic, BEFORE the global type table can resolve it.
|
|
//
|
|
// `b.sx` ↔ `c.sx` together still compile: `b_sizes` / `b_arr` resolve `Nums` /
|
|
// `COnly` because b.sx directly imports c.sx (one flat hop there, two from a
|
|
// file that imports b.sx).
|
|
//
|
|
// Regression (Phase E4): before the bare-TYPE gate reached the reflection
|
|
// type-arg and array-literal leaf sites, these 2-flat-hop references leaked
|
|
// through the global `type_alias_map` / `findByName` / `type_bridge` lookup.
|
|
|
|
#import "modules/std.sx";
|
|
#import "0765-modules-import-reflection-type-non-transitive/b.sx";
|
|
|
|
main :: () -> s32 {
|
|
print("{}\n", size_of(Nums));
|
|
print("{}\n", size_of(*COnly));
|
|
xs := Nums.[1, 2];
|
|
print("{} {}\n", xs[0], xs[1]);
|
|
0
|
|
}
|