SH3-1b: fix shape parseAst over-suppressing prec-binary ops.

exclude/suppress only gates literal-headed LEDs; shape Pratt binary
wrongly consulted suppressCur, rejecting noplus 1*2 while CST/interp
accepted. Drop the binary-path check in TS+Rust; extend toy corpus.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: johnsoncodehk

src/target-rust.ts

@@ -3456,10 +3456,9 @@ function emitRustPrattMethod(
     const binaryArms = rule.binary.map((b) =>
       `Some(${lidOf(ids, b.op)}) => (${b.lbp}, ${b.rbp}),`,
     ).join('\n                ');
+    // Binary `$ op $` must NOT consult suppress_cur — exclude only disables
+    // literal-headed LEDs (≡ CST / interpreter / TS shape).
     binaryBody = `{
-            if let Some(t) = self.toks.get(self.pos) {
-                if self.suppress_cur.contains(&t.lid) { break; }
-            }
             let (_lbp, _rbp) = match self.peek_lid() {
                 ${binaryArms}
                 _ => break,

src/target-ts.ts

@@ -3429,12 +3429,13 @@ function emitAstPrattRule(r: PrattRule, sir: ShapeIRRule, ids: LexIdPlan, shapeI
     }
   }
 
+  // Binary `$ op $` path must NOT consult `_suppressCur` — exclude/suppress only
+  // disables literal-headed LEDs (e.g. `[$, 'in', $]`), matching CST / interpreter.
   let binaryCode = '    break;';
   if (binarySlot) {
     if (binarySlot.kind === 'node') {
       const binaryNode = binarySlot as NodeShape;
-      binaryCode = `    if (_suppressCur !== null && _suppressCur.has(t.lid)) break;
-    const info = ${r.name}_BIN[t.lid];
+      binaryCode = `    const info = ${r.name}_BIN[t.lid];
     if (info === undefined || info.lbp <= minBp) break;
     const ledSave = pos;
     const opText = _src.slice(t.off, t.end);
@@ -3448,8 +3449,7 @@ function emitAstPrattRule(r: PrattRule, sir: ShapeIRRule, ids: LexIdPlan, shapeI
     leftOff = spOff;
     leftEnd = end;`;
     } else if (binarySlot.kind === 'custom') {
-      binaryCode = `    if (_suppressCur !== null && _suppressCur.has(t.lid)) break;
-    const info = ${r.name}_BIN[t.lid];
+      binaryCode = `    const info = ${r.name}_BIN[t.lid];
     if (info === undefined || info.lbp <= minBp) break;
     const ledSave = pos;
     const opText = _src.slice(t.off, t.end);
@@ -3459,8 +3459,7 @@ function emitAstPrattRule(r: PrattRule, sir: ShapeIRRule, ids: LexIdPlan, shapeI
     left = ${customFinish((binarySlot as CustomShape).fn, '[right]', 'ledSave', '[]', 'left', 'opText')} as ${retType};
     leftEnd = pos > 0 ? toks[pos - 1]!.end : leftEnd;`;
     } else {
-      binaryCode = `    if (_suppressCur !== null && _suppressCur.has(t.lid)) break;
-    const info = ${r.name}_BIN[t.lid];
+      binaryCode = `    const info = ${r.name}_BIN[t.lid];
     if (info === undefined || info.lbp <= minBp) break;
     const ledSave = pos;
     const opText = _src.slice(t.off, t.end);

test/fixtures/shape-toy.ts

@@ -582,7 +582,16 @@ export function buildToyCorpus(seed = 0x5a2_2026): { src: string; source: string
     }
     if (r < .50) return `txn ${pick(ids)}${rng() < .6 ? `:${pick(ids)}` : ''}${pick(['!', '.', '?'])}`;
     if (r < .58) return `line ${pick(ids)} ${pick(ids)}`;
-    if (r < .66) return `noplus ${atom()}+${atom()}`;
+    // SH3-1b: suppress only disables literal LEDs — binary `*`/`/` must still parse
+    // under exclude('*', Expr). Mix ops + grouping so the arm is not `+`-only.
+    if (r < .66) {
+      const op = pick(['+', '-', '*', '/', '+', '*']);
+      const form = rng();
+      if (form < .35) return `noplus ${atom()}${op}${atom()}`;
+      if (form < .55) return `noplus ${atom()}${op}${atom()}${op}${atom()}`;
+      if (form < .75) return `noplus (${atom()}${op}${atom()})`;
+      return `noplus ${atom()}${op}(${atom()}${op}${atom()})`;
+    }
     if (r < .75) {
       const n = 2 + Math.floor(rng() * 5);
       return `repeat ${Array.from({ length: n }, atom).join(' ')}`;
@@ -591,9 +600,16 @@ export function buildToyCorpus(seed = 0x5a2_2026): { src: string; source: string
       const n = Math.floor(rng() * 5);
       return `maybe${n ? ' ' + Array.from({ length: n }, atom).join(' ') : ''}`;
     }
+    // SH3-1b: sep(alt([Ident,':',Number], Number)) — include multi-pair + trailing
+    // delim; incomplete `id:` forms are CST-over-accept (see SH3-1b reply), not emitted.
     if (r < .90) {
       const n = Math.floor(rng() * 4);
-      const pairs = Array.from({ length: n }, () => rng() < .55 ? `${pick(ids)}:${pick(nums)}` : pick(nums));
+      const pairs = Array.from({ length: n }, () => {
+        const k = rng();
+        if (k < .45) return `${pick(ids)}:${pick(nums)}`;
+        if (k < .75) return pick(nums);
+        return `${pick(ids)} : ${pick(nums)}`;
+      });
       return `pairs(${pairs.join(',')}${n && rng() < .3 ? ',' : ''})`;
     }
     if (r < .95) return `notany ${pick(ids.filter((x) => x !== 'bad' && x !== 'worse'))}`;
@@ -637,6 +653,11 @@ export function buildToyCorpus(seed = 0x5a2_2026): { src: string; source: string
     'txn a:b?;', 'txn a:b!;', 'txn a.;', 'line a b;', 'line a\nb;',
     'noplus 1+2;', 'repeat a 1 b 2;', 'maybe;', 'maybe a 1;',
     'pairs();', 'pairs(a:1,2,b:3,);', 'notany good;', 'notany bad;',
+    // SH3-1b: suppress must not block prec-binary `*` (LED-only exclude)
+    'noplus 1 * 2;', 'noplus 1 * 2 * 3;', 'noplus (1*2);', 'noplus 1*2;',
+    'noplus 1/2;', 'noplus 1*2+3;', 'noplus (1*2)*3;', 'noplus 1*(2*3);',
+    // SH3-1b: well-formed sep+alt (incomplete `pairs(a:)` is CST-over-accept — not here)
+    'pairs(a:1);', 'pairs(1, a:2);', 'pairs(a:1, 2, b:3);', 'pairs( a : 1 , );',
     // SH2-0b: choice-arm nested groups + multi-stmt
     'tag x=(1);', 'tag x=((1));', 'tag y=(((2)));', 'tag z:(3);', 'tag z:((a));',
     'tag x:1;tag y=2;', 'bang!x;tag z;', 'tag x=(1);tag y=2;tag z;',

test/shape-parity.ts

@@ -1006,6 +1006,18 @@ async function main(): Promise<void> {
 
   }
 
+  // ── SH3-1b: suppress is LED-only; prec-binary survives exclude('*', Expr) ─
+  const sh31bNoplus = [
+    'noplus 1 * 2;', 'noplus 1 * 2 * 3;', 'noplus (1*2);', 'noplus 1*2;',
+    'noplus 1/2;', 'noplus 1*2+3;', 'noplus (1*2)*3;', 'noplus 1*(2*3);',
+  ];
+  for (const src of sh31bNoplus) {
+    check(
+      accepts(toyMod, src, false) && accepts(toyMod, src, true),
+      `SH3-1b suppress/binary accept ${JSON.stringify(src)}`,
+    );
+  }
+
   // ── Guard + capped witnesses (toy) ────────────────────────────────────────
   check(
     accepts(toyMod, 'a::b;', false) && accepts(toyMod, 'a::b;', true),

test/shape-rust.ts

@@ -286,6 +286,24 @@ async function main(): Promise<void> {
   check('toy CST≡AST accept equivalence', toyAcceptDiv === 0, `${toyCorpus.length} cases, ${toyAcceptDiv} divergences`);
   check('toy TS↔Rust AST isomorphism', toyIsoBad === 0, `${toyIsoN} compared, ${toyIsoBad} divergences`);
 
+  // SH3-1b: suppress is LED-only — prec-binary under exclude('*') must accept + iso
+  const sh31bNoplus = [
+    'noplus 1 * 2;', 'noplus 1 * 2 * 3;', 'noplus (1*2);', 'noplus 1*2;',
+    'noplus 1/2;', 'noplus 1*2+3;', 'noplus (1*2)*3;', 'noplus 1*(2*3);',
+  ];
+  const sh31bLines = runBatch(toyBin, sh31bNoplus);
+  let sh31bBad = 0;
+  for (let i = 0; i < sh31bNoplus.length; i++) {
+    const src = sh31bNoplus[i]!;
+    const tsCst = toyTs.parse(toyTs.tokenize(src)) !== null;
+    const tsAst = toyTs.parseAst(src);
+    const rustOk = sh31bLines[i]!.startsWith('A\t');
+    if (!tsCst || tsAst === null || !rustOk) { sh31bBad++; continue; }
+    const rust = stripSpans(JSON.parse(sh31bLines[i]!.slice(2)));
+    if (JSON.stringify(rust) !== JSON.stringify(stripSpans(tsAst))) sh31bBad++;
+  }
+  check('SH3-1b noplus suppress/binary TS↔Rust', sh31bBad === 0, `${sh31bNoplus.length - sh31bBad}/${sh31bNoplus.length}`);
+
   let failFast = '';
   try {
     emitRust(typescriptGrammar, { shape: typescriptShape });