Reject unary-prefix left operand of '**' (TS17006)

`-x ** y` / `typeof x ** y` are syntax errors in JS/TS: the left operand of
`**` must be an UpdateExpression, not a UnaryExpression (write `(-x) ** y` or
`-(x ** y)`). We parsed it silently as `(-x) ** y`.

New declarable, language-agnostic operator property: `noUnaryLhs('**')` marks an
infix op whose left operand may not be a bare unary-prefix expression. The engine
enforces it generically — when such an op is about to bind and the lhs is a
prefix-op node whose operator is NOT also a postfix (i.e. a pure unary like
`-`/`!`/`typeof`, as opposed to an update `++`/`--`), the whole expression fails
hard (returns null). Failing hard (not just declining to bind) is required so it
can't reparse another way: left-assoc `(x ** -y) ** z`, or `typeof` degrading to a
bare identifier that splits the statement. The check sits at the LED, so
`(-x) ** y` is fine (lhs is a paren node, not a prefix node). It's a general
property — Python allows `-x ** y` and simply wouldn't declare it.

Correct across the boundary: rejects `-x ** y`, `typeof/void/delete/await x ** y`,
`x ** -y ** z`, `1 ** -2 ** 3`; still parses `x ** -y`, `(-x) ** y`, `-(x ** y)`,
`++x ** y`, `x++ ** y`, `2 ** 3 ** 4`, `-x * y`, `a = -b`.

FP 93->88 (5 es7/exponentiationOperator cases), FN stays 0 (3376/3376), TP
unchanged. agnostic 5/5, refactor-guard 112/112, highlighter 99.3% unchanged,
smoke pass. Artifacts regenerated.

Author: johnsoncodehk

examples/typescript.ts

@@ -1,6 +1,6 @@
 import {
   token, rule, defineGrammar,
-  left, right, none,
+  left, right, none, noUnaryLhs,
   op, prefix, postfix, sameLine,
   sep, opt, many, many1, alt, exclude, not,
 } from '../src/api.ts';
