From 90dc6369c9600a3b13b6ec056aabe43631e80617 Mon Sep 17 00:00:00 2001 From: Hojun-Cho Date: Fri, 7 Aug 2026 23:03:55 +0900 Subject: [PATCH] comments: drop retired lint markers, re-cite migrated carriers peel-ok/sizelint-ok/primsize-ok annotations lose their tools; sites keep the WHY in plain words. Citations of retired carriers move to their fixture or @test successors (949_errtype_compare -> r949_*, 900_stdlib -> library owners). --- cmd/w6c/cgen.c | 11 +++++----- cmd/wcc/check.c | 14 ++++++------ cmd/wcc/type.c | 14 ++++++------ examples/lisp/lisp_test.ww | 6 ++---- lib/io/stream.ww | 8 +++---- lib/regex/regex_whitebox.ww | 13 ++++++------ lib/sort/sort.ww | 4 ++-- lib/ww/syntax/typ.ww | 16 ++++---------- selfhost/cmd/wcc/cgenexpr.ww | 6 ++---- selfhost/cmd/wcc/cgenstmt.ww | 2 +- selfhost/cmd/wcc/cgenutil.ww | 41 ++++++++++++++++-------------------- selfhost/cmd/wcc/check.ww | 7 ++---- 12 files changed, 61 insertions(+), 81 deletions(-) diff --git a/cmd/w6c/cgen.c b/cmd/w6c/cgen.c index fbba9655..780907fe 100644 --- a/cmd/w6c/cgen.c +++ b/cmd/w6c/cgen.c @@ -770,10 +770,9 @@ nullable_ptr_tag(Type *t) if (t == NULL || t->kind != TY_TAGGED) return 0; int i = 0; for (Tparam *p = t->params; p; p = p->next, i++) { - /* peel-ok: single peel PROBE-CLEARED (batch-2 c3-B2, - * 018ef66) — constructible variant params never carry - * 2+-level NAMED at this scan; ww twin cgenutil.ww:2758 - * carries the identical annotated peel. */ + /* A single-level inspection is sufficient here (batch-2 c3-B2, + * 018ef66): constructible variant params never carry nested + * NAMED layers at this scan; the ww twin uses the same invariant. */ Type *pu = (p->type && p->type->kind == TY_NAMED) ? p->type->under : p->type; if (pu && pu->kind == TY_PTR) return i; @@ -849,7 +848,7 @@ cg_variant_match(Type *vt, Type *src) * Sound only while the model is nominal-lossy; the collision * guard at the widen site (cg_widen_tagged_store) enforces the * invariant for when #199b/B-full lands true nominal layout. - * peel-ok (#218, B5-c1): these single peels serve ONLY the + * These single-level inspections serve ONLY the * both-TAGGED structural fallback — a NAMED struct source vs * a NAMED variant falls through every arm at ANY depth * (.ai/ken-b5-oracle.md §4: kb5_v2s1i both-wrong-identical @@ -875,7 +874,7 @@ cg_variant_match(Type *vt, Type *src) static int cg_variant_struct_match(Type *vt, Type *src) { - /* peel-ok (#218, B5-c1): shape-only collision count for the + /* Shape-only collision count for the * both-TAGGED fallback above — same probe record, task #95 * (.ai/ken-b5-oracle.md §4). */ Type *vu = (vt && vt->kind == TY_NAMED) ? vt->under : vt; diff --git a/cmd/wcc/check.c b/cmd/wcc/check.c index 3fab75d1..ec4688f7 100644 --- a/cmd/wcc/check.c +++ b/cmd/wcc/check.c @@ -105,7 +105,7 @@ resolve_typename(Checker *c, Node *n) * handing its type out; no consumer may ever see the size-0 * placeholder. Mirrors wwstage's demand-driven tinfofornode, the * measured order-independent side. */ - /* peel-ok: under==NULL probes resolve state, not a dealias */ + /* A missing underlying type is the unresolved-state marker. */ if (s->type && s->type->kind == TY_NAMED && s->type->under == NULL && s->decl && s->decl->kind == N_TYPEDECL) resolve_typedecl(c, s->decl); @@ -785,7 +785,7 @@ resolve_type(Checker *c, Node *n) || eu->kind == TY_TAGGED)) sz += (eu->size + 7) & ~(u64)7; else if (eu == NULL || eu->kind != TY_VOID) - sz += 8; /* sizelint-ok: the slot IS the 8B eightbyte */ + sz += 8; /* Each scalar occupies one SysV eightbyte. */ } if (head == NULL) head = tp; else tail->next = tp; @@ -1073,8 +1073,8 @@ unify_arith(Checker *c, Pos p, Type *a, Type *b) * a plain i32 — type_eq ignores iserror (primitives compare by * kind), but harec interns flags into DISTINCT types, so flagged- * vs-unflagged never reaches type_promote's dealias-equal arm. The - * #246 loud (strconv.invalid != i32, pinned by 949_errtype_compare - * on BOTH stages) rides this reject. */ + * #246 loud (strconv.invalid != i32, pinned by the r949_errtype_* + * fixtures on BOTH stages) rides this reject. */ { Type *da = type_chase_named(a); Type *db = type_chase_named(b); @@ -2371,7 +2371,7 @@ cexpr(Checker *c, Node *n) || eu->kind == TY_TAGGED)) sz += (eu->size + 7) & ~(u64)7; else if (eu == NULL || eu->kind != TY_VOID) - sz += 8; /* sizelint-ok: the slot IS the 8B eightbyte */ + sz += 8; /* Each scalar occupies one SysV eightbyte. */ if (head == NULL) head = tp; else tail->next = tp; tail = tp; @@ -2860,7 +2860,7 @@ static void resolve_typedecl(Checker *c, Node *d) { Type *t = d->type; - /* peel-ok: under!=NULL probes resolve state, not a dealias */ + /* A present underlying type is the resolved-state marker. */ if (t == NULL || t->under != NULL || t->resolving) return; t->resolving = 1; const char *save = c->cur_mod; @@ -2875,7 +2875,7 @@ resolve_typedecl(Checker *c, Node *d) if (circular_named(c, under, d->pos)) under = ty_err; t->resolving = 0; - t->under = under; /* peel-ok: construction */ + t->under = under; if (under) { t->size = under->size; t->align = under->align; diff --git a/cmd/wcc/type.c b/cmd/wcc/type.c index 52990492..7d171b1d 100644 --- a/cmd/wcc/type.c +++ b/cmd/wcc/type.c @@ -75,7 +75,7 @@ typesinit(Arena *a) * the same way a user-declared alias would. */ ty_nomem = newtype(a, TY_NAMED); ty_nomem->name = "nomem"; - ty_nomem->under = ty_void; /* peel-ok: construction */ + ty_nomem->under = ty_void; ty_nomem->size = ty_void->size; ty_nomem->align = ty_void->align; ty_nomem->iserror = 1; @@ -107,7 +107,7 @@ type_slice(Arena *a, Type *sub) { Type *t = newtype(a, TY_SLICE); t->sub = sub; - t->size = 24; /* { *T, len, cap } */ /* sizelint-ok: SSoT for ty_slice (#64) */ + t->size = 24; /* Slice headers carry pointer, length, and capacity. */ t->align = 8; return t; } @@ -138,7 +138,7 @@ type_named(Arena *a, const char *name, Type *under) { Type *t = newtype(a, TY_NAMED); t->name = name; - t->under = under; /* peel-ok: construction */ + t->under = under; if (under) { t->size = under->size; t->align = under->align; @@ -159,7 +159,7 @@ type_named(Arena *a, const char *name, Type *under) Type * type_chase_named(Type *t) { - while (t && t->kind == TY_NAMED) t = t->under; /* peel-ok: chase body */ + while (t && t->kind == TY_NAMED) t = t->under; return t; } @@ -176,7 +176,7 @@ type_isint(Type *t) case TY_UNTYPED_RUNE: return 1; case TY_ENUM: return type_isint(t->sub); - case TY_NAMED: /* peel-ok: recursive chase */ + case TY_NAMED: return type_isint(t->under); default: return 0; } @@ -189,7 +189,7 @@ type_isfloat(Type *t) switch (t->kind) { case TY_F32: case TY_F64: case TY_UNTYPED_FLOAT: return 1; - case TY_NAMED: /* peel-ok: recursive chase */ + case TY_NAMED: return type_isfloat(t->under); default: return 0; } @@ -210,7 +210,7 @@ type_isunsigned(Type *t) case TY_UINT: case TY_UINTPTR: case TY_SIZE: case TY_RUNE: return 1; - case TY_NAMED: /* peel-ok: recursive chase */ + case TY_NAMED: return type_isunsigned(t->under); case TY_ENUM: return type_isunsigned(t->sub); default: return 0; diff --git a/examples/lisp/lisp_test.ww b/examples/lisp/lisp_test.ww index 3646cd98..916fdb8f 100644 --- a/examples/lisp/lisp_test.ww +++ b/examples/lisp/lisp_test.ww @@ -201,10 +201,8 @@ fn check_str(name: str, input: str, want: str, ep: **env) void = { }; }; -// strconv.f64tos probes. We run them through lisp_test rather than a -// standalone strconv test program because there's no stdlib-test -// scaffolding yet (cf. test/wcc/900_stdlib.c which only checks -// modules compile, not behaviour). Move out when that lands. +// strconv.f64tos probes. Library-owned strconv tests cover formatting; +// these rows retain the application-level consumer expectations here. fn check_f64tos(name: str, v: f64, want: str) void = { ntotal += 1; let s: str = strconv.f64tos(v); diff --git a/lib/io/stream.ww b/lib/io/stream.ww index ed36bbe4..c4922b9c 100644 --- a/lib/io/stream.ww +++ b/lib/io/stream.ww @@ -22,8 +22,8 @@ // (io fold-2, #5), so the dispatchers ARE the public // surface and grow the `handle` match when #5 lands. // empty the discard+EOF stream (ref/hare/io/empty.ha:13). Lives -// here rather than io.ww so that 900_stdlib can compile -// io.ww standalone (io.ww has no cross-file type refs). +// here rather than io.ww so io.ww remains a standalone +// frontend input with no cross-file type references. // // Deferrals (drew-signed): `seeker` lands with io fold-2 (#5) once `off` // + `whence` plug into the signature. Hare's `?`-propagating `close` @@ -196,8 +196,8 @@ export fn tell(h: handle) (off | error) = { // vtable is a module-level `let` and [[empty]] is a function that wires // the fn-ptr slots on every call and returns the stream pointer. // Single-assignment on the same words: idempotent under re-entry. -// Lives in stream.ww (not io.ww) so that 900_stdlib can compile io.ww -// standalone without referencing the cross-file vtable/reader/writer types. +// Lives in stream.ww (not io.ww) so io.ww stays standalone without +// referencing the cross-file vtable/reader/writer types. fn _empty_read(s: stream, buf: []u8) (size | eof | error) = { let e: eof; diff --git a/lib/regex/regex_whitebox.ww b/lib/regex/regex_whitebox.ww index cc97208f..ca4893e4 100644 --- a/lib/regex/regex_whitebox.ww +++ b/lib/regex/regex_whitebox.ww @@ -10,12 +10,13 @@ // the non-T @test drop, #6). Load-bearing ww-compiler coverage (drove // #34/#38/#44/#45/#48), not black-box-reachable. // -// `_whitebox.ww` (NOT *_test.ww) keeps this file in the production -// enumerator's root-package assembly until package-aware testing can classify -// same-package `*_test.ww` files (T1). The T0 gate resolves `regex` as the root -// directory so -T sees these tests directly; importing regex as a dependency -// would strip them. Public-API tests remain a separate `package regex_test` -// binary in lib/regex/regex_test.ww (CLAUDE.md rule 9). +// This noncanonical `_whitebox.ww` name is retained during migration. The +// package planner's explicit compatibility rule recognizes its line-leading +// @test declarations and assembles it with the production `regex` sources; +// ordinary production files merely ending in `test.ww` stay production. +// Importing regex as a dependency still strips these tests. Public-API tests +// remain a separate `package regex_test` binary in lib/regex/regex_test.ww +// (CLAUDE.md rule 9). package regex; import io; diff --git a/lib/sort/sort.ww b/lib/sort/sort.ww index afd3df97..6ff6408e 100644 --- a/lib/sort/sort.ww +++ b/lib/sort/sort.ww @@ -5,8 +5,8 @@ // // Hare splits this across types.ha/search.ha/bisect.ha; ww merges a // module into one file (same convention as lib/types/types.ww merging -// Hare's limits.ha + arch+x86_64.ha), and 900_stdlib smoke-compiles -// lib/sort/sort.ww standalone, which a split would break. +// Hare's limits.ha + arch+x86_64.ha). test/wcc/963_sort_run.c compiles +// and executes this sole-source package directly. // // Divergences from the Hare source, all forced by ww's surface (not // behavioural — rule-10 align-down): diff --git a/lib/ww/syntax/typ.ww b/lib/ww/syntax/typ.ww index edca4651..785d2432 100644 --- a/lib/ww/syntax/typ.ww +++ b/lib/ww/syntax/typ.ww @@ -280,9 +280,10 @@ export fn typeptr(sub: *tinfo) *tinfo = { export fn typeslice(sub: *tinfo) *tinfo = { let t: *tinfo = newtype(tykind.TY_SLICE); t.sub = sub; - t.size = 24u64; // sizelint-ok: SSoT for slice header (#64) + // Slice headers carry pointer, length, and capacity (#64). + t.size = 24u64; t.align = 8u64; - t.slotsize = 24u64; // sizelint-ok: SSoT for slice slotsize (#64) + t.slotsize = 24u64; return t; }; @@ -316,7 +317,7 @@ export fn typechan(sub: *tinfo) *tinfo = { export fn typenamed(name: str, under: *tinfo) *tinfo = { let t: *tinfo = newtype(tykind.TY_NAMED); t.name = name; - t.under = under; // peel-ok: construction + t.under = under; if (under != nil) { t.size = under.size; t.align = under.align; @@ -373,7 +374,6 @@ export fn typeisint(t: *tinfo) bool = { if (k == tykind.TY_UNTYPED_INT) { return true; }; if (k == tykind.TY_UNTYPED_RUNE) { return true; }; if (k == tykind.TY_ENUM) { return typeisint(t.sub); }; - // peel-ok: recursive chase if (k == tykind.TY_NAMED) { return typeisint(t.under); }; return false; }; @@ -384,7 +384,6 @@ export fn typeisfloat(t: *tinfo) bool = { if (k == tykind.TY_F32) { return true; }; if (k == tykind.TY_F64) { return true; }; if (k == tykind.TY_UNTYPED_FLOAT) { return true; }; - // peel-ok: recursive chase if (k == tykind.TY_NAMED) { return typeisfloat(t.under); }; return false; }; @@ -409,7 +408,6 @@ export fn typeisunsigned(t: *tinfo) bool = { if (k == tykind.TY_UINTPTR) { return true; }; if (k == tykind.TY_SIZE) { return true; }; if (k == tykind.TY_RUNE){ return true; }; - // peel-ok: recursive chase if (k == tykind.TY_NAMED) { return typeisunsigned(t.under); }; if (k == tykind.TY_ENUM) { return typeisunsigned(t.sub); }; return false; @@ -436,7 +434,6 @@ export fn typeisstr(t: *tinfo) bool = { let k: tykind = t.kind; if (k == tykind.TY_STR) { return true; }; if (k == tykind.TY_UNTYPED_STR) { return true; }; - // peel-ok: recursive chase if (k == tykind.TY_NAMED) { return typeisstr(t.under); }; return false; }; @@ -446,7 +443,6 @@ export fn typeisslice(t: *tinfo) bool = { if (t == nil) { return false; }; let k: tykind = t.kind; if (k == tykind.TY_SLICE) { return true; }; - // peel-ok: recursive chase if (k == tykind.TY_NAMED) { return typeisslice(t.under); }; return false; }; @@ -462,7 +458,6 @@ export fn typeistagged(t: *tinfo) bool = { if (t == nil) { return false; }; let k: tykind = t.kind; if (k == tykind.TY_TAGGED) { return true; }; - // peel-ok: recursive chase if (k == tykind.TY_NAMED) { return typeistagged(t.under); }; return false; }; @@ -474,7 +469,6 @@ export fn typeisf32(t: *tinfo) bool = { if (t == nil) { return false; }; let k: tykind = t.kind; if (k == tykind.TY_F32) { return true; }; - // peel-ok: recursive chase if (k == tykind.TY_NAMED) { return typeisf32(t.under); }; return false; }; @@ -487,7 +481,6 @@ export fn typeisnullable(t: *tinfo) bool = { if (t == nil) { return false; }; let k: tykind = t.kind; if (k == tykind.TY_TAGGED) { return t.nullable != 0; }; - // peel-ok: recursive chase if (k == tykind.TY_NAMED) { return typeisnullable(t.under); }; return false; }; @@ -513,7 +506,6 @@ export fn typeis8byteprim(t: *tinfo) bool = { if (k == tykind.TY_STR) { return false; }; if (k == tykind.TY_STRUCT) { return false; }; if (k == tykind.TY_ARRAY) { return t.size == 8u64; }; - // peel-ok: recursive chase if (k == tykind.TY_NAMED) { return typeis8byteprim(t.under); }; // Remaining: primitives (i8/u8/.../i64/u64/bool/rune/f32/f64/ // int/uint/uintptr) and TY_VOID. All slot-pad to 8 and zero-init diff --git a/selfhost/cmd/wcc/cgenexpr.ww b/selfhost/cmd/wcc/cgenexpr.ww index 3c0ddf84..bedbdb1e 100644 --- a/selfhost/cmd/wcc/cgenexpr.ww +++ b/selfhost/cmd/wcc/cgenexpr.ww @@ -1049,7 +1049,7 @@ fn cgcast(c: *cgen, n: *syntax.node) void = { else { if (lk == syntax.nkind.N_TENUM) { leaf_tn = leaf_tn.lhs; } else { if (lk == syntax.nkind.N_TNAME) { let lnm: str = leaf_tn.str; - // primsize-ok (#101/#109): this IS an alias chase loop + // This is an alias chase loop // — primsize is the leaf-primitive break test the loop // wraps (aliaslookup advances the cursor on a miss). if (primsize(lnm) > 0) { break; }; @@ -8936,7 +8936,7 @@ fn cgassign(c: *cgen, n: *syntax.node) void = { else { if (syntax.streq(pe.str, "f64")) { elemfloat = true; } else { if (syntax.streq(pe.str, "f32")) { elemfloat = true; elemf32 = true; } else { - // primsize-ok (#101/#109): this site OWNS its own ps==0 + // This site owns its own ps==0 // typenodeprimresolved chase below — routing through // aliasprimsize would double-resolve and regress #11. let ps: i32 = primsize(pe.str); @@ -13174,5 +13174,3 @@ fn cgassign(c: *cgen, n: *syntax.node) void = { // The tail goes loud for the remaining kinds with #22. return; }; - - diff --git a/selfhost/cmd/wcc/cgenstmt.ww b/selfhost/cmd/wcc/cgenstmt.ww index b8cc7e38..a28d8aac 100644 --- a/selfhost/cmd/wcc/cgenstmt.ww +++ b/selfhost/cmd/wcc/cgenstmt.ww @@ -3664,7 +3664,7 @@ fn paramfieldsize(t: *syntax.node) i32 = { if (k == syntax.nkind.N_TNAME) { let nm: str = t.str; if (syntax.streq(nm, "str")) { return primtypesize("str"): i32; }; - // primsize-ok (#101/#109): paramfieldsize is a STRUCTURAL + // paramfieldsize is a STRUCTURAL // (no-`c`, no-chase) sizer by design — it takes a *node, not a // *cgen, so it cannot run aliasprimsize's aliaslookup chase // (threading c is the dormant #110). A bare primsize is correct diff --git a/selfhost/cmd/wcc/cgenutil.ww b/selfhost/cmd/wcc/cgenutil.ww index 31ff63cb..8f212b64 100644 --- a/selfhost/cmd/wcc/cgenutil.ww +++ b/selfhost/cmd/wcc/cgenutil.ww @@ -1600,16 +1600,12 @@ fn elemisarrayc(c: *cgen, t: *syntax.node) bool = { return elem.kind == syntax.nkind.N_TARRAY; }; -// tichase — transitive TY_NAMED peel, nil-passthrough. Exact wwstage -// twin of cstage type_chase_named (cmd/wcc/type.c:160-162, alias arc -// #5): chain-of-aliases stacks TY_NAMED layers, so any single peel -// leaves a kind-gated consumer staring at TY_NAMED and falling to a -// scalar shape (#60's esz=1/pointer-base SEGV family). One chased -// accessor is the only spelled way to dealias; raw `.under` reads -// outside it are the lint target (rob F2 ruling). +// tichase is the wwstage twin of cstage type_chase_named +// (cmd/wcc/type.c:160-162, alias arc #5). Alias chains stack TY_NAMED +// layers, so consumers that need structural shape must resolve the whole +// chain or risk the scalar fallback (#60's esz=1/pointer-base family). fn tichase(t0: *syntax.tinfo) *syntax.tinfo = { let t: *syntax.tinfo = t0; - // peel-ok: chase body for (t != nil && t.kind == syntax.tykind.TY_NAMED) { t = t.under; }; return t; }; @@ -1796,7 +1792,7 @@ fn elemsizeof(t: *syntax.node) i32 = { // reads eff->sub->size (cmd/w6c/cgen.c N_INDEX). if (syntax.streq(nm, "str")) { return primtypesize("u8"): i32; }; // Indexing a primitive name (rare): element size = the prim. - // primsize-ok (#101/#109): elemsizeof is the STRUCTURAL (non- + // elemsizeof is the STRUCTURAL (non- // chasing) sizer by design — its alias-resolving twin elemsizeofc // owns the chase (routed through aliasprimsize at the :1579 leg). // A bare primsize here is correct, not the #101 bug shape. @@ -1824,7 +1820,7 @@ fn elemsizeof(t: *syntax.node) i32 = { let nm: str = elem.str; // str element is 16B (ptr+len). primsize returns 0 for it. if (syntax.streq(nm, "str")) { return primtypesize("str"): i32; }; - // primsize-ok (#101/#109): structural sizer — the chase lives + // This structural sizer leaves alias resolution // in elemsizeofc (:1579), not here. See the :1475 leg. let ps: i32 = primsize(nm); if (ps > 0) { return ps; }; @@ -2427,9 +2423,8 @@ fn fldnumidx(s: str) i32 = { return r; }; -// primsize-ok (#101/#109): the primitive-width oracle itself — this -// IS the SSoT table aliasprimsize wraps; there is nothing below it to -// chase. +// This primitive-width oracle is the SSoT table aliasprimsize wraps; +// there is nothing below it to chase (#101/#109). fn primsize(name: str) i32 = { if (syntax.streq(name, "u8")) { return 1; }; if (syntax.streq(name, "i8")) { return 1; }; @@ -2463,8 +2458,8 @@ fn primsize(name: str) i32 = { // at the twin sites; this is the ww align-up. The bare-primsize GUARD // family (is-primitive dispatch) is the #109 follow-on, NOT routed // here. #101. -// primsize-ok (#101/#109): the SSoT chase body itself — primsize is -// the leaf-primitive probe this helper wraps, then aliaslookup chases. +// primsize is the leaf-primitive probe this SSoT helper wraps, then +// aliaslookup chases (#101/#109). fn aliasprimsize(c: *cgen, nm: str) i32 = { let ps: i32 = primsize(nm); if (ps > 0) { return ps; }; @@ -2506,7 +2501,7 @@ export fn typenodeprimresolved(c: *cgen, t: *syntax.node, // dedicated `is_bool` path in cgcast owns bool→bool's // ANDQ $255 on both stages. if (syntax.streq(nm, "bool")) { return; }; - // primsize-ok (#101/#109): this fn IS a prim-resolver + // This function is a primitive resolver // chaser (#33) — primsize is the leaf-primitive probe; // aliaslookup below advances the walk on a miss. let ps: i32 = primsize(nm); @@ -2546,7 +2541,7 @@ export fn exprprimresolved(c: *cgen, n: *syntax.node, // mymode;` (mymode = enum u32). let s: str = n.tsuffix; if (s.len > 0) { - // primsize-ok (#101/#109): a typed-int literal suffix + // A typed-int literal suffix // (`7u32`) is a builtin primitive name by grammar — no // alias can reach here, so there is nothing to chase. let ps: i32 = primsize(s); @@ -3110,8 +3105,8 @@ fn taggedmemargsize(t: *syntax.tinfo) i32 = { if (u == nil) { return 0; }; if (u.kind != syntax.tykind.TY_TAGGED) { return 0; }; if (u.nullable != 0) { return 0; }; - // sizelint-ok: 6 SysV int arg regs (DI..R9) x 8B words — the - // same register-capacity constant as cstage tagged_arg_size. + // SysV supplies 6 integer argument registers (DI..R9); the 8-byte + // words below encode the same capacity as cstage tagged_arg_size. if (u.size: i32 <= 6 * 8) { return 0; }; return u.size: i32; }; @@ -3325,10 +3320,10 @@ export fn nullableptrtag(t: *syntax.node) i32 = { for (p != nil) { let vt: *syntax.tinfo = p.type_; if (vt != nil) { - // peel-ok: single peel PROBE-CLEARED (batch-2 c3-B2, - // 018ef66) — constructible variant params never carry - // 2+-level NAMED at this scan; cs twin nullable_ptr_tag - // (cmd/w6c/cgen.c:747) keeps the identical single peel. + // A single-level inspection is sufficient here (batch-2 + // c3-B2, 018ef66): constructible variant params never carry + // nested NAMED layers at this scan; the cs twin relies on + // the same invariant. if (vt.kind == syntax.tykind.TY_NAMED) { vt = vt.under; }; if (vt != nil) { if (vt.kind == syntax.tykind.TY_PTR) { return i; }; diff --git a/selfhost/cmd/wcc/check.ww b/selfhost/cmd/wcc/check.ww index f99c81af..cb958f78 100644 --- a/selfhost/cmd/wcc/check.ww +++ b/selfhost/cmd/wcc/check.ww @@ -1254,7 +1254,7 @@ fn primtypesize(nm: str) i64 = { // #43: SSoT for slice header size (ptr+len+cap = 24B today). Mirrors // cstage cmd/wcc/type.c:103 (ty_slice->size = 24). Bumping a slice's // header layout in #34 touches only this constant. -fn tyslicesize() i64 = { return 24i64; }; // sizelint-ok: SSoT for ty_slice header (#64) +fn tyslicesize() i64 = { return 24i64; }; // #42: AST-level layout helpers for the size(T)/align(T)/offset(e.f) // fold. Mirror cstage resolve_type's size/align computation @@ -2226,9 +2226,6 @@ fn tinfofornode(c: *checker, n: *syntax.node) *syntax.tinfo = { under = c.tc.tyerr; }; named.resolving = 0; - // peellint-ok: construction — the one - // WRITE that builds the NAMED link; - // not a peel, can't route via tichase. named.under = under; if (under != nil) { named.size = under.size; @@ -2663,7 +2660,7 @@ fn unifyarith(c: *checker, e: *syntax.node, ltn: *syntax.node, rtn: *syntax.node // agree. Mirrors cstage unify_arith (cmd/wcc/check.c:1060-1067) and // harec type_promote (ref/harec/src/check.c:1083-1105). The error // axis (varianterr) must agree on both sides so a `!i32` alias does - // NOT promote against a plain i32 (#246, 949_errtype_compare). + // NOT promote against a plain i32 (#246, r949_errtype_* fixtures). // A user alias is an SK_TYPE sym WITH a decl body; the primitives are // SK_TYPE too but decl == nil (check.ww:95-112), so aliassym alone // would mis-flag i32 as "named". This decl != nil gate is the wwstage