fix(stdlib/E4): route reflection/literal/value/match bare-type sites through the non-transitive gate
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).
This commit is contained in:
agra
@@ -4097,6 +4097,12 @@ pub const Lowering = struct {
|
||||
// (`x: Type = Vec4`), comparison (`x == Vec4`), and
|
||||
// pack-arg / Any context (boxing happens at the
|
||||
// consumer).
|
||||
// E4 single-hop visibility gate: a bare type name used as a VALUE
|
||||
// (`x: Type = COnly`, `x == COnly`) reachable only over 2+ flat hops
|
||||
// is not bare-visible either (consistent with annotations / 0763).
|
||||
// `headTypeLeak` fires only for a real type author unreachable from
|
||||
// here; a value name / generic param / undeclared name falls through.
|
||||
if (self.headTypeLeak(id.name, node.span)) break :blk self.emitPlaceholder(id.name);
|
||||
const ty = blk_ty: {
|
||||
if (self.type_bindings) |tb| {
|
||||
if (tb.get(id.name)) |t| break :blk_ty t;
|
||||
@@ -5425,6 +5431,14 @@ pub const Lowering = struct {
|
||||
.type_expr => |te| te.name,
|
||||
else => "",
|
||||
};
|
||||
// E4 single-hop visibility gate: a SPECIFIC 2-flat-hop type name in
|
||||
// a type-match arm (`case COnly:`) is not bare-visible (consistent
|
||||
// with annotations / 0763). A category keyword (`int`, `struct`, …)
|
||||
// is not a type author anywhere, so the gate is a no-op for those.
|
||||
if (self.headTypeLeak(name, pat.span)) {
|
||||
arm_tag_values.append(self.alloc, &.{}) catch unreachable;
|
||||
continue;
|
||||
}
|
||||
const tag_values = self.resolveTypeCategoryTags(name);
|
||||
arm_tag_values.append(self.alloc, tag_values) catch unreachable;
|
||||
for (tag_values) |tag| {
|
||||
@@ -6862,10 +6876,17 @@ pub const Lowering = struct {
|
||||
},
|
||||
.parameterized_type_expr => |pt| return self.resolveParameterizedWithBindings(&pt, te.span),
|
||||
.identifier => |id| {
|
||||
// E4 single-hop visibility gate: a 2-flat-hop bare type name in a
|
||||
// typed array/vector-literal annotation (`Nums.[1, 2]`) is not
|
||||
// bare-visible (consistent with annotations / 0763).
|
||||
if (self.headTypeLeak(id.name, te.span)) return .unresolved;
|
||||
const name_id = self.module.types.internString(id.name);
|
||||
return self.module.types.findByName(name_id) orelse .unresolved;
|
||||
},
|
||||
.type_expr => return type_bridge.resolveAstType(te, &self.module.types, &self.program_index.type_alias_map, &self.program_index.module_const_map),
|
||||
.type_expr => |inner| {
|
||||
if (self.headTypeLeak(inner.name, te.span)) return .unresolved;
|
||||
return type_bridge.resolveAstType(te, &self.module.types, &self.program_index.type_alias_map, &self.program_index.module_const_map);
|
||||
},
|
||||
.field_access => |fa| {
|
||||
// Module.Type — try to resolve the field as a type name
|
||||
const name_id = self.module.types.internString(fa.field);
|
||||
@@ -12330,6 +12351,13 @@ pub const Lowering = struct {
|
||||
}
|
||||
return .unresolved;
|
||||
}
|
||||
// E4 single-hop visibility gate: each element leaf is resolved through
|
||||
// the source-aware resolver, so a 2-flat-hop inner leaf (`(COnly, s64)`)
|
||||
// emits "not visible" + poisons rather than leaking through
|
||||
// `type_bridge`'s ungated global lookup. A valid element resolves to the
|
||||
// same TypeId the delegated build produces below (no diagnostic, no
|
||||
// drift); only the poison short-circuits.
|
||||
if (self.resolveTypeWithBindings(el.value) == .unresolved) return .unresolved;
|
||||
}
|
||||
return type_bridge.resolveAstType(node, &self.module.types, &self.program_index.type_alias_map, &self.program_index.module_const_map);
|
||||
}
|
||||
@@ -12382,6 +12410,12 @@ pub const Lowering = struct {
|
||||
if (self.type_bindings) |tb| {
|
||||
if (tb.get(id.name)) |ty| return ty;
|
||||
}
|
||||
// E4 single-hop visibility gate: a bare type name reachable only
|
||||
// over 2+ flat hops is not bare-visible in a reflection / type-arg
|
||||
// slot either (consistent with normal annotations / 0763). A
|
||||
// genuinely-undeclared name is NOT authored as a type anywhere, so
|
||||
// the gate falls through to the "unresolved type" diagnostic below.
|
||||
if (self.headTypeLeak(id.name, node.span)) return .unresolved;
|
||||
if (self.program_index.type_alias_map.get(id.name)) |alias_ty| return alias_ty;
|
||||
const name_id = self.module.types.internString(id.name);
|
||||
if (self.module.types.findByName(name_id)) |t| return t;
|
||||
@@ -12391,6 +12425,7 @@ pub const Lowering = struct {
|
||||
return .unresolved;
|
||||
},
|
||||
.type_expr => |te| {
|
||||
if (self.headTypeLeak(te.name, node.span)) return .unresolved;
|
||||
if (self.program_index.type_alias_map.get(te.name)) |alias_ty| return alias_ty;
|
||||
return type_bridge.resolveAstType(node, &self.module.types, &self.program_index.type_alias_map, &self.program_index.module_const_map);
|
||||
},
|
||||
@@ -12410,14 +12445,20 @@ pub const Lowering = struct {
|
||||
// Handle type constructor calls: size_of(Sx(f32)), size_of(Complex(u32))
|
||||
return self.resolveTypeCallWithBindings(&cl);
|
||||
},
|
||||
.tuple_literal => return self.resolveTupleLiteralTypeArg(node),
|
||||
// Wrapped / structural forms (`*T`, `[N]T`, `[]T`, `?T`, fn-ptr, tuple)
|
||||
// route through the gated `resolveTypeWithBindings`, whose
|
||||
// `resolveCompound` recurses each element through the source-aware leaf
|
||||
// (`resolveNominalLeaf`) — so a 2-hop inner leaf (`*COnly`, `[2]COnly`,
|
||||
// `(COnly, s64)`) is rejected exactly as in a normal annotation, instead
|
||||
// of `type_bridge.resolveAstType`'s ungated global lookup (E4).
|
||||
.tuple_literal,
|
||||
.pointer_type_expr,
|
||||
.many_pointer_type_expr,
|
||||
.array_type_expr,
|
||||
.slice_type_expr,
|
||||
.optional_type_expr,
|
||||
.function_type_expr,
|
||||
=> return type_bridge.resolveAstType(node, &self.module.types, &self.program_index.type_alias_map, &self.program_index.module_const_map),
|
||||
=> return self.resolveTypeWithBindings(node),
|
||||
else => return .unresolved,
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user