@@ -509,7 +509,7 @@ export default defineGrammar({
     left('<<', '>>', '>>>'),
     left('+', '-'),
     left('*', '/', '%'),
-    right('**'),
+    right(noUnaryLhs('**')),   // `-x ** y` is a syntax error: a unary-prefix expr can't be a `**` LHS
     right(prefix('!', '~', '+', '-', 'typeof', 'void', 'delete', 'await', 'yield')),
     right(prefix('++', '--')),
     left(postfix('++', '--')),

src/api.ts

@@ -79,6 +79,7 @@ interface PostfixSlot {
 }
 interface PrefixOps { readonly __kind: 'prefix-ops'; ops: string[] }
 interface PostfixOps { readonly __kind: 'postfix-ops'; ops: string[] }
+interface NoUnaryLhsOps { readonly __kind: 'no-unary-lhs-ops'; ops: string[] }
 
 type Marker = OpMarker | PrefixSlot | PostfixSlot | SameLineMarker;
 
@@ -97,6 +98,13 @@ export const postfix: PostfixSlot = Object.assign(
   { __kind: 'postfix' as const },
 ) as PostfixSlot;
 
+// Mark infix operators whose LEFT operand may not be a bare unary-prefix expression
+// (a prefix-op result that is NOT also an update `++`/`--`). E.g. JS `**`: `-x ** y`
+// is a syntax error (write `(-x) ** y` or `-(x ** y)`), but `x ** -y`, `(-x) ** y`,
+// and `++x ** y` are fine. A general, declarable property — Python, by contrast,
+// allows `-x ** y` and would not use this. The engine enforces it generically.
+export const noUnaryLhs = (...ops: string[]): NoUnaryLhsOps => ({ __kind: 'no-unary-lhs-ops' as const, ops });
+
 // ── Combinators ──
 
 class SepNode {
@@ -192,29 +200,33 @@ interface PrecLevelDef {
   operators: PrecOperator[];
 }
 
-function buildPrecOps(ops: (string | PrefixOps | PostfixOps)[]): PrecOperator[] {
+type OpSpec = string | PrefixOps | PostfixOps | NoUnaryLhsOps;
+
+function buildPrecOps(ops: OpSpec[]): PrecOperator[] {
   const result: PrecOperator[] = [];
   for (const o of ops) {
     if (typeof o === 'string') {
       result.push({ value: o, position: 'infix' });
     } else if (o.__kind === 'prefix-ops') {
       for (const v of o.ops) result.push({ value: v, position: 'prefix' });
-    } else {
+    } else if (o.__kind === 'postfix-ops') {
       for (const v of o.ops) result.push({ value: v, position: 'postfix' });
+    } else {
+      for (const v of o.ops) result.push({ value: v, position: 'infix', noUnaryLhs: true });
     }
   }
   return result;
 }
 
-export function left(...ops: (string | PrefixOps | PostfixOps)[]): PrecLevelDef {
+export function left(...ops: OpSpec[]): PrecLevelDef {
   return { __kind: 'prec-level', assoc: 'left', operators: buildPrecOps(ops) };
 }
 
-export function right(...ops: (string | PrefixOps | PostfixOps)[]): PrecLevelDef {
+export function right(...ops: OpSpec[]): PrecLevelDef {
   return { __kind: 'prec-level', assoc: 'right', operators: buildPrecOps(ops) };
 }
 
-export function none(...ops: (string | PrefixOps | PostfixOps)[]): PrecLevelDef {
+export function none(...ops: OpSpec[]): PrecLevelDef {
   return { __kind: 'prec-level', assoc: 'none', operators: buildPrecOps(ops) };
 }
 

src/gen-parser.ts

@@ -42,6 +42,12 @@ export function createParser(grammar: CstGrammar) {
   // Build precedence table
   const opTable = new Map<string, OpInfo>();
   const prefixOps = new Map<string, OpInfo>();
+  // Infix ops whose LEFT operand may not be a bare unary-prefix expression (e.g. `**`).
+  // A prefix op that is NOT also a postfix op is a "pure unary" prefix (`-`/`!`/`typeof`…)
+  // as opposed to an update (`++`/`--`, which are both prefix and postfix); only the
+  // pure-unary ones are forbidden before a noUnaryLhs operator.
+  const noUnaryLhsOps = new Set<string>();
+  const postfixOpValues = new Set<string>();
 
   for (let i = 0; i < grammar.precs.length; i++) {
     const level = grammar.precs[i];
@@ -55,6 +61,7 @@ export function createParser(grammar: CstGrammar) {
           position: 'prefix',
         });
       } else if (op.position === 'postfix') {
+        postfixOpValues.add(op.value);
         opTable.set(op.value, {
           lbp: bp,
           rbp: 0,
@@ -65,6 +72,7 @@ export function createParser(grammar: CstGrammar) {
         const lbp = bp;
         const rbp = level.assoc === 'right' ? bp - 1 : bp;
         opTable.set(op.value, { lbp, rbp, assoc: level.assoc, position: 'infix' });
+        if (op.noUnaryLhs) noUnaryLhsOps.add(op.value);
       }
     }
   }
@@ -706,6 +714,20 @@ export function createParser(grammar: CstGrammar) {
               matched = true;
             }
           } else {
+            // A `noUnaryLhs` op (e.g. `**`) may not take a bare unary-prefix expression
+            // (`-x`, `typeof x` — a prefix-op node whose op is NOT also a postfix, i.e.
+            // not an update `++`/`--`) as its LEFT operand. Fail the whole expression
+            // hard (return null) rather than just declining to bind — otherwise it could
+            // reparse another way (left-assoc `(x ** -y) ** z`, or `typeof` as a bare
+            // identifier splitting the statement). `(-x) ** y` is unaffected: lhs is then
+            // a parenthesized node, not a prefix node.
+            if (noUnaryLhsOps.has(tokKey) && lhs.kind === 'node') {
+              const head = lhs.children[0];
+              if (head?.kind === 'leaf' && head.tokenType === '$operator'
+                  && prefixOps.has(head.text) && !postfixOpValues.has(head.text)) {
+                return null;
+              }
+            }
             pos++;
             const opLeaf: CstLeaf = { kind: 'leaf', tokenType: '$operator', text: tok.text, offset: tok.offset, end: tok.offset + tok.text.length };
             const rhs = parsePratt(rule, info.rbp);

src/types.ts

@@ -39,6 +39,7 @@ export interface RegexContext {
 export interface PrecOperator {
   value: string;
   position: 'infix' | 'prefix' | 'postfix';
+  noUnaryLhs?: boolean;  // infix op whose left operand may not be a bare unary-prefix expression (e.g. JS `**`)
 }
 
 export interface PrecLevel {