emit-portable: typescript.ts emits too — both real grammars in the gate (issue #6)

The second real full language now goes through the agnostic emitter end-to-end. Two
type-grammar constructs were the wall:

- A LED with a leading `sameLine` guard (`$ sameLine '<' …`) — TS's generic-args /
  array / non-null type tails that must not cross a newline. The guard is hoisted into
  the led-arm condition (skip, don't break, so the connector can rebind).
- `notLeftLeaf`: a led skipped when the LEFT node's head-leaf text is in a word set
  (`void`/`null`/`this` can't be `.`-qualified as a type). Each target gains a
  `headLeafText` (the leftmost leaf's source text) and the led arm checks it.

typescript.ts (the most complex grammar) emits, compiles and runs in ts/go/rust, and
is gate-maintained alongside javascript.ts (13/13 accept, 4/4 reject ×3, ASCII corpus;
83.5% on the broad curated TS corpus in TS). Full suite 42/42. The agnostic emitter now
covers both full real languages — the issue-#6 goal, proven in three target languages.

Author: johnsoncodehk

src/emit-portable.ts

@@ -74,6 +74,8 @@ export type PrattRule = {
   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
+  ledSameLine: boolean[];                             // parallel to leds: a leading `sameLine` guard (TS type tails) — the connector must be on the operand's line
+  ledNotLeftLeaf: Array<string[] | null>;             // parallel to leds: skip this led when the left node's head-leaf text is in this set (`void.x` etc.)
   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
 };
@@ -304,9 +306,17 @@ function buildPratt(
   const leds: Bracket[] = [];
   const ledAccessTail: boolean[] = [];
   const ledLbp: Array<number | null> = [];
+  const ledSameLine: boolean[] = [];
+  const ledNotLeftLeaf: Array<string[] | null> = [];
   const postfixToks: string[] = [];
   for (const alt of alts) {
-    const items = alt.type === 'seq' ? alt.items : [alt];
+    let items = alt.type === 'seq' ? alt.items : [alt];
+    // A left-recursive continuation may carry a leading `notLeftLeaf(words)` head-leaf guard
+    // before the self `$` — strip it and attach the word set to the led it produces.
+    let nllWords: string[] | null = null;
+    if (items[0].type === 'notLeftLeaf' && items[1]?.type === 'ref' && items[1].name === name) {
+      nllWords = items[0].words; items = items.slice(1);
+    }
     const startsSelf = items[0].type === 'ref' && items[0].name === name;
     if (!startsSelf) {
       // NUD
@@ -331,9 +341,11 @@ function buildPratt(
       continue;
     }
     // LED (starts with self): `$ op $` (binary, op slot + trailing self) or `$ <lit> …` (mixfix)
-    const rest = items.slice(1);
-    if (rest[0].type === 'op') { sawBinary = true; continue; }
-    if (rest[0].type === 'postfix') { sawPostfix = true; continue; }   // postfix operator (`x++`)
+    const restAll = items.slice(1);
+    const hasSameLine = restAll[0]?.type === 'sameLine';   // a TS type tail: `$ sameLine '<' …`
+    const rest = hasSameLine ? restAll.slice(1) : restAll;
+    if (!hasSameLine && rest[0].type === 'op') { sawBinary = true; continue; }
+    if (!hasSameLine && 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
@@ -346,6 +358,8 @@ function buildPratt(
       leds.push({ first: conn, steps });
       ledAccessTail.push(!lastIsOperand && !wordConnector);
       ledLbp.push(prec ? prec.lbp : null);
+      ledSameLine.push(hasSameLine);
+      ledNotLeftLeaf.push(nllWords);
       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)
@@ -376,5 +390,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, cstName, nudToks, nudBrackets, nudSeqs, nudCapped, prefix, binary, leds, ledAccessTail, ledLbp, postfixToks, postfix };
+  return { kind: 'pratt', name, cstName, nudToks, nudBrackets, nudSeqs, nudCapped, prefix, binary, leds, ledAccessTail, ledLbp, ledSameLine, ledNotLeftLeaf, postfixToks, postfix };
 }

src/target-go.ts

@@ -210,7 +210,7 @@ function prattRule(r: PrattRule, tpl: TplCfg | null): string {
 \t\tif ${b.steps.map(stepCond).join(' && ')} { return finish(${J(r.cstName)}, sb, t.Off) }
 \t\tpos = save; scratch = scratch[:sb]; nodes = nodes[:nb]; kids = kids[:kb]
 \t}`;
-  const ledArm = (b: Bracket, accessTail: boolean, lbp: number | null) => `\t\tif ${accessTail ? '!tailClosed && ' : ''}${lbp !== null ? `${lbp} > minBp && ` : ''}!_mySup[${J(b.first)}] && t.Text == ${J(b.first)} {
+  const ledArm = (b: Bracket, accessTail: boolean, lbp: number | null, sameLine: boolean, nll: string[] | null) => `\t\tif ${accessTail ? '!tailClosed && ' : ''}${lbp !== null ? `${lbp} > minBp && ` : ''}${sameLine ? '!t.Nl && ' : ''}${nll ? `!_inW([]string{${nll.map(J).join(', ')}}, headLeafText(left)) && ` : ''}!_mySup[${J(b.first)}] && 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.cstName)}, sb, nodes[left].Offset); continue }
@@ -242,7 +242,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], r.ledLbp[i])).join('\n')}
+${r.leds.map((b, i) => ledArm(b, r.ledAccessTail[i], r.ledLbp[i], r.ledSameLine[i], r.ledNotLeftLeaf[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
@@ -338,6 +338,7 @@ type bp struct{ lbp, rbp int }
 var toks []Tok
 var pos int
 var _capped bool
+var _src string
 var _suppressNext map[string]bool
 var nodes []Node
 var kids []int32
@@ -412,7 +413,14 @@ func writeJSON(id int32, b *strings.Builder) {
 \tfmt.Fprintf(b, "],\\"offset\\":%d,\\"end\\":%d}", nd.Offset, nd.End)
 }
 
+func headLeafText(id int32) string {
+\tfor !nodes[id].IsLeaf && nodes[id].KidCount > 0 { id = kids[nodes[id].KidStart] }
+\treturn _src[nodes[id].Offset:nodes[id].End]
+}
+func _inW(ws []string, s string) bool { for _, w := range ws { if w == s { return true } }; return false }
+
 func parseOnce(src string) int32 {
+\t_src = src
 \ttoks = lex(src)
 \tpos = 0
 \tnodes = nodes[:0]; kids = kids[:0]; scratch = scratch[:0]

src/target-rust.ts

@@ -241,7 +241,7 @@ function prattRule(r: PrattRule, tpl: TplCfg | null): string {
             if ${b.steps.map(stepCond).join(' && ')} { return Some(node(${J(r.cstName)}, kids)); }
             self.pos = save;   // fall through to the next NUD alternative
         }`;
-  const ledArm = (b: Bracket, accessTail: boolean, lbp: number | null) => `            if ${accessTail ? '!tail_closed && ' : ''}${lbp !== null ? `${lbp} > min_bp && ` : ''}!my_sup.iter().any(|c| *c == ${J(b.first)}) && t.text == ${J(b.first)} {
+  const ledArm = (b: Bracket, accessTail: boolean, lbp: number | null, sameLine: boolean, nll: string[] | null) => `            if ${accessTail ? '!tail_closed && ' : ''}${lbp !== null ? `${lbp} > min_bp && ` : ''}${sameLine ? '!t.nl && ' : ''}${nll ? `!self.nll_blocked(&[${nll.map(J).join(', ')}], &left) && ` : ''}!my_sup.iter().any(|c| *c == ${J(b.first)}) && 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);
@@ -268,7 +268,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], r.ledLbp[i])).join('\n')}
+${r.leds.map((b, i) => ledArm(b, r.ledAccessTail[i], r.ledLbp[i], r.ledSameLine[i], r.ledNotLeftLeaf[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.cstName)}, vec![left, op_leaf]); tail_closed = true; continue; } }
             let (lbp, rbp) = match Parser::${r.name}_bin(t.text) { Some(x) => x, None => break };
@@ -352,9 +352,15 @@ fn node(rule: &'static str, kids: Vec<Cst>) -> Cst { let o = kids[0].offset; let
 
 ${lexer(ir)}
 
-struct Parser<'a> { toks: Vec<Tok<'a>>, pos: usize, capped: bool, suppress_next: Vec<&'static str> }
+struct Parser<'a> { toks: Vec<Tok<'a>>, pos: usize, capped: bool, suppress_next: Vec<&'static str>, src: &'a str }
 impl<'a> Parser<'a> {
     fn peek(&self) -> Option<Tok<'a>> { if self.pos < self.toks.len() { Some(self.toks[self.pos]) } else { None } }
+    fn head_leaf_text(&self, node: &Cst) -> &'a str {
+        let mut n = node;
+        while !n.children.is_empty() { n = &n.children[0]; }
+        &self.src[n.offset..n.end]
+    }
+    fn nll_blocked(&self, words: &[&str], node: &Cst) -> bool { let h = self.head_leaf_text(node); words.iter().any(|w| *w == h) }
     fn branch(&self, rule: &'static str, kids: Vec<Cst>, save: usize) -> Cst {
         let offset = if !kids.is_empty() { kids[0].offset } else if save < self.toks.len() { self.toks[save].off } else { 0 };
         let end = if !kids.is_empty() { kids[kids.len() - 1].end } else { offset };
@@ -409,15 +415,15 @@ fn main() {
     // Self-bench: a numeric arg N times the lex+parse loop and prints ms/iteration.
     if let Some(iters) = std::env::args().nth(1).and_then(|a| a.parse::<u64>().ok()) {
         // black_box on the input + result so the optimizer can't elide the lex/parse.
-        for _ in 0..3 { let toks = lex(std::hint::black_box(&src)); let mut p = Parser { toks, pos: 0, capped: false, suppress_next: Vec::new() }; std::hint::black_box(p.parse_${ir.entry}()); }
+        for _ in 0..3 { let toks = lex(std::hint::black_box(&src)); let mut p = Parser { toks, pos: 0, capped: false, suppress_next: Vec::new(), src: &src }; std::hint::black_box(p.parse_${ir.entry}()); }
         let t = std::time::Instant::now();
-        for _ in 0..iters { let toks = lex(std::hint::black_box(&src)); let mut p = Parser { toks, pos: 0, capped: false, suppress_next: Vec::new() }; std::hint::black_box(p.parse_${ir.entry}()); }
+        for _ in 0..iters { let toks = lex(std::hint::black_box(&src)); let mut p = Parser { toks, pos: 0, capped: false, suppress_next: Vec::new(), src: &src }; std::hint::black_box(p.parse_${ir.entry}()); }
         println!("{:.4}", t.elapsed().as_secs_f64() * 1000.0 / iters as f64);
         return;
     }
     let toks = lex(&src);
     let n = toks.len();
-    let mut p = Parser { toks, pos: 0, capped: false, suppress_next: Vec::new() };
+    let mut p = Parser { toks, pos: 0, capped: false, suppress_next: Vec::new(), src: &src };
     match p.parse_${ir.entry}() {
         Some(root) if p.pos == n => { let mut out = String::new(); write_json(&root, &mut out); print!("{}", out); }
         _ => { eprintln!("parse error (pos {}/{})", p.pos, n); std::process::exit(1); }

src/target-ts.ts

@@ -197,7 +197,7 @@ function prattRule(r: PrattRule, tpl: TplCfg | null): string {
     }`;
   // 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 && ` : ''}(_mySup === null || !_mySup.has(${J(b.first)})) && t.text === ${J(b.first)}) {
+  const ledArm = (b: Bracket, accessTail: boolean, lbp: number | null, sameLine: boolean, nll: string[] | null) => `    if (${accessTail ? '!tailClosed && ' : ''}${lbp !== null ? `${lbp} > minBp && ` : ''}${sameLine ? '!t.nl && ' : ''}${nll ? `!${J(nll)}.includes(headLeafText(left)) && ` : ''}(_mySup === null || !_mySup.has(${J(b.first)})) && t.text === ${J(b.first)}) {
       const ledSave = pos; const kids: Cst[] = [left];
       if (${b.steps.map(stepCond).join(' && ')}) { left = node(${J(r.cstName)}, kids); continue; }
       pos = ledSave; break;
@@ -223,7 +223,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], r.ledLbp[i])).join('\n')}
+${r.leds.map((b, i) => ledArm(b, r.ledAccessTail[i], r.ledLbp[i], r.ledSameLine[i], r.ledNotLeftLeaf[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.cstName)}, children: [left, opLeaf], offset: left.offset, end: t.end }; tailClosed = true; continue; }
@@ -302,7 +302,13 @@ let toks: Tok[] = [];
 let pos = 0;
 let _capped = false;
 let _suppressNext: Set<string> | null = null;
+let _src = '';
 function peek(): Tok | null { return pos < toks.length ? toks[pos] : null; }
+function headLeafText(node: Cst): string {
+  let n: Cst = node;
+  while ('children' in n && n.children.length > 0) n = n.children[0];
+  return _src.slice(n.offset, n.end);
+}
 function branch(rule: string, kids: Cst[], save: number): Node {
   const offset = kids.length > 0 ? kids[0].offset : (save < toks.length ? toks[save].off : 0);
   const end = kids.length > 0 ? kids[kids.length - 1].end : offset;
@@ -350,6 +356,7 @@ function altLit(opts: [string, string][], kids: Cst[]): boolean {
 ${matchTemplate}${ruleFns}
 
 const src = readFileSync(0, 'utf8');
+_src = src;
 toks = lex(src);
 pos = 0;
 const root = parse${ir.entry}();

test/portable-targets.ts

@@ -195,6 +195,20 @@ const CASES: Case[] = [
     ],
     reject: ['function (', 'a +;', 'if x {}', '{ a: }', 'for (;;', 'a ? b ;'],
   },
+  {
+    // The real typescript.ts grammar — the second, most complex full language proving the
+    // agnostic emitter (types, generics, interfaces, enums, assertions, variance). ASCII.
+    grammar: 'typescript', path: '../typescript.ts',
+    accept: [
+      'const a: number = 1;', 'let s: string;', 'type Alias = { a: number; b?: string };',
+      'type U = "a" | "b" | "c";', 'function gen2<T, U extends T>(x: T, y: U): T { return x; }',
+      'interface I<T> extends A<T> { m(x: T): T; }', 'const c = x as const;',
+      'function isStr(x: unknown): x is string { return true; }', 'enum E { A, B, C }',
+      'const n = maybe!;', 'let arr: number[];', 'type Fn = (x: number) => string;',
+      'class C<in out T> { value!: T; }',
+    ],
+    reject: ['interface {}', 'const x: = 1;', 'enum {}', 'a + ;'],
+  },
 ];
 
 const sortKeys = (o: unknown): unknown =>