chore(specializer): wave-5 close-out — spec addendum, clippy while-let fixes, TASK-52 all ACs checked + Done

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: 2 people

backlog/tasks/task-52 - Specializer-wave-5-—-structural-dialect-sweep-slices-subscripts-operators-star-forms-dup-name-contract-binder-tail.md

@@ -3,10 +3,10 @@ id: TASK-52
 title: >-
   Specializer wave 5 — structural + dialect sweep (slices, subscripts,
   operators, star forms, dup-name contract, binder tail)
-status: In Progress
+status: Done
 assignee: []
 created_date: '2026-07-26 21:46'
-updated_date: '2026-07-26 22:52'
+updated_date: '2026-07-26 23:10'
 labels: []
 milestone: m-7
 dependencies:
@@ -37,9 +37,9 @@ Out of wave: regexp family (wave B), lists/structs (wave C), stage-B multiplicit
 - [x] #3 Extended subscripts serve: dynamic, negative, out-of-range indices per pins
 - [x] #4 Operator/star dialect forms serve or reclassify cleanly: ^@, GLOB, << >>, * LIKE/ILIKE/SIMILAR, * REPLACE, * RENAME, qualified EXCLUDE, alias-prefix colon
 - [x] #5 Duplicate output column names: contract pinned to DuckDB Python-client behavior, implemented across output modes
-- [ ] #6 Binder tail per pins: NULL <op> NULL typing, lateral aliases, t(a,b), NATURAL JOIN, schema-qualified driving relation, BETWEEN/IN mixed-type semantics
-- [ ] #7 Corpus replay: three-outcome contract holds, zero FAILs, match count reported (ceiling ~130 over 395)
-- [ ] #8 Gate green both backends, clippy clean, serving-bench parity gate passes
+- [x] #6 Binder tail per pins: NULL <op> NULL typing, lateral aliases, t(a,b), NATURAL JOIN, schema-qualified driving relation, BETWEEN/IN mixed-type semantics
+- [x] #7 Corpus replay: three-outcome contract holds, zero FAILs, match count reported (ceiling ~130 over 395)
+- [x] #8 Gate green both backends, clippy clean, serving-bench parity gate passes
 <!-- AC:END -->
 
 ## Implementation Plan
@@ -55,3 +55,21 @@ Stages (each lands with tests + corpus replay green):
 7. Census + bench parity + close-out.
 Spec: docs/superpowers/specs/2026-07-26-wave5-structural-pins.md (pins committed cc28fc0, before implementation).
 <!-- SECTION:PLAN:END -->
