Update grammar to cover array spreads, variant type spreads and newer operators. (#267)

* feat: add ReScript 12 operator support

Add parser support for the ReScript 12 operator improvements that were
missing from the grammar.

This covers modulo, bitwise operators, and shift operators, and adds
corpus and highlight updates for the new syntax. Unrelated untracked
files are left out of the commit.

* feat: add variant spread syntax support

Add grammar support for variant type spreads and variant pattern
spreads.

This adds corpus coverage for type declarations and expressions,
including a dedicated variant pattern spread example.

Also ignore local uv lockfiles via .git/info/exclude.

* feat: add array spread expression support

Allow spread elements in array expressions.

Add corpus coverage for array spread syntax using the ReScript 11.1
style example, including multiple spreads in the same array literal.

* fix: make extensible type "= .." a dedicated node

The ".." token for extensible variants (e.g. `type t = ..`) was
included as a choice in the `_type_identifier` rule alongside
`type_identifier` and `type_identifier_path`.  Because
`_type_identifier` is inlined, the tokenizer would see the three-dot
spread operator "..." and greedily match ".." first, leaving a stray
"." behind.  This made every variant type spread (`| ...Foo.t`)
produce an ERROR node, breaking font-lock for the rest of the file.

Extensible variants are syntactically distinct: `type t = ..` is the
only valid use of ".." in a type position — it cannot appear inside
generics (`option<..>` is invalid) or be combined with other type
constructors.  Modelling it as a separate `extensible_type` node
branching directly from `type_binding` reflects this and removes the
ambiguity from the tokenizer entirely.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: avoid highlighting extension prefixes as operators

Remove '%' from the unconditional operator query so leading percent signs in
extension expressions like %foo and %%foo are not highlighted as operators.

Highlight '%' only in binary_expression, matching how other context-sensitive
operators such as '<', '>', and '/' are handled.

* chore: align tree-sitter CLI version in package and CI

Pin the GitHub Actions tree-sitter CLI to v0.26.3 so parser generation
matches the version declared in the package metadata, and regenerate
src/parser.c with that version.

Keep the runtime tree-sitter peer dependency at ^0.21.1. The CLI and the
runtime are versioned separately, so the CI toolchain update should not raise
the consumer runtime requirement.

Include package.json, package-lock.json, and .nvmrc in the CI path filters so
toolchain-only changes still trigger the workflow.

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: mvaled

.github/workflows/ci.yml

@@ -8,6 +8,9 @@ on:
       - test/**
       - bindings/**
       - binding.gyp
+      - package.json
+      - package-lock.json
+      - .nvmrc
       - .github/workflows/**
   pull_request:
     paths:
@@ -16,6 +19,9 @@ on:
       - test/**
       - bindings/**
       - binding.gyp
+      - package.json
+      - package-lock.json
+      - .nvmrc
       - .github/workflows/**
 
 concurrency:
@@ -36,6 +42,8 @@ jobs:
 
       - name: Set up tree-sitter
         uses: tree-sitter/setup-action/cli@v2
+        with:
+          tree-sitter-ref: v0.26.3
 
       - name: Run tests
         uses: tree-sitter/parser-test-action@v2

grammar.js

@@ -45,8 +45,12 @@ module.exports = grammar({
       "binary_times",
       "binary_pow",
       "binary_plus",
+      "binary_shift",
       "binary_compare",
       "binary_relation",
+      "binary_bitand",
+      "binary_bitxor",
+      "binary_bitor",
       "binary_and",
       "binary_or",
       "coercion_relation",
@@ -250,20 +254,25 @@ module.exports = grammar({
         field("name", choice($.type_identifier, $.type_identifier_path)),
         optional($.type_parameters),
         optional(
-          seq(
-            optional(seq("=", $._non_function_inline_type)),
-            optional(
-              seq(
-                choice("=", "+="),
-                optional("private"),
-                field("body", $._type),
+          choice(
+            seq("=", $.extensible_type),
+            seq(
+              optional(seq("=", $._non_function_inline_type)),
+              optional(
+                seq(
+                  choice("=", "+="),
+                  optional("private"),
+                  field("body", $._type),
+                ),
               ),
+              repeat($.type_constraint),
             ),
-            repeat($.type_constraint),
           ),
         ),
       ),
 
+    extensible_type: (_$) => "..",
+
     type_parameters: ($) =>
       seq(
         "<",
@@ -305,7 +314,9 @@ module.exports = grammar({
     tuple_type: ($) => prec.dynamic(-1, seq("(", commaSep1t($._type), ")")),
 
     variant_type: ($) =>
-      prec.left(seq(optional("|"), barSep1($.variant_declaration))),
+      prec.left(
+        seq(optional("|"), barSep1(choice($.variant_declaration, $.variant_type_spread))),
+      ),
 
     variant_declaration: ($) =>
       prec.right(
@@ -316,6 +327,8 @@ module.exports = grammar({
         ),
       ),
 
+    variant_type_spread: ($) => seq("...", $._type_identifier),
+
     variant_parameters: ($) => seq("(", commaSep1t($._type), ")"),
 
     polyvar_type: ($) =>
@@ -538,7 +551,7 @@ module.exports = grammar({
 
     tuple: ($) => seq("(", commaSep2t($.expression), ")"),
 
-    array: ($) => seq("[", commaSept($.expression), "]"),
+    array: ($) => seq("[", commaSept(choice($.spread_element, $.expression)), "]"),
 
     list: ($) =>
       seq($._list_constructor, "{", optional(commaSep1t($._list_element)), "}"),
@@ -576,7 +589,7 @@ module.exports = grammar({
         -1,
         seq(
           "|",
-          field("pattern", $._pattern),
+          field("pattern", choice($.variant_spread_pattern, $._pattern)),
           optional($.guard),
           "=>",
           field(
@@ -590,6 +603,11 @@ module.exports = grammar({
 
     polyvar_type_pattern: ($) => seq("#", "...", $._type_identifier),
 
+    variant_type_pattern: ($) => seq("...", $._type_identifier),
+
+    variant_spread_pattern: ($) =>
+      seq($.variant_type_pattern, optional($.as_aliasing)),
+
     try_expression: ($) =>
       seq("try", $.expression, "catch", "{", repeat($.switch_match), "}"),
 
@@ -985,18 +1003,25 @@ module.exports = grammar({
     binary_expression: ($) =>
       choice(
         ...[
+          ["&&&", "binary_bitand"],
           ["&&", "binary_and"],
+          ["|||", "binary_bitor"],
           ["||", "binary_or"],
+          ["^^^", "binary_bitxor"],
           ["++", "binary_plus"],
           ["+", "binary_plus"],
           ["+.", "binary_plus"],
           ["-", "binary_plus"],
           ["-.", "binary_plus"],
           ["*", "binary_times"],
           ["*.", "binary_times"],
+          ["%", "binary_times"],
           ["**", "binary_pow"],
           ["/", "binary_times"],
           ["/.", "binary_times"],
+          ["<<", "binary_shift"],
+          [">>>", "binary_shift"],
+          [">>", "binary_shift"],
           ["<", "binary_relation"],
           ["<=", "binary_relation"],
           ["==", "binary_relation"],
@@ -1030,6 +1055,7 @@ module.exports = grammar({
     unary_expression: ($) =>
       choice(
         ...[
+          ["~~~", "unary_not"],
           ["!", "unary_not"],
           ["-", "unary_not"],
           ["-.", "unary_not"],
@@ -1085,7 +1111,7 @@ module.exports = grammar({
       ),
 
     _type_identifier: ($) =>
-      choice($.type_identifier, $.type_identifier_path, ".."),
+      choice($.type_identifier, $.type_identifier_path),
 
     type_identifier_path: ($) =>
       seq($.module_primary_expression, ".", $.type_identifier),

queries/highlights.scm

@@ -225,15 +225,22 @@
   "**"
   "*."
   "/."
+  "<<"
+  ">>"
+  ">>>"
   "<="
   "=="
   "==="
   "!"
   "!="
   "!=="
   ">="
+  "&&&"
   "&&"
+  "|||"
   "||"
+  "^^^"
+  "~~~"
   "="
   ":="
   "->"
@@ -245,8 +252,8 @@
 ] @operator
 
 ; Explicitly enclose these operators with binary_expression
-; to avoid confusion with JSX tag delimiters
-(binary_expression ["<" ">" "/"] @operator)
+; to avoid confusion with JSX tag delimiters and extension expressions.
+(binary_expression ["<" ">" "/" "%"] @operator)
 
 [
   "("