@willbooster/tree-sitter-typescript 1.2.0 → 1.2.2

package/README.md

@@ -103,9 +103,10 @@ cargo test
 
 - the corpus in `test/corpus`, with the native build and with the Wasm build (the first run downloads the WASI SDK).
   Cases run with the `typescript` grammar unless they carry `:language(tsx)`;
-- an incremental-parsing check (`test/unit/incremental.test.ts`): `tree-sitter fuzz` edits each corpus case of the
-  `typescript` grammar at random, reparses it, undoes the edits, and reparses again. `TREE_SITTER_SEED`,
-  `TREE_SITTER_ITERATIONS`, and `TREE_SITTER_EDITS` run other or more edits;
+- an incremental-parsing check (`test/unit/incremental.test.ts`): `script/fuzz-corpus` runs `tree-sitter fuzz`, which
+  edits each corpus case of each grammar at random, reparses it, undoes the edits, and reparses again, on the
+  WillBooster/tree-sitter runtime version locked in `Cargo.lock` (the first run builds that CLI with `cargo`).
+  `TREE_SITTER_SEED`, `TREE_SITTER_ITERATIONS`, and `TREE_SITTER_EDITS` run other or more edits;
 - a check that the real-world files in `examples/`, the checked-in ones and those of the cloned repositories, fail to
   parse exactly as listed in `script/known-failures.txt`. `.ts` files are parsed with the `typescript` grammar and
   `.tsx` files with the `tsx` grammar. The first run clones the repositories. The example repositories are pinned to

package/common/defineGrammar.js

@@ -13,6 +13,7 @@ module.exports = function defineGrammar(dialect) {
       ...previous,
       ['call', 'instantiation', 'unary', 'binary', $.await_expression, $.arrow_function],
       ['extends', 'instantiation'],
+      ['new', 'generic_call', 'instantiation', 'unary', 'binary'],
       [
         $.intersection_type,
         $.union_type,
@@ -58,10 +59,7 @@ module.exports = function defineGrammar(dialect) {
 
     conflicts: ($, previous) => [
       ...previous,
-      [$.call_expression, $.instantiation_expression, $.binary_expression],
-      [$.call_expression, $.instantiation_expression, $.binary_expression, $.unary_expression],
-      [$.call_expression, $.instantiation_expression, $.binary_expression, $.update_expression],
-      [$.call_expression, $.instantiation_expression, $.binary_expression, $.await_expression],
+      [$.expression, $.call_expression, $.instantiation_expression],
 
       // This appears to be necessary to parse a parenthesized class expression
       [$.class],
@@ -159,22 +157,20 @@ module.exports = function defineGrammar(dialect) {
 
       call_expression: ($) =>
         choice(
-          prec(
-            'call',
-            seq(
-              field('function', choice($.expression, $.import)),
-              field('type_arguments', optional($.type_arguments)),
-              field('arguments', $.arguments)
-            )
-          ),
-          // A tag with type arguments is parsed like a generic call. Optional type arguments in the `template_call`
-          // alternative below would make the parser commit to a tagged template at the `<` of `f<T>(x)`.
-          prec(
-            'call',
-            seq(
-              field('function', $.expression),
-              field('type_arguments', $.type_arguments),
-              field('arguments', $.template_string)
+          prec('call', seq(field('function', choice($.expression, $.import)), field('arguments', $.arguments))),
+          // Type arguments follow a primary expression, as in TypeScript: `a + b<T>(c)` calls `b`. Where comparisons
+          // could also read the input, as in `a < b > (c)`, TypeScript reads a generic call, hence the dynamic
+          // precedence. A tag with type arguments is parsed like a generic call. Optional type arguments in the
+          // `template_call` alternative below would make the parser commit to a tagged template at the `<` of `f<T>(x)`.
+          prec.dynamic(
+            1,
+            prec(
+              'generic_call',
+              seq(
+                field('function', choice($.primary_expression, $.new_expression)),
+                field('type_arguments', $.type_arguments),
+                field('arguments', choice($.arguments, $.template_string))
+              )
             )
           ),
           prec(
@@ -493,7 +489,13 @@ module.exports = function defineGrammar(dialect) {
       satisfies_expression: ($) => prec.left('binary', seq($.expression, 'satisfies', $.type)),
 
       instantiation_expression: ($) =>
-        prec('instantiation', seq($.expression, field('type_arguments', $.type_arguments))),
+        prec.dynamic(
+          -1,
+          prec(
+            'instantiation',
+            seq(choice($.primary_expression, $.new_expression), field('type_arguments', $.type_arguments))
+          )
+        ),
 
       class_heritage: ($) => choice(seq($.extends_clause, optional($.implements_clause)), $.implements_clause),
 
@@ -1047,8 +1049,10 @@ module.exports = function defineGrammar(dialect) {
       tuple_type: ($) => seq('[', commaSep($._tuple_type_member), optional(','), ']'),
       readonly_type: ($) => seq('readonly', $.type),
 
-      union_type: ($) => prec.left(seq(optional($.type), '|', $.type)),
-      intersection_type: ($) => prec.left(seq(optional($.type), '&', $.type)),
+      // TypeScript allows a leading `|` or `&` only at the start of a type, so `a < b || c > (d)` compares instead of
+      // calling `a` with `b | | c`. The negative dynamic precedence outweighs that of the generic call.
+      union_type: ($) => prec.left(choice(seq($.type, '|', $.type), prec.dynamic(-2, seq('|', $.type)))),
+      intersection_type: ($) => prec.left(choice(seq($.type, '&', $.type), prec.dynamic(-2, seq('&', $.type)))),
 
       function_type: ($) =>
         prec.left(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@willbooster/tree-sitter-typescript",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "TypeScript and TSX grammars for tree-sitter",
   "keywords": [
     "incremental",

package/tree-sitter.json

@@ -77,7 +77,7 @@
     }
   ],
   "metadata": {
-    "version": "1.2.0",
+    "version": "1.2.2",
     "license": "MIT",
     "description": "TypeScript and TSX grammars for tree-sitter",
     "authors": [

package/tsx/src/node-types.json

@@ -3103,7 +3103,11 @@
       "required": false,
       "types": [
         {
-          "type": "expression",
+          "type": "new_expression",
+          "named": true
+        },
+        {
+          "type": "primary_expression",
           "named": true
         }
       ]

package/typescript/src/node-types.json

@@ -3099,7 +3099,11 @@
       "required": false,
       "types": [
         {
-          "type": "expression",
+          "type": "new_expression",
+          "named": true
+        },
+        {
+          "type": "primary_expression",
           "named": true
         }
       ]