+
+## Implementation Notes
+
+<!-- SECTION:NOTES:BEGIN -->
+Corpus arc through the wave (census_wave5, all zero-FAIL): 395 -> 397 (colon alias) -> 427 (slices+subscripts) -> 431 (bitwise) -> 446 (^@+GLOB) -> 477 (star forms + dup-name rename) -> 484 (binder tail). +89 of the ~130 ceiling; the remainder is gated by dynamic self-joins, wave-B regexp (SIMILAR TO star, COLUMNS), lists/structs, and the USING-unmerge corner.
+
+Two replay FAILs caught and fixed during stage 6 (NULL ^@ NULL typing; exec-time IN-list conversion on empty input) — the three-outcome contract did its job; corrections recorded in the spec addendum.
+<!-- SECTION:NOTES:END -->
+
+## Final Summary
+
+<!-- SECTION:FINAL_SUMMARY:BEGIN -->
+Wave 5 shipped: the structural + dialect sweep, corpus 395 -> 484 bit-exact of 678 (+89, zero wrong answers, zero replay FAILs throughout). Pins-first: an 8-agent measurement fleet (7 DuckDB areas + a sqlparser capability spike) landed as docs/superpowers/specs/2026-07-26-wave5-structural-pins.md + pins-wave5/*.json BEFORE implementation, with a post-landing addendum recording two corpus-caught corrections (NULL ^@ NULL typing; exec-time IN-list conversion — an empty input succeeds in DuckDB, so non-numeric literals stay clean-unsupported).
+
+Landed in seven stages: (1a) frontend switched to GenericDialect — measured strict superset, byte-identical corpus; (1b) colon prefix alias k: expr via token pre-rewrite (sqlparser misparses it SILENTLY as a Snowflake JSON path — no error to catch); (2) bracket subscripts s[i] and slices s[a:b] bound onto the wave-3 kernels with chained access, open-bound desugar, and the asymmetric ±2^32 runtime trap window on both backends; (3) bitwise << >> & | + xor() as new i64 BinOps with DuckDB's five-step << trap ladder, >> total, and a source-order re-association pass because DuckDB puts all four in ONE flat left-assoc tier while sqlparser tiers them (fold shares the duck_shl kernel so folding and trapping can never disagree); (4) ^@ -> the starts_with kernel + a dedicated byte-level GLOB matcher (one-byte ?, byte-set classes where only ! negates, literal-if-first ']'/'-' rules, dead patterns match nothing) reached via a LIKE + __glob_pat marker rewrite; (5) star forms — name filters * LIKE/ILIKE/NOT LIKE/GLOB over column names, qualified EXCLUDE, * REPLACE, * RENAME — plus the duplicate-name contract: dedup_output_names applies DuckDB's own boundary rename (left-to-right, own-case _N, case-insensitive incl. candidates), verified against .df(); (6) binder tail — lateral aliases with real-column-wins shadowing in SELECT and WHERE, NULL <op> NULL typing by operator, main.tbl qualifier, NATURAL JOIN desugared to USING with the pinned hard error, t AS u(x,y) via a Cow column view, mixed BETWEEN/IN literal casts with half-away rounding.
+
+Gate: 148 Rust + 553 py green (interp backend identical except the deliberate backend-identity guards), clippy clean on wave files, serving-bench parity gate passed on all four scenarios with the typed path at 1.4-2.0x over handcrafted python in 16/16 cells — 27 new surface forms cost the hot path nothing. Remaining unsupported head after the wave: aggregation 45 (out of scope), table-fns 24 (out of scope), regexp ~25+SIMILAR/COLUMNS (wave B), lists/structs 25 (wave C), dynamic self-joins 10, small named tails.
+<!-- SECTION:FINAL_SUMMARY:END -->

docs/superpowers/specs/2026-07-26-wave5-structural-pins.md

@@ -196,6 +196,35 @@ gated by self-join first.
 - `try_trim_null` does not exist in DuckDB (stays clean-unsupported as an
   unknown function); `COLUMNS` is star-expansion only (wave-B).
 
+## Implementation addendum (2026-07-27, post-landing corrections)
+
+Deviations and corrections discovered while landing — same discipline as
+the wave-3 addendum (the corpus replay is the arbiter):
+
+- **Mixed BETWEEN/IN with non-numeric string literals stays
+  clean-unsupported, not a bind error.** The binder-tail pin's bind-time
+  "Conversion Error" applies to top-level constant comparisons; inside an
+  IN-list against a COLUMN the conversion is EXECUTION-time — corpus case
+  `a IN ('a', ...)` on an EMPTY table succeeds in DuckDB. Caught as a
+  replay FAIL, fixed to conservative unsupported. Numeric/bool literals DO
+  convert at bind (half-away rounding, bool -> 0/1).
+- **sqlparser parses `* ILIKE` and EXCLUDE as mutually exclusive**, so the
+  star-filter rewrite absorbs the EXCLUDE entries into its marker string
+  and the binder re-applies them.
+- Error-class simplifications (all corpus-clean, texts not verbatim):
+  zero-match star filters use a short "empty set of columns" Bind text
+  rather than DuckDB's internal COLUMNS(list_filter(...)) desugaring;
+  `* SIMILAR TO` and REPLACE/RENAME-plus-filter classify at parse (DuckDB
+  parses then bind-errors); EXCLUDE/REPLACE duplicate-entry checks surface
+  at bind with matching wording.
+- `* EXCLUDE (t.key)` on a USING join stays unsupported (DuckDB UNMERGES
+  the column — not modeled); all other qualified EXCLUDE forms serve.
+- `~` (prefix bitnot) and `#` stay unsupported alongside `^` (pow): their
+  sqlparser precedence disagrees with DuckDB's measured one, and mapping
+  them would silently compute the wrong tree. xor() covers the semantics.
+- NULL || NULL types as VARCHAR here (DuckDB's SQLNULL materializes as
+  INTEGER); value-NULL either way, positional corpus compare unaffected.
+
 ## Implementation stages (each lands with tests + corpus replay green)
 
 1. Parser groundwork: GenericDialect switch (full regression net), colon-

src/specializer/rewrite.rs

@@ -78,8 +78,7 @@ pub fn rewrite_star_filters(tokens: Vec<Token>) -> Vec<Token> {
             }
             if matches!(tokens.get(i), Some(Token::LParen)) {
                 let mut depth = 0i32;
-                loop {
-                    let Some(tok) = tokens.get(i) else { break };
+                while let Some(tok) = tokens.get(i) {
                     match tok {
                         Token::LParen => depth += 1,
                         Token::RParen => depth -= 1,
@@ -198,8 +197,7 @@ pub fn rewrite_glob(tokens: Vec<Token>) -> Vec<Token> {
         // Copy one primary: a balanced group or a single token, then
         // directly-attached `.word` / `(...)` / `[...]` chains.
         let mut depth = 0i32;
-        loop {
-            let Some(tok) = tokens.get(i) else { break };
+        while let Some(tok) = tokens.get(i) {
             match tok {
                 Token::LParen | Token::LBracket => {
                     depth += 1;