emit-portable: precedence-gated mixfix LEDs (ternary + chain-rhs in/instanceof)

The portable parser's mixfix leds bound maximally tight — fine for access tails
(`.`/`(`/`[`) but wrong for a precedence-carrying led like the ternary `? :`
(`a == b ? c : d` must group as `(a == b) ? c : d`). The led loop now gates such a
led by its lbp (from the grammar's ledPrec): bind only when lbp > minBp. And a
chain-rhs led (`in`/`instanceof`) parses its trailing self-operand at the level's bp
via a new `ruleBp` step, so `a in b in c` left-chains as `(a in b) in c`. Both
derive from analyzeGrammar's ledPrecByConnector — single-sourced with the interpreter.

examples/ledjs.ts verifies it across ts/go/rust — 11/11 accept (ternary below the
operators, right-associative `a ? b : c ? d : e`, chain-rhs `in`), 4/4 reject,
byte-identical to createParser. Full suite 42/42. This is the precedence foundation
the no-`in` (suppress) context builds on next.

Author: johnsoncodehk

examples/ledjs.ts

@@ -0,0 +1,46 @@
+// Exercises precedence-gated mixfix LEDs: the ternary `? :` (a led that binds LOOSER than the
+// operators, so `a == b ? c : d` groups as `(a == b) ? c : d`) and `in`/`instanceof` (chain-rhs
+// leds at the relational level — `a in b in c` left-chains as `(a in b) in c`). Both need the
+// led-precedence gate the portable parser previously lacked (its mixfix leds bound maximally tight).
+import {
+  token, rule, defineGrammar, left, right, op,
+  seq, oneOf, range, star, many,
+} from '../src/api.ts';
+
+const idStart = oneOf(range('a', 'z'), range('A', 'Z'), '_', '$');
+const idCont = oneOf(range('a', 'z'), range('A', 'Z'), range('0', '9'), '_', '$');
+const Ident = token(seq(idStart, star(idCont)), { identifier: true, scope: 'variable' });
+const Number_ = token(seq(range('0', '9'), star(range('0', '9'))), { scope: 'constant.numeric' });
+
+const jsPrec = [
+  right('='),
+  left('||'),
+  left('==', '!='),
+  left('<', '>'),
+  left('+', '-'),
+  left('*', '/'),
+];
+
+const Expr = rule(($) => [
+  Number_, Ident,
+  ['(', $, ')'],
+  [$, op, $],
+  [$, '?', $, ':', $],          // ternary (binds below `||`)
+  [$, 'in', $],                 // relational chain-rhs
+  [$, 'instanceof', $],
+]);
+const Stmt = rule(($) => [[Expr, ';']]);
+const Program = rule(($) => [many(Stmt)]);
+
+export default defineGrammar({
+  name: 'ledjs',
+  scopeName: 'source.ledjs',
+  tokens: { Ident, Number: Number_ },
+  prec: jsPrec,
+  ledPrec: [
+    { connector: '?', below: '||' },
+    { connector: 'in', sameAs: '<', chainRhs: true },
+    { connector: 'instanceof', sameAs: '<', chainRhs: true },
+  ],
+  rules: { Expr, Stmt, Program },
+});

src/emit-portable.ts

@@ -46,6 +46,7 @@ export type Step =
   | { t: 'lit'; value: string; ttype: '$keyword' | '$punct' }   // match a literal by text
   | { t: 'tok'; name: string }                                  // match a token kind
   | { t: 'rule'; name: string }                                 // call a rule, append its node
+  | { t: 'ruleBp'; name: string; bp: number }                   // call a Pratt rule at a given binding power (chain-rhs led trailing operand)
   | { t: 'star'; step: Step }                                   // repeat inner 0+
   | { t: 'opt'; steps: Step[] }                                 // optional sub-sequence
   | { t: 'sep'; elem: Step; delim: string }                     // elem (delim elem)*
@@ -69,6 +70,7 @@ export type PrattRule = {
   binary: Array<{ op: string; lbp: number; rbp: number }>;  // LED: infix op, bind iff lbp > minBp, rhs at rbp
   leds: Bracket[];                                    // LED: mixfix continuation (call/member/index), tried before operators
   ledAccessTail: boolean[];                           // parallel to leds: a "closed punct-connector" tail (member/call/index) — disabled once a postfix binds
+  ledLbp: Array<number | null>;                       // parallel to leds: precedence gate (ternary/in/instanceof) — bind only when lbp > minBp; null = bind maximally tight
   postfixToks: string[];                              // LED: a postfix token `$ X` (e.g. a tagged template), tried like a mixfix led (also an access tail)
   postfix: Array<{ op: string; lbp: number }>;        // LED: a postfix operator `$ ++` — binds iff lbp > minBp + !tailClosed, no rhs, closes the tail
 };
@@ -268,6 +270,7 @@ function buildPratt(
   let sawPrefix = false, sawBinary = false, sawPostfix = false;
   const leds: Bracket[] = [];
   const ledAccessTail: boolean[] = [];
+  const ledLbp: Array<number | null> = [];
   const postfixToks: string[] = [];
   for (const alt of alts) {
     const items = alt.type === 'seq' ? alt.items : [alt];
@@ -303,12 +306,17 @@ function buildPratt(
     if (rest[0].type === 'op') { sawBinary = true; continue; }
     if (rest[0].type === 'postfix') { sawPostfix = true; continue; }   // postfix operator (`x++`)
     if (rest[0].type === 'literal') {
+      const conn = rest[0].value;
+      const prec = a.ledPrecByConnector.get(conn);   // { lbp, rhsBp } for ternary/in/instanceof
       const steps = rest.map((it) => stepOfPratt(it));
       const last = steps[steps.length - 1];
       const lastIsOperand = last !== undefined && last.t === 'rule' && last.name === name;   // open binary/ternary operand
-      const wordConnector = /^[A-Za-z]/.test(rest[0].value);                                  // `in`/`instanceof`/`as` — not a tail
-      leds.push({ first: rest[0].value, steps });
+      // chain-rhs (`in`/`instanceof`): the trailing self-operand parses at the level's bp (left-chain).
+      if (prec && prec.rhsBp !== null && lastIsOperand) steps[steps.length - 1] = { t: 'ruleBp', name, bp: prec.rhsBp };
+      const wordConnector = /^[A-Za-z]/.test(conn);                                           // `in`/`instanceof`/`as` — not a tail
+      leds.push({ first: conn, steps });
       ledAccessTail.push(!lastIsOperand && !wordConnector);
+      ledLbp.push(prec ? prec.lbp : null);
       continue;
     }
     if (rest.length === 1 && rest[0].type === 'ref' && a.tokenNames.has(rest[0].name)) { postfixToks.push(rest[0].name); continue; }  // postfix token (tagged template)
@@ -337,5 +345,5 @@ function buildPratt(
   const postfix = sawPostfix
     ? [...a.opTable.entries()].filter(([, info]) => info.position === 'postfix').map(([op, info]) => ({ op, lbp: info.lbp }))
     : [];
-  return { kind: 'pratt', name, nudToks, nudBrackets, nudSeqs, nudCapped, prefix, binary, leds, ledAccessTail, postfixToks, postfix };
+  return { kind: 'pratt', name, nudToks, nudBrackets, nudSeqs, nudCapped, prefix, binary, leds, ledAccessTail, ledLbp, postfixToks, postfix };
 }

src/target-go.ts

@@ -169,6 +169,7 @@ function stepCond(s: Step): string {
     case 'lit': return `matchLit(${J(s.value)}, ${J(s.ttype)})`;
     case 'tok': return `matchTok(${J(s.name)})`;
     case 'rule': return `callRule(parse${s.name})`;
+    case 'ruleBp': return `callRule(func() int32 { return ${s.name}bp(${s.bp}) })`;
     case 'star': return `star(func() bool { return ${stepCond(s.step)} })`;
     case 'opt': return `opt(func() bool { return ${s.steps.map(stepCond).join(' && ')} })`;
     case 'sep': return `sepBy(func() bool { return ${stepCond(s.elem)} }, ${J(s.delim)})`;
@@ -208,7 +209,7 @@ function prattRule(r: PrattRule, tpl: TplCfg | null): string {
 \t\tif ${b.steps.map(stepCond).join(' && ')} { return finish(${J(r.name)}, sb, t.Off) }
 \t\tpos = save; scratch = scratch[:sb]; nodes = nodes[:nb]; kids = kids[:kb]; return -1
 \t}`;
-  const ledArm = (b: Bracket, accessTail: boolean) => `\t\tif ${accessTail ? '!tailClosed && ' : ''}t.Text == ${J(b.first)} {
+  const ledArm = (b: Bracket, accessTail: boolean, lbp: number | null) => `\t\tif ${accessTail ? '!tailClosed && ' : ''}${lbp !== null ? `${lbp} > minBp && ` : ''}t.Text == ${J(b.first)} {
 \t\t\tledSave := pos; sb := len(scratch); nb := len(nodes); kb := len(kids)
 \t\t\tscratch = append(scratch, left)
 \t\t\tif ${b.steps.map(stepCond).join(' && ')} { left = finish(${J(r.name)}, sb, nodes[left].Offset); continue }
@@ -239,7 +240,7 @@ func ${r.name}bp(minBp int) int32 {
 \tfor {
 \t\tt := peek()
 \t\tif t == nil { break }
-${r.leds.map((b, i) => ledArm(b, r.ledAccessTail[i])).join('\n')}
+${r.leds.map((b, i) => ledArm(b, r.ledAccessTail[i], r.ledLbp[i])).join('\n')}
 ${r.postfixToks.map(postfixArm).join('\n')}
 \t\tif post, ok := ${r.name}POST[t.Text]; ok && !tailClosed && post > minBp {
 \t\t\tsb := len(scratch); scratch = append(scratch, left, mkLeaf("$operator", t.Off, t.End)); pos++; tailClosed = true

src/target-rust.ts

@@ -177,6 +177,7 @@ function stepCond(s: Step): string {
     case 'lit': return `self.match_lit(${J(s.value)}, ${J(s.ttype)}, &mut kids)`;
     case 'tok': return `self.match_tok(${J(s.name)}, &mut kids)`;
     case 'rule': return `self.call_rule(Parser::parse_${s.name}, &mut kids)`;
+    case 'ruleBp': return `self.call_rule(|p| p.${s.name}_bp(${s.bp}), &mut kids)`;
     case 'star': return `self.star(|p, k| ${stepCondP(s.step)}, &mut kids)`;
     case 'opt': return `self.opt(|p, k| ${s.steps.map(stepCondP).join(' && ')}, &mut kids)`;
     case 'sep': return `self.sep_by(|p, k| ${stepCondP(s.elem)}, ${J(s.delim)}, &mut kids)`;
@@ -202,6 +203,7 @@ function stepCondP(s: Step): string {
     case 'lit': return `p.match_lit(${J(s.value)}, ${J(s.ttype)}, k)`;
     case 'tok': return `p.match_tok(${J(s.name)}, k)`;
     case 'rule': return `p.call_rule(Parser::parse_${s.name}, k)`;
+    case 'ruleBp': return `p.call_rule(|p| p.${s.name}_bp(${s.bp}), k)`;
     case 'star': return `p.star(|p, k| ${stepCondP(s.step)}, k)`;
     case 'opt': return `p.opt(|p, k| ${s.steps.map(stepCondP).join(' && ')}, k)`;
     case 'sep': return `p.sep_by(|p, k| ${stepCondP(s.elem)}, ${J(s.delim)}, k)`;
@@ -237,7 +239,7 @@ function prattRule(r: PrattRule, tpl: TplCfg | null): string {
             if ${b.steps.map(stepCond).join(' && ')} { return Some(node(${J(r.name)}, kids)); }
             self.pos = save; return None;
         }`;
-  const ledArm = (b: Bracket, accessTail: boolean) => `            if ${accessTail ? '!tail_closed && ' : ''}t.text == ${J(b.first)} {
+  const ledArm = (b: Bracket, accessTail: boolean, lbp: number | null) => `            if ${accessTail ? '!tail_closed && ' : ''}${lbp !== null ? `${lbp} > min_bp && ` : ''}t.text == ${J(b.first)} {
                 let led_save = self.pos; let mut kids: Vec<Cst> = Vec::new();
                 if ${b.steps.map(stepCond).join(' && ')} {
                     let mut full = vec![left]; full.append(&mut kids);
@@ -262,7 +264,7 @@ function prattRule(r: PrattRule, tpl: TplCfg | null): string {
         let mut tail_closed = false;
         loop {
             let t = match self.peek() { Some(t) => t, None => break };
-${r.leds.map((b, i) => ledArm(b, r.ledAccessTail[i])).join('\n')}
+${r.leds.map((b, i) => ledArm(b, r.ledAccessTail[i], r.ledLbp[i])).join('\n')}
 ${r.postfixToks.map(postfixArm).join('\n')}
             if let Some(plbp) = Parser::${r.name}_post(t.text) { if !tail_closed && plbp > min_bp { self.pos += 1; let op_leaf = Cst::leaf("$operator", t.off, t.end); left = node(${J(r.name)}, vec![left, op_leaf]); tail_closed = true; continue; } }
             let (lbp, rbp) = match Parser::${r.name}_bin(t.text) { Some(x) => x, None => break };

src/target-ts.ts

@@ -160,6 +160,7 @@ function stepCond(s: Step): string {
     case 'lit': return `matchLit(${J(s.value)}, ${J(s.ttype)}, kids)`;
     case 'tok': return `matchTok(${J(s.name)}, kids)`;
     case 'rule': return `callRule(parse${s.name}, kids)`;
+    case 'ruleBp': return `callRule(() => ${s.name}_bp(${s.bp}), kids)`;
     case 'star': return `star(() => ${stepCond(s.step)}, kids)`;
     case 'opt': return `opt(() => ${s.steps.map(stepCond).join(' && ')}, kids)`;
     case 'sep': return `sepBy(() => ${stepCond(s.elem)}, ${J(s.delim)}, kids)`;
@@ -193,8 +194,9 @@ function prattRule(r: PrattRule, tpl: TplCfg | null): string {
       if (${b.steps.map(stepCond).join(' && ')}) return node(${J(r.name)}, kids);
       pos = save; return null;
     }`;
-  // Access-tail leds (member/call/index) are disabled once a postfix has closed the operand.
-  const ledArm = (b: Bracket, accessTail: boolean) => `    if (${accessTail ? '!tailClosed && ' : ''}t.text === ${J(b.first)}) {
+  // Access-tail leds (member/call/index) are disabled once a postfix has closed the operand;
+  // a precedence-gated led (ternary/in/instanceof) binds only when its lbp > minBp.
+  const ledArm = (b: Bracket, accessTail: boolean, lbp: number | null) => `    if (${accessTail ? '!tailClosed && ' : ''}${lbp !== null ? `${lbp} > minBp && ` : ''}t.text === ${J(b.first)}) {
       const ledSave = pos; const kids: Cst[] = [left];
       if (${b.steps.map(stepCond).join(' && ')}) { left = node(${J(r.name)}, kids); continue; }
       pos = ledSave; break;
@@ -219,7 +221,7 @@ function ${r.name}_bp(minBp: number): Node | null {
   for (;;) {
     const t = peek();
     if (t === null) break;
-${r.leds.map((b, i) => ledArm(b, r.ledAccessTail[i])).join('\n')}
+${r.leds.map((b, i) => ledArm(b, r.ledAccessTail[i], r.ledLbp[i])).join('\n')}
 ${r.postfixToks.map(postfixArm).join('\n')}
     const post = ${r.name}_POST[t.text];
     if (!tailClosed && post !== undefined && post > minBp) { pos++; const opLeaf: Leaf = { tokenType: '$operator', offset: t.off, end: t.end }; left = { rule: ${J(r.name)}, children: [left, opLeaf], offset: left.offset, end: t.end }; tailClosed = true; continue; }

test/portable-targets.ts

@@ -154,6 +154,17 @@ const CASES: Case[] = [
     ],
     reject: ['=> x;', 'x => ;', '1 + () => 2;', '(,) => b;'],
   },
+  {
+    // Precedence-gated mixfix LEDs: ternary `? :` (binds below the operators) and the
+    // chain-rhs relational leds `in`/`instanceof` (`a in b in c` left-chains).
+    grammar: 'ledjs', path: '../examples/ledjs.ts',
+    accept: [
+      'a == b ? c : d;', 'a ? b : c ? d : e;', 'a + b ? c : d - e;', 'a in b;',
+      'a in b in c;', 'x instanceof Y;', 'a < b in c;', '1 + 2 * 3 ? 4 : 5;',
+      '(a ? b : c) + d;', 'a in b ? c : d;', 'a = b ? c : d;',
+    ],
+    reject: ['a ? b;', 'a ? : c;', 'in b;', 'a instanceof;'],
+  },
 ];
 
 const sortKeys = (o: unknown): unknown =>