Reject property access on a bare instantiation expression (TS1477)

`Foo<T>.Bar()` — a bare type-argument instantiation followed by property access —
is a TS error (TS1477), but our access LEDs chained `.Bar` straight onto the
instantiation. Same family as the prior 'postfix closes the access tail' fix.

Grammar: split Expr's instantiation LED into a call/tag arm (an ordinary access
tail — `f<T>().x` still chains) and a separate bare-instantiation arm ending in
the negative lookahead `not(Expr)`.

Engine (still language-agnostic): a LED whose last item is a zero-width negative
lookahead is a 'tail-closing' LED — once it binds, it sets tailClosed, so the
access-tail LEDs (`.`/`?.`/`[`/call/`<T>`/tagged-template) can't chain off it.
Keyed purely on the structural shape '`led` ends in a not assertion', no TS
knowledge; there is exactly one such LED in the grammar.

Verified: rejects `Foo<T>.Bar()`/`Foo<T>.Bar<T>()`; still parses `Foo<T>()`,
`Foo.Bar<T>()`, `Foo<T>`x`` (tagged), `Foo<T>().x`, `Foo<T> as Bar`, `Foo<T>[0]`.
FP 95->93, 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/lezer/typescript.grammar

@@ -48,7 +48,8 @@ Expr {
     kw_this |
     kw_super |
     Spread Expr |
-    Expr AngleL (Type (Comma Type)*)? AngleR (ParenL (Expr (Comma Expr)*)? ParenR | Template | ) |
+    Expr AngleL (Type (Comma Type)*)? AngleR (ParenL (Expr (Comma Expr)*)? ParenR | Template) |
+    Expr AngleL (Type (Comma Type)*)? AngleR |
     Expr ParenL (Expr (Comma Expr)*)? ParenR |
     Expr Dot (Ident | PrivateField) |
     Expr QuestionDot (Ident | PrivateField | ParenL (Expr (Comma Expr)*)? ParenR | BracketL Expr BracketR | Template) |

examples/tree-sitter/grammar.js

@@ -72,7 +72,8 @@ module.exports = grammar({
       "this",
       "super",
       seq("...", $.expr),
-      prec.left(18, seq($.expr, "<", optional(seq($.type, repeat(seq(",", $.type)), optional(","))), ">", choice(seq("(", optional(seq($.expr, repeat(seq(",", $.expr)), optional(","))), ")"), $.template, blank()))),
+      prec.left(18, seq($.expr, "<", optional(seq($.type, repeat(seq(",", $.type)), optional(","))), ">", choice(seq("(", optional(seq($.expr, repeat(seq(",", $.expr)), optional(","))), ")"), $.template))),
+      prec.left(18, seq($.expr, "<", optional(seq($.type, repeat(seq(",", $.type)), optional(","))), ">")),
       prec.left(18, seq($.expr, "(", optional(seq($.expr, repeat(seq(",", $.expr)), optional(","))), ")")),
       prec.left(18, seq($.expr, ".", choice($.ident, $.private_field))),
       prec.left(18, seq($.expr, "?.", choice($.ident, $.private_field, seq("(", optional(seq($.expr, repeat(seq(",", $.expr)), optional(","))), ")"), seq("[", $.expr, "]"), $.template))),

examples/typescript.ts

@@ -188,11 +188,18 @@ const Expr = rule($ => [
   [prefix, $],
   [$, postfix],
   ['...', $],
-  // instantiation / typed call / tagged template: f<T> | f<T>(…) | f<T>`…`
-  // A bare instantiation `f<T>` (no call/tag) only when the next token can't
-  // start an expression — otherwise `<`/`>` were comparisons (`f < a, b > 7`):
-  // the same disambiguation TS makes via canFollowTypeArgumentsInExpression.
-  [$, '<', sep(Type, ','), '>', alt(['(', sep($, ','), ')'], Template, not(Expr))],
+  // typed call / tagged template: f<T>(…) | f<T>`…` — a call/tag may itself be
+  // continued by member access (`f<T>().x`), so this is an ordinary access tail.
+  [$, '<', sep(Type, ','), '>', alt(['(', sep($, ','), ')'], Template)],
+  // bare instantiation `f<T>` (no call/tag): allowed only when the next token
+  // can't start an expression — otherwise `<`/`>` were comparisons (`f < a, b > 7`),
+  // the disambiguation TS makes via canFollowTypeArgumentsInExpression. Ending in a
+  // negative lookahead, this LED closes the access tail (it asserts nothing follows),
+  // so a `.`/`?.` property access can't chain off it: `Foo<T>.Bar` is rejected
+  // (TS1477 — a bare instantiation is not a valid base for property access). A `[`,
+  // `(`, or `` ` `` continuation still reparses the `<…>` as comparisons (those start
+  // an expression, so `not($)` fails the bare arm), matching TS.
+  [$, '<', sep(Type, ','), '>', not(Expr)],
   [$, '(', sep($, ','), ')'],
   [$, '.', alt(Ident, PrivateField)],
   // optional chaining: ?.x | ?.#x | ?.(args) | ?.[i] | ?.`…`

src/gen-parser.ts

@@ -240,6 +240,15 @@ export function createParser(grammar: CstGrammar) {
   // binary/ternary `… in $` / `? $ : $`) AND whose connector is a punctuator, not a
   // word-operator — so `as`/`satisfies`/`in`/`instanceof`/`?:` still bind after `a++`.
   const accessTailLeds = new Set<object>();
+  // ── Tail-closing LEDs (a LED that itself closes the access tail) ──
+  // A LED ending in a zero-width *negative lookahead* (`… not($)`) asserts that
+  // nothing may follow it, so its result cannot be the base of any further
+  // member/element/call access — once it binds, the access tail is closed (no `.x`,
+  // `[i]`, `(…)`, `<T>`, tagged template). Language-agnostic / structural: keyed on
+  // the LED ending in a `not` assertion, with no knowledge of what it guards. (E.g.
+  // a bare type-argument instantiation `Foo<T>` — written `… '>' not($)` — which TS
+  // forbids from being followed by property access, TS1477.)
+  const tailClosingLeds = new Set<object>();
   for (const [ruleName, { leds }] of prattClassified.entries()) {
     for (const led of leds) {
       const it = led.items;
@@ -249,6 +258,7 @@ export function createParser(grammar: CstGrammar) {
       const lastIsOperand = selfRefName(last, ruleName);                // open binary/ternary operand
       const wordConnector = it[0].type === 'literal' && /^[A-Za-z]/.test(it[0].value);
       if (!lastIsOperand && !wordConnector) accessTailLeds.add(led);
+      if (last.type === 'not') tailClosingLeds.add(led);
     }
   }
 
@@ -673,6 +683,9 @@ export function createParser(grammar: CstGrammar) {
               offset: lhs.offset,
               end: children.length > 0 ? childEnd(children[children.length - 1]) : lhs.end,
             };
+            // A LED ending in a negative lookahead (e.g. a bare instantiation
+            // `Foo<T>`) closes the access tail: nothing may chain off it.
+            if (tailClosingLeds.has(led)) tailClosed = true;
             matched = true;
             break;
           }