lab/sx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(diag): undeclared type in a main-file generic struct field → diagnostic (no silent stub) [stdlib E3 attempt-2]

Browse Source 
Closes the main-file carveout left by attempt-1 (4072689): a genuinely-
undeclared type used as a field type inside a MAIN-file GENERIC struct still
fell through the type leaf's empty-struct stub and silently compiled —
`Box :: struct($T: Type) { good: T; bad: MissingType; }` with `b : Box(s64)`
exited 0 and printed a value instead of reporting `unknown type 'MissingType'`.

Root cause: `UnknownTypeChecker` is the main-file diagnostic authority (the
type leaf defers to it for `.undeclared` names there), but
`checkStructFieldTypes` SKIPPED every generic struct outright ("its fields
reference `$T`, resolved at instantiation"), so the undeclared name was never
examined. The sibling `walkBodyTypes` `.struct_decl` arm skipped body-local
generic structs the same way.

Fix (semantic_diagnostics.zig, checker only — no leaf change):
- `checkStructFieldTypes`: stop skipping generic structs; walk the field
  types with the struct's OWN type params (`$T`, `$N`, `..$Ts`) passed as the
  in-scope set. A param name resolves; any OTHER bare name that is neither
  declared nor a generic param is reported. Value-param positions (a `Vector`
  lane count, a `$N: u32` arg) are still skipped inside
  `checkTypeNodeForUnknown` / `isValueParamPosition`.
- `walkBodyTypes` `.struct_decl`: same close for body-local structs — the
  local struct's own type params join the enclosing scope's in-scope params
  (so it can name both the outer fn's `$T` and its own), any other bare field
  type is still flagged.

The `..$Ts` pack field `(..$Ts)` parses to a `spread_expr` inside the tuple,
which hits `checkTypeNodeForUnknown`'s `else` arm — never walked — so the pack
examples (0538-0543, 0414) stay green. The checker walks only MAIN-file decls,
so library generic structs (List, Map) are untouched.

Regression: examples/0171-types-undeclared-type-in-generic-struct-field — the
reviewer's exact shape; `unknown type 'MissingType'` at the field, exit 1.
Fail-before on 4072689 (prints 7, exit 0), pass-after.

Gate: zig build; zig build test (423/423 + LSP corpus sweep 514); run_examples
498 passed / 0 failed (prior 497 byte-identical); m3te ios-sim build exit 0.
This commit is contained in:
agra
2026-06-08 08:36:45 +03:00
parent 4072689afe
commit a4906975bd
5 changed files with 53 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
src/ir/semantic_diagnostics.zig
View File

@@ -490,10 +490,14 @@ pub const UnknownTypeChecker = struct {
}
fn checkStructFieldTypes(self: UnknownTypeChecker, sd: *const ast.StructDecl, declared: *std.StringHashMap(void)) void {
// Generic struct fields reference the struct's own type params ($T) —
// resolved at instantiation, not here.
if (sd.type_params.len != 0) return;
for (sd.field_types) |ft| self.checkTypeNodeForUnknown(ft, declared, &.{}, &.{});
// A generic struct's field types may reference its own type params
// (`$T`, `$N`, the `..$Ts` pack) — those are IN SCOPE here, so pass them
// through rather than skipping the whole decl. Skipping silently let a
// genuinely-undeclared field type (`bad: MissingType`) fall through the
// type leaf's empty-struct stub and compile (stdlib E3). A value-param
// position (a `Vector` lane count, a `$N: u32` arg) is still skipped
// inside `checkTypeNodeForUnknown` / `isValueParamPosition`.
for (sd.field_types) |ft| self.checkTypeNodeForUnknown(ft, declared, sd.type_params, &.{});
}
fn checkFnSignatureTypes(self: UnknownTypeChecker, fd: *const ast.FnDecl, declared: *std.StringHashMap(void)) void {
@@ -592,7 +596,15 @@ pub const UnknownTypeChecker = struct {
if (cd.type_annotation) |ta| self.checkTypeNodeForUnknown(ta, declared, in_scope.items, type_vals.items);
self.walkBodyTypes(cd.value, declared, in_scope, type_vals);
},
.struct_decl => |sd| if (sd.type_params.len == 0) {
.struct_decl => |sd| {
// A body-local struct's own type params (`$T`) join the enclosing
// scope's in-scope params (so a local generic struct can name both
// the outer fn's `$T` and its own); any OTHER bare field type is
// still a genuinely-undeclared type. Mirrors the top-level
// `checkStructFieldTypes` close of the generic-struct carveout.
const save = in_scope.items.len;
defer in_scope.shrinkRetainingCapacity(save);
for (sd.type_params) |tp| in_scope.append(self.alloc, tp) catch {};
for (sd.field_types) |ft| self.checkTypeNodeForUnknown(ft, declared, in_scope.items, type_vals.items);
},
.call => |c| {