@konomanoasa/tree-sitter-query 0.3.0 → 0.3.1

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "konomanoasa-tree-sitter-query"
-version = "0.3.0"
+version = "0.3.1"
 edition = "2024"
 description = "Tree-sitter grammar for Tree-sitter Query."
 readme = "README.md"

package/README.md

@@ -29,6 +29,10 @@ npm test
 - [Tree-sitter query operators](https://tree-sitter.github.io/tree-sitter/using-parsers/queries/2-operators.html)
 - [Tree-sitter query predicates and directives](https://tree-sitter.github.io/tree-sitter/using-parsers/queries/3-predicates-and-directives.html)
 
+## Used By
+
+[query-ts-mode](https://github.com/konomanoasa/query-ts-mode): Emacs major mode.
+
 ## License
 
 [MIT](LICENSE)

package/grammar.js

@@ -1,5 +1,5 @@
 const namePattern = /[A-Za-z0-9_-][A-Za-z0-9_.-]*/;
-const stringContent = /[^"\\\n]+/;
+const fieldNamePattern = /[A-Za-z0-9-][A-Za-z0-9_.-]*/;
 
 const postfixed = ($, body) =>
   seq(
@@ -37,6 +37,9 @@ const subtyped = ($, supertype) =>
     ),
   );
 
+const callOnlyGroupMembers = ($) =>
+  seq($._call_only_group_start, repeat(anchored($, $._call_only_member)));
+
 const call = ($, marker) =>
   seq(
     "(",
@@ -53,7 +56,7 @@ export default grammar({
   rules: {
     query: ($) => optional($._members),
     _members: ($) => seq($._member, optional($._members)),
-    _member: ($) => choice($._child_pattern, $._call),
+    _member: ($) => choice($._matching_child_pattern, $._call_only_member),
     _call: ($) => choice($.predicate, $.directive),
     _call_only_member: ($) => choice($._call_only_child_pattern, $._call),
 
@@ -67,8 +70,6 @@ export default grammar({
         ),
       ),
     _delimited: ($) => choice($.node_pattern, $.group, $.alternation),
-    _child_pattern: ($) =>
-      choice($._matching_child_pattern, $._call_only_child_pattern),
     _matching_child_pattern: ($) => choice($.pattern, $.field_constraint),
     _call_only_child_pattern: ($) =>
       choice(
@@ -86,13 +87,13 @@ export default grammar({
               "node",
               choice($.identifier, $.wildcard, $.supertype, $.missing_node),
             ),
-            repeat($._node_annotation),
+            repeat($._non_matching_child),
             optional(
               seq(
                 anchored($, $._matching_child_pattern),
                 repeat(
                   choice(
-                    $._node_annotation,
+                    $._non_matching_child,
                     anchored($, $._matching_child_pattern),
                   ),
                 ),
@@ -103,7 +104,7 @@ export default grammar({
         ),
         ")",
       ),
-    _node_annotation: ($) =>
+    _non_matching_child: ($) =>
       choice(anchored($, $._call_only_member), $.negated_field),
 
     field_constraint: ($) => fieldConstraint($, $._matching_child_pattern),
@@ -128,24 +129,14 @@ export default grammar({
       seq(
         "(",
         choice(
-          alias($._group_pattern, $.pattern),
-          seq(
-            $._call_only_group_start,
-            repeat(anchored($, $._call_only_member)),
-            anchored($, $._matching_child_pattern),
-          ),
+          alias($._group_start_pattern, $.pattern),
+          seq(callOnlyGroupMembers($), anchored($, $._matching_child_pattern)),
         ),
         repeat(anchored($, $._member)),
         ")",
       ),
-    _group_pattern: ($) => postfixed($, choice($._delimited, $.string)),
-    _call_only_group: ($) =>
-      seq(
-        "(",
-        $._call_only_group_start,
-        repeat(anchored($, $._call_only_member)),
-        ")",
-      ),
+    _group_start_pattern: ($) => postfixed($, choice($._delimited, $.string)),
+    _call_only_group: ($) => seq("(", callOnlyGroupMembers($), ")"),
     _call_only_group_start: ($) =>
       choice($._call, alias($._call_only_pattern, $.pattern)),
 
@@ -169,7 +160,7 @@ export default grammar({
     directive: ($) => call($, "!"),
 
     identifier: () => namePattern,
-    _field_identifier: () => /[A-Za-z0-9-][A-Za-z0-9_.-]*/,
+    _field_identifier: () => fieldNamePattern,
     _immediate_identifier: () => token.immediate(namePattern),
     _name: ($) =>
       choice(
@@ -187,15 +178,11 @@ export default grammar({
       ),
     _string_line_break: () => token.immediate(/\n/),
     _unmatchable: () => token(seq("\\", /[^\s\S]/)),
-    string_content: () =>
-      token.immediate(
-        prec(
-          1,
-          repeat1(choice(stringContent, seq("\0", optional(stringContent)))),
-        ),
-      ),
     // Keep NUL distinct from EOF in the generated lexer.
-    escape_sequence: () => token.immediate(choice(/\\(.|\n)/, prec(1, "\\\0"))),
+    string_content: () =>
+      token.immediate(prec(1, repeat1(choice(/[^"\\\n]+/, "\0")))),
+    escape_sequence: () =>
+      token.immediate(seq("\\", choice(/.|\n/, prec(1, "\0")))),
 
     comment: () => /;[^\r\n]*(\r+[^\r\n]+)*/,
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@konomanoasa/tree-sitter-query",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "type": "module",
   "description": "Tree-sitter grammar for Tree-sitter Query.",
   "license": "MIT",
@@ -29,7 +29,7 @@
     "test:fuzz": "node --test --test-name-pattern=\"fixed-seed generated histories\" test/incremental.test.js",
     "test:fuzz:corpus": "npm run tree-sitter -- fuzz-all --iterations 100 --edits 5",
     "test:highlights": "node --test test/highlight.test.js",
-    "test:incremental": "node --test test/incremental.test.js",
+    "test:incremental": "node --test --test-concurrency=1 test/cst.test.js test/parser.test.js test/incremental.test.js",
     "tree-sitter": "node scripts/tree-sitter.js"
   },
   "devDependencies": {

package/src/grammar.json

@@ -40,11 +40,11 @@
       "members": [
         {
           "type": "SYMBOL",
-          "name": "_child_pattern"
+          "name": "_matching_child_pattern"
         },
         {
           "type": "SYMBOL",
-          "name": "_call"
+          "name": "_call_only_member"
         }
       ]
     },
@@ -197,19 +197,6 @@
         }
       ]
     },
-    "_child_pattern": {
-      "type": "CHOICE",
-      "members": [
-        {
-          "type": "SYMBOL",
-          "name": "_matching_child_pattern"
-        },
-        {
-          "type": "SYMBOL",
-          "name": "_call_only_child_pattern"
-        }
-      ]
-    },
     "_matching_child_pattern": {
       "type": "CHOICE",
       "members": [
@@ -301,7 +288,7 @@
                   "type": "REPEAT",
                   "content": {
                     "type": "SYMBOL",
-                    "name": "_node_annotation"
+                    "name": "_non_matching_child"
                   }
                 },
                 {
@@ -338,7 +325,7 @@
                             "members": [
                               {
                                 "type": "SYMBOL",
-                                "name": "_node_annotation"
+                                "name": "_non_matching_child"
                               },
                               {
                                 "type": "SEQ",
@@ -393,7 +380,7 @@
         }
       ]
     },
-    "_node_annotation": {
+    "_non_matching_child": {
       "type": "CHOICE",
       "members": [
         {
@@ -689,7 +676,7 @@
               "type": "ALIAS",
               "content": {
                 "type": "SYMBOL",
-                "name": "_group_pattern"
+                "name": "_group_start_pattern"
               },
               "named": true,
               "value": "pattern"
@@ -698,32 +685,37 @@
               "type": "SEQ",
               "members": [
                 {
-                  "type": "SYMBOL",
-                  "name": "_call_only_group_start"
-                },
-                {
-                  "type": "REPEAT",
-                  "content": {
-                    "type": "SEQ",
-                    "members": [
-                      {
-                        "type": "CHOICE",
+                  "type": "SEQ",
+                  "members": [
+                    {
+                      "type": "SYMBOL",
+                      "name": "_call_only_group_start"
+                    },
+                    {
+                      "type": "REPEAT",
+                      "content": {
+                        "type": "SEQ",
                         "members": [
                           {
-                            "type": "SYMBOL",
-                            "name": "anchor"
+                            "type": "CHOICE",
+                            "members": [
+                              {
+                                "type": "SYMBOL",
+                                "name": "anchor"
+                              },
+                              {
+                                "type": "BLANK"
+                              }
+                            ]
                           },
                           {
-                            "type": "BLANK"
+                            "type": "SYMBOL",
+                            "name": "_call_only_member"
                           }
                         ]
-                      },
-                      {
-                        "type": "SYMBOL",
-                        "name": "_call_only_member"
                       }
-                    ]
-                  }
+                    }
+                  ]
                 },
                 {
                   "type": "SEQ",
@@ -780,7 +772,7 @@
         }
       ]
     },
-    "_group_pattern": {
+    "_group_start_pattern": {
       "type": "SEQ",
       "members": [
         {
@@ -834,32 +826,37 @@
           "value": "("
         },
         {
-          "type": "SYMBOL",
-          "name": "_call_only_group_start"
-        },
-        {
-          "type": "REPEAT",
-          "content": {
-            "type": "SEQ",
-            "members": [
-              {
-                "type": "CHOICE",
+          "type": "SEQ",
+          "members": [
+            {
+              "type": "SYMBOL",
+              "name": "_call_only_group_start"
+            },
+            {
+              "type": "REPEAT",
+              "content": {
+                "type": "SEQ",
                 "members": [
                   {
-                    "type": "SYMBOL",
-                    "name": "anchor"
+                    "type": "CHOICE",
+                    "members": [
+                      {
+                        "type": "SYMBOL",
+                        "name": "anchor"
+                      },
+                      {
+                        "type": "BLANK"
+                      }
+                    ]
                   },
                   {
-                    "type": "BLANK"
+                    "type": "SYMBOL",
+                    "name": "_call_only_member"
                   }
                 ]
-              },
-              {
-                "type": "SYMBOL",
-                "name": "_call_only_member"
               }
-            ]
-          }
+            }
+          ]
         },
         {
           "type": "STRING",
@@ -1263,25 +1260,8 @@
                 "value": "[^\"\\\\\\n]+"
               },
               {
-                "type": "SEQ",
-                "members": [
-                  {
-                    "type": "STRING",
-                    "value": "\u0000"
-                  },
-                  {
-                    "type": "CHOICE",
-                    "members": [
-                      {
-                        "type": "PATTERN",
-                        "value": "[^\"\\\\\\n]+"
-                      },
-                      {
-                        "type": "BLANK"
-                      }
-                    ]
-                  }
-                ]
+                "type": "STRING",
+                "value": "\u0000"
               }
             ]
           }
@@ -1291,19 +1271,28 @@
     "escape_sequence": {
       "type": "IMMEDIATE_TOKEN",
       "content": {
-        "type": "CHOICE",
+        "type": "SEQ",
         "members": [
           {
-            "type": "PATTERN",
-            "value": "\\\\(.|\\n)"
+            "type": "STRING",
+            "value": "\\"
           },
           {
-            "type": "PREC",
-            "value": 1,
-            "content": {
-              "type": "STRING",
-              "value": "\\\u0000"
-            }
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "PATTERN",
+                "value": ".|\\n"
+              },
+              {
+                "type": "PREC",
+                "value": 1,
+                "content": {
+                  "type": "STRING",
+                  "value": "\u0000"
+                }
+              }
+            ]
           }
         ]
       }

package/src/parser.c

@@ -9,7 +9,7 @@
 #define LANGUAGE_VERSION 15
 #define STATE_COUNT 146
 #define LARGE_STATE_COUNT 2
-#define SYMBOL_COUNT 68
+#define SYMBOL_COUNT 67
 #define ALIAS_COUNT 0
 #define TOKEN_COUNT 26
 #define EXTERNAL_TOKEN_COUNT 0
@@ -53,40 +53,39 @@ enum ts_symbol_identifiers {
   sym_pattern = 31,
   sym__call_only_pattern = 32,
   sym__delimited = 33,
-  sym__child_pattern = 34,
-  sym__matching_child_pattern = 35,
-  sym__call_only_child_pattern = 36,
-  sym_node_pattern = 37,
-  sym__node_annotation = 38,
-  sym_field_constraint = 39,
-  sym__call_only_field_constraint = 40,
-  sym_negated_field = 41,
-  sym_supertype = 42,
-  sym__untyped_missing_node = 43,
-  sym_missing_node = 44,
-  sym__missing_supertype = 45,
-  sym_group = 46,
-  sym__group_pattern = 47,
-  sym__call_only_group = 48,
-  sym__call_only_group_start = 49,
-  sym_alternation = 50,
-  sym__call_only_alternation = 51,
-  sym_capture = 52,
-  sym_predicate = 53,
-  sym_directive = 54,
-  sym__name = 55,
-  sym_string = 56,
-  sym__immediate_string = 57,
-  sym__string_tail = 58,
-  aux_sym_pattern_repeat1 = 59,
-  aux_sym_node_pattern_repeat1 = 60,
-  aux_sym_node_pattern_repeat2 = 61,
-  aux_sym_group_repeat1 = 62,
-  aux_sym_group_repeat2 = 63,
-  aux_sym_alternation_repeat1 = 64,
-  aux_sym_alternation_repeat2 = 65,
-  aux_sym_predicate_repeat1 = 66,
-  aux_sym__string_tail_repeat1 = 67,
+  sym__matching_child_pattern = 34,
+  sym__call_only_child_pattern = 35,
+  sym_node_pattern = 36,
+  sym__non_matching_child = 37,
+  sym_field_constraint = 38,
+  sym__call_only_field_constraint = 39,
+  sym_negated_field = 40,
+  sym_supertype = 41,
+  sym__untyped_missing_node = 42,
+  sym_missing_node = 43,
+  sym__missing_supertype = 44,
+  sym_group = 45,
+  sym__group_start_pattern = 46,
+  sym__call_only_group = 47,
+  sym__call_only_group_start = 48,
+  sym_alternation = 49,
+  sym__call_only_alternation = 50,
+  sym_capture = 51,
+  sym_predicate = 52,
+  sym_directive = 53,
+  sym__name = 54,
+  sym_string = 55,
+  sym__immediate_string = 56,
+  sym__string_tail = 57,
+  aux_sym_pattern_repeat1 = 58,
+  aux_sym_node_pattern_repeat1 = 59,
+  aux_sym_node_pattern_repeat2 = 60,
+  aux_sym_group_repeat1 = 61,
+  aux_sym_group_repeat2 = 62,
+  aux_sym_alternation_repeat1 = 63,
+  aux_sym_alternation_repeat2 = 64,
+  aux_sym_predicate_repeat1 = 65,
+  aux_sym__string_tail_repeat1 = 66,
 };
 
 static const char * const ts_symbol_names[] = {
@@ -124,11 +123,10 @@ static const char * const ts_symbol_names[] = {
   [sym_pattern] = "pattern",
   [sym__call_only_pattern] = "pattern",
   [sym__delimited] = "_delimited",
-  [sym__child_pattern] = "_child_pattern",
   [sym__matching_child_pattern] = "_matching_child_pattern",
   [sym__call_only_child_pattern] = "_call_only_child_pattern",
   [sym_node_pattern] = "node_pattern",
-  [sym__node_annotation] = "_node_annotation",
+  [sym__non_matching_child] = "_non_matching_child",
   [sym_field_constraint] = "field_constraint",
   [sym__call_only_field_constraint] = "field_constraint",
   [sym_negated_field] = "negated_field",
@@ -137,7 +135,7 @@ static const char * const ts_symbol_names[] = {
   [sym_missing_node] = "missing_node",
   [sym__missing_supertype] = "supertype",
   [sym_group] = "group",
-  [sym__group_pattern] = "pattern",
+  [sym__group_start_pattern] = "pattern",
   [sym__call_only_group] = "group",
   [sym__call_only_group_start] = "_call_only_group_start",
   [sym_alternation] = "alternation",
@@ -195,11 +193,10 @@ static const TSSymbol ts_symbol_map[] = {
   [sym_pattern] = sym_pattern,
   [sym__call_only_pattern] = sym_pattern,
   [sym__delimited] = sym__delimited,
-  [sym__child_pattern] = sym__child_pattern,
   [sym__matching_child_pattern] = sym__matching_child_pattern,
   [sym__call_only_child_pattern] = sym__call_only_child_pattern,
   [sym_node_pattern] = sym_node_pattern,
-  [sym__node_annotation] = sym__node_annotation,
+  [sym__non_matching_child] = sym__non_matching_child,
   [sym_field_constraint] = sym_field_constraint,
   [sym__call_only_field_constraint] = sym_field_constraint,
   [sym_negated_field] = sym_negated_field,
@@ -208,7 +205,7 @@ static const TSSymbol ts_symbol_map[] = {
   [sym_missing_node] = sym_missing_node,
   [sym__missing_supertype] = sym_supertype,
   [sym_group] = sym_group,
-  [sym__group_pattern] = sym_pattern,
+  [sym__group_start_pattern] = sym_pattern,
   [sym__call_only_group] = sym_group,
   [sym__call_only_group_start] = sym__call_only_group_start,
   [sym_alternation] = sym_alternation,
@@ -368,10 +365,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
     .visible = false,
     .named = true,
   },
-  [sym__child_pattern] = {
-    .visible = false,
-    .named = true,
-  },
   [sym__matching_child_pattern] = {
     .visible = false,
     .named = true,
@@ -384,7 +377,7 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
     .visible = true,
     .named = true,
   },
-  [sym__node_annotation] = {
+  [sym__non_matching_child] = {
     .visible = false,
     .named = true,
   },
@@ -420,7 +413,7 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
     .visible = true,
     .named = true,
   },
-  [sym__group_pattern] = {
+  [sym__group_start_pattern] = {
     .visible = true,
     .named = true,
   },
@@ -1414,10 +1407,10 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [sym__members] = STATE(140),
     [sym__member] = STATE(26),
     [sym__call] = STATE(26),
+    [sym__call_only_member] = STATE(26),
     [sym_pattern] = STATE(26),
     [sym__call_only_pattern] = STATE(89),
     [sym__delimited] = STATE(55),
-    [sym__child_pattern] = STATE(26),
     [sym__matching_child_pattern] = STATE(26),
     [sym__call_only_child_pattern] = STATE(26),
     [sym_node_pattern] = STATE(55),
@@ -1485,7 +1478,7 @@ static const uint16_t ts_small_parse_table[] = {
       sym__call,
       sym__call_only_member,
       sym__call_only_child_pattern,
-      sym__node_annotation,
+      sym__non_matching_child,
       sym_negated_field,
       sym_predicate,
       sym_directive,
@@ -1533,7 +1526,7 @@ static const uint16_t ts_small_parse_table[] = {
       sym__call,
       sym__call_only_member,
       sym__call_only_child_pattern,
-      sym__node_annotation,
+      sym__non_matching_child,
       sym_negated_field,
       sym_predicate,
       sym_directive,
@@ -1579,7 +1572,7 @@ static const uint16_t ts_small_parse_table[] = {
       sym__call,
       sym__call_only_member,
       sym__call_only_child_pattern,
-      sym__node_annotation,
+      sym__non_matching_child,
       sym_negated_field,
       sym_predicate,
       sym_directive,
@@ -1625,7 +1618,7 @@ static const uint16_t ts_small_parse_table[] = {
       sym__call,
       sym__call_only_member,
       sym__call_only_child_pattern,
-      sym__node_annotation,
+      sym__non_matching_child,
       sym_negated_field,
       sym_predicate,
       sym_directive,
@@ -1669,7 +1662,7 @@ static const uint16_t ts_small_parse_table[] = {
       sym_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
-      sym__node_annotation,
+      sym__non_matching_child,
       sym_field_constraint,
       sym_negated_field,
       sym_predicate,
@@ -1714,7 +1707,7 @@ static const uint16_t ts_small_parse_table[] = {
       sym_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
-      sym__node_annotation,
+      sym__non_matching_child,
       sym_field_constraint,
       sym_negated_field,
       sym_predicate,
@@ -1759,7 +1752,7 @@ static const uint16_t ts_small_parse_table[] = {
       sym_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
-      sym__node_annotation,
+      sym__non_matching_child,
       sym_field_constraint,
       sym_negated_field,
       sym_predicate,
@@ -1804,7 +1797,7 @@ static const uint16_t ts_small_parse_table[] = {
       sym_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
-      sym__node_annotation,
+      sym__non_matching_child,
       sym_field_constraint,
       sym_negated_field,
       sym_predicate,
@@ -1849,7 +1842,7 @@ static const uint16_t ts_small_parse_table[] = {
       sym_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
-      sym__node_annotation,
+      sym__non_matching_child,
       sym_field_constraint,
       sym_negated_field,
       sym_predicate,
@@ -1894,7 +1887,7 @@ static const uint16_t ts_small_parse_table[] = {
       sym_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
-      sym__node_annotation,
+      sym__non_matching_child,
       sym_field_constraint,
       sym_negated_field,
       sym_predicate,
@@ -1939,7 +1932,7 @@ static const uint16_t ts_small_parse_table[] = {
       sym_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
-      sym__node_annotation,
+      sym__non_matching_child,
       sym_field_constraint,
       sym_negated_field,
       sym_predicate,
@@ -1979,8 +1972,8 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(15), 10,
       sym__member,
       sym__call,
+      sym__call_only_member,
       sym_pattern,
-      sym__child_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
       sym_field_constraint,
@@ -2021,8 +2014,8 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(21), 10,
       sym__member,
       sym__call,
+      sym__call_only_member,
       sym_pattern,
-      sym__child_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
       sym_field_constraint,
@@ -2063,8 +2056,8 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(21), 10,
       sym__member,
       sym__call,
+      sym__call_only_member,
       sym_pattern,
-      sym__child_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
       sym_field_constraint,
@@ -2105,8 +2098,8 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(18), 10,
       sym__member,
       sym__call,
+      sym__call_only_member,
       sym_pattern,
-      sym__child_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
       sym_field_constraint,
@@ -2147,8 +2140,8 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(19), 10,
       sym__member,
       sym__call,
+      sym__call_only_member,
       sym_pattern,
-      sym__child_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
       sym_field_constraint,
@@ -2189,8 +2182,8 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(21), 10,
       sym__member,
       sym__call,
+      sym__call_only_member,
       sym_pattern,
-      sym__child_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
       sym_field_constraint,
@@ -2231,8 +2224,8 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(21), 10,
       sym__member,
       sym__call,
+      sym__call_only_member,
       sym_pattern,
-      sym__child_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
       sym_field_constraint,
@@ -2273,8 +2266,8 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(14), 10,
       sym__member,
       sym__call,
+      sym__call_only_member,
       sym_pattern,
-      sym__child_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
       sym_field_constraint,
@@ -2315,8 +2308,8 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(21), 10,
       sym__member,
       sym__call,
+      sym__call_only_member,
       sym_pattern,
-      sym__child_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
       sym_field_constraint,
@@ -2355,8 +2348,8 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(24), 10,
       sym__member,
       sym__call,
+      sym__call_only_member,
       sym_pattern,
-      sym__child_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
       sym_field_constraint,
@@ -2395,8 +2388,8 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(22), 10,
       sym__member,
       sym__call,
+      sym__call_only_member,
       sym_pattern,
-      sym__child_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
       sym_field_constraint,
@@ -2435,8 +2428,8 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(24), 10,
       sym__member,
       sym__call,
+      sym__call_only_member,
       sym_pattern,
-      sym__child_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
       sym_field_constraint,
@@ -2475,8 +2468,8 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(24), 10,
       sym__member,
       sym__call,
+      sym__call_only_member,
       sym_pattern,
-      sym__child_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
       sym_field_constraint,
@@ -2517,8 +2510,8 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(26), 9,
       sym__member,
       sym__call,
+      sym__call_only_member,
       sym_pattern,
-      sym__child_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
       sym_field_constraint,
@@ -2598,8 +2591,8 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(25), 10,
       sym__member,
       sym__call,
+      sym__call_only_member,
       sym_pattern,
-      sym__child_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
       sym_field_constraint,
@@ -2874,8 +2867,8 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(115), 9,
       sym__member,
       sym__call,
+      sym__call_only_member,
       sym_pattern,
-      sym__child_pattern,
       sym__matching_child_pattern,
       sym__call_only_child_pattern,
       sym_field_constraint,
@@ -3085,7 +3078,7 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(145), 1,
       sym_identifier,
     STATE(13), 1,
-      sym__group_pattern,
+      sym__group_start_pattern,
     STATE(112), 1,
       sym__call_only_pattern,
     STATE(142), 1,
@@ -3160,7 +3153,7 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(145), 1,
       sym_identifier,
     STATE(13), 1,
-      sym__group_pattern,
+      sym__group_start_pattern,
     STATE(112), 1,
       sym__call_only_pattern,
     STATE(142), 1,
@@ -3211,7 +3204,7 @@ static const uint16_t ts_small_parse_table[] = {
       sym__call,
       sym__call_only_member,
       sym__call_only_child_pattern,
-      sym__node_annotation,
+      sym__non_matching_child,
       sym_negated_field,
       sym_predicate,
       sym_directive,
@@ -5099,10 +5092,10 @@ static const TSParseActionEntry ts_parse_actions[] = {
   [319] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_node_pattern, 8, 0, 10),
   [321] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 1, 0, 5),
   [323] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_pattern_repeat1, 1, 0, 5),
-  [325] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__group_pattern, 2, 0, 6),
-  [327] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__group_pattern, 2, 0, 6),
-  [329] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__group_pattern, 1, 0, 1),
-  [331] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__group_pattern, 1, 0, 1),
+  [325] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__group_start_pattern, 2, 0, 6),
+  [327] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__group_start_pattern, 2, 0, 6),
+  [329] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__group_start_pattern, 1, 0, 1),
+  [331] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__group_start_pattern, 1, 0, 1),
   [333] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_directive, 6, 0, 19),
   [335] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_directive, 6, 0, 19),
   [337] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_predicate, 6, 0, 19),
@@ -5146,8 +5139,8 @@ static const TSParseActionEntry ts_parse_actions[] = {
   [417] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_negated_field, 2, 0, 13),
   [419] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_supertype, 3, 0, 15),
   [421] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_supertype, 3, 0, 15),
-  [423] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__node_annotation, 2, 0, 0),
-  [425] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__node_annotation, 2, 0, 0),
+  [423] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__non_matching_child, 2, 0, 0),
+  [425] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__non_matching_child, 2, 0, 0),
   [427] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110),
   [429] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_supertype, 3, 0, 16),
   [431] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_supertype, 3, 0, 16),
@@ -5240,7 +5233,7 @@ TS_PUBLIC const TSLanguage *tree_sitter_query(void) {
     .metadata = {
       .major_version = 0,
       .minor_version = 3,
-      .patch_version = 0,
+      .patch_version = 1,
     },
   };
   return &language;

package/test/bindings.test.rs

@@ -25,22 +25,12 @@ fn parses_valid_source() {
 }
 
 #[test]
-fn preserves_comment_text() {
-  let mut parser = parser();
-  let source = "; query\n";
-  let tree = parser.parse(source, None).unwrap();
-  let root = tree.root_node();
-  assert!(!root.has_error());
-  assert_eq!(root.kind(), "query");
-  assert_eq!(root.to_sexp(), "(query (comment))");
-  assert_eq!(root.named_child(0).unwrap().byte_range(), 0..7);
-}
-
-#[test]
-fn missing_node_forms_follow_public_query_api_syntax() {
+fn node_designators_follow_public_query_api_syntax() {
   let language = grammar::LANGUAGE.into();
   let mut parser = parser();
   for (source, valid) in [
+    ("(_ @x)", false),
+    ("(_+ _)", false),
     ("(MISSING)", true),
     ("(MISSING ; comment\n)", true),
     ("(MISSING identifier)", true),
@@ -68,6 +58,72 @@ fn missing_node_forms_follow_public_query_api_syntax() {
   }
 }
 
+#[test]
+fn call_placement_and_arguments_follow_public_query_api_syntax() {
+  let language = grammar::LANGUAGE.into();
+  let mut parser = parser();
+  for (source, valid) in [
+    ("(#custom?)", true),
+    ("[(#custom?)]", true),
+    ("((#custom?))", true),
+    ("(node_pattern (#custom?))", true),
+    ("(#custom? 42 -1 0.5 _ MISSING)", true),
+    ("(#_call? _arg)", true),
+    ("(_) @_cap (#_call? _arg @_cap)", true),
+    ("(#custom)", false),
+    ("(#custom?) @capture", false),
+    ("(#custom!)?", false),
+    ("(# custom?)", false),
+    ("(#custom ?)", false),
+    ("(identifier) @ name", false),
+  ] {
+    match Query::new(&language, source) {
+      Ok(_) => assert!(valid, "{source:?}"),
+      Err(error) => {
+        assert!(!valid, "{source:?}: {error:?}");
+        assert_eq!(error.kind, QueryErrorKind::Syntax, "{source:?}");
+      }
+    }
+    assert_eq!(
+      parser.parse(source, None).unwrap().root_node().has_error(),
+      !valid,
+      "{source:?}"
+    );
+  }
+}
+
+#[test]
+fn documented_call_prefix_overrides_the_public_query_api_extension() {
+  let language = grammar::LANGUAGE.into();
+  let mut parser = parser();
+  for (source, valid) in [
+    ("(#custom?)", true),
+    ("(#custom! key value)", true),
+    ("(.custom?)", false),
+    ("(.custom! key value)", false),
+  ] {
+    assert!(Query::new(&language, source).is_ok(), "{source:?}");
+    assert_eq!(
+      parser.parse(source, None).unwrap().root_node().has_error(),
+      !valid,
+      "{source:?}"
+    );
+  }
+}
+
+#[test]
+fn postfix_order_and_repetition_follow_public_query_api_syntax() {
+  let language = grammar::LANGUAGE.into();
+  let mut parser = parser();
+  for source in ["(identifier) @x? @y+", "(identifier) +*?"] {
+    let query = Query::new(&language, source).unwrap();
+    assert_eq!(query.pattern_count(), 1, "{source:?}");
+    let tree = parser.parse(source, None).unwrap();
+    assert!(!tree.root_node().has_error(), "{source:?}");
+    assert_eq!(tree.root_node().named_child_count(), 1, "{source:?}");
+  }
+}
+
 #[test]
 fn field_constraints_and_call_anchors_follow_public_query_api_syntax() {
   let language = grammar::LANGUAGE.into();
@@ -159,173 +215,76 @@ fn adjacent_bare_wildcards_follow_public_query_api_pattern_and_capture_counts()
 }
 
 #[test]
-fn bare_wildcards_split_field_prefixes_but_identifier_contexts_preserve_ranges()
-{
+fn underscored_names_reach_semantic_validation_without_wildcard_splitting() {
   let language = grammar::LANGUAGE.into();
-  let query = Query::new(&language, "[(wildcard) (identifier)] @leaf").unwrap();
   let mut parser = parser();
-  for (source, expected) in [
-    (
-      "__ @x",
-      vec![("wildcard", 0..1), ("wildcard", 1..2), ("identifier", 4..5)],
-    ),
-    (
-      "_field: (x)",
-      vec![
-        ("wildcard", 0..1),
-        ("identifier", 1..6),
-        ("identifier", 9..10),
-      ],
-    ),
-    (
-      "(_x !_field) @_cap",
-      vec![
-        ("identifier", 1..3),
-        ("identifier", 5..11),
-        ("identifier", 14..18),
-      ],
-    ),
-    (
-      "(#_call? _arg @_cap)",
-      vec![
-        ("identifier", 2..7),
-        ("identifier", 9..13),
-        ("identifier", 15..19),
-      ],
-    ),
-    (
-      "(MISSING _type) (_super/_sub)",
-      vec![
-        ("identifier", 9..14),
-        ("identifier", 17..23),
-        ("identifier", 24..28),
-      ],
-    ),
+  for (source, error) in [
+    ("(_x)", QueryErrorKind::NodeType),
+    ("(_ !_x)", QueryErrorKind::Field),
+    ("(node_pattern !_)", QueryErrorKind::Field),
   ] {
+    assert_eq!(
+      Query::new(&language, source).unwrap_err().kind,
+      error,
+      "{source:?}"
+    );
     let tree = parser.parse(source, None).unwrap();
     assert!(!tree.root_node().has_error(), "{source:?}");
-    let mut cursor = QueryCursor::new();
-    let mut matches =
-      cursor.matches(&query, tree.root_node(), source.as_bytes());
-    let mut actual = Vec::new();
-    while let Some(item) = matches.next() {
-      let node = item.captures()[0].node;
-      assert_eq!(node.child_count(), 0);
-      actual.push((node.kind(), node.byte_range()));
-    }
-    assert_eq!(actual, expected, "{source:?}");
+    assert_eq!(tree.root_node().byte_range(), 0..source.len());
   }
 }
 
 #[test]
-fn chained_fields_preserve_names_separators_and_postfix_ranges() {
-  let tree = parser().parse("left: right: (_)+ @x", None).unwrap();
-  let root = tree.root_node();
-  assert!(!root.has_error());
-  assert_eq!(root.named_child_count(), 1);
-  let mut target = root.named_child(0).unwrap();
-  for (range, name_range, separator_range) in
-    [(0..20, 0..4, 4..5), (6..20, 6..11, 11..12)]
-  {
-    assert_eq!(target.kind(), "field_constraint");
-    assert_eq!(target.byte_range(), range);
-    assert_eq!(target.child_count(), 3);
-    assert_eq!(
-      target.child_by_field_name("name").unwrap().byte_range(),
-      name_range
-    );
-    let separator = target.child(1).unwrap();
-    assert_eq!(separator.kind(), ":");
-    assert!(!separator.is_named());
-    assert_eq!(separator.byte_range(), separator_range);
-    target = target.child_by_field_name("pattern").unwrap();
-  }
-  assert_eq!(target.kind(), "pattern");
-  assert_eq!(target.byte_range(), 13..20);
-  for (field, kind, range) in [
-    ("body", "node_pattern", 13..16),
-    ("quantifier", "quantifier", 16..17),
-    ("capture", "capture", 18..20),
-  ] {
-    let child = target.child_by_field_name(field).unwrap();
-    assert_eq!(child.kind(), kind);
-    assert_eq!(child.byte_range(), range);
+fn field_lookup_matches_cursor_ownership() {
+  let mut parser = parser();
+  for source in ["left: right: (_)+ @x", "(node . child: (_)+ @x !absent)"] {
+    let tree = parser.parse(source, None).unwrap();
+    let mut pending = vec![tree.root_node()];
+    let mut fields = 0;
+    while let Some(owner) = pending.pop() {
+      let mut cursor = owner.walk();
+      if !cursor.goto_first_child() {
+        continue;
+      }
+      loop {
+        let child = cursor.node();
+        if let Some(field) = cursor.field_name() {
+          assert_eq!(
+            owner.child_by_field_name(field),
+            Some(child),
+            "{source:?}: {field}"
+          );
+          assert_eq!(child.parent(), Some(owner));
+          fields += 1;
+        }
+        pending.push(child);
+        if !cursor.goto_next_sibling() {
+          break;
+        }
+      }
+    }
+    assert!(fields > 0, "{source:?}: no fields");
   }
 }
 
 #[test]
-fn string_leaves_preserve_literal_bytes_and_escape_spelling() {
+fn string_arguments_follow_public_query_api_syntax() {
   let language = grammar::LANGUAGE.into();
   let mut parser = parser();
-  for (source, expected) in [
-    (
-      "\"日\\\"本\"",
-      vec![
-        ("\"", 0..1),
-        ("string_content", 1..4),
-        ("escape_sequence", 4..6),
-        ("string_content", 6..9),
-        ("\"", 9..10),
-      ],
-    ),
-    (
-      "\";x\0\"",
-      vec![("\"", 0..1), ("string_content", 1..4), ("\"", 4..5)],
-    ),
-    (
-      "\"\\\n;x\0\"",
-      vec![
-        ("\"", 0..1),
-        ("escape_sequence", 1..3),
-        ("string_content", 3..6),
-        ("\"", 6..7),
-      ],
-    ),
-    (
-      "\"a\0b\0\0c\"",
-      vec![("\"", 0..1), ("string_content", 1..7), ("\"", 7..8)],
-    ),
-    (
-      "\"\0\"",
-      vec![("\"", 0..1), ("string_content", 1..2), ("\"", 2..3)],
-    ),
-    (
-      "\"a\\\0b\"",
-      vec![
-        ("\"", 0..1),
-        ("string_content", 1..2),
-        ("escape_sequence", 2..4),
-        ("string_content", 4..5),
-        ("\"", 5..6),
-      ],
-    ),
-    (
-      "\"\\\0\"",
-      vec![("\"", 0..1), ("escape_sequence", 1..3), ("\"", 3..4)],
-    ),
+  for source in [
+    "\"日\\\"本\"",
+    "\";x\0\"",
+    "\"\\\n;x\0\"",
+    "\"a\0b\0\0c\"",
+    "\"\0\"",
+    "\"a\\\0b\"",
+    "\"\\\0\"",
+    r#""\q""#,
+    "\"\r\"",
   ] {
     assert!(Query::new(&language, &format!("(#custom? {source})")).is_ok());
-    let tree = parser.parse(source, None).unwrap();
-    assert!(!tree.root_node().has_error(), "{source:?}");
-    let string = tree
-      .root_node()
-      .named_child(0)
-      .unwrap()
-      .child_by_field_name("body")
-      .unwrap();
-    let mut cursor = string.walk();
-    let actual: Vec<_> = string
-      .children(&mut cursor)
-      .map(|node| {
-        assert_eq!(node.child_count(), 0);
-        (node.kind(), node.byte_range())
-      })
-      .collect();
-    assert_eq!(actual, expected, "{source:?}");
-  }
-  for source in ["\"a\0", "\"\\\0", "\"a\\", "\"\0\n\""] {
     assert!(
-      parser.parse(source, None).unwrap().root_node().has_error(),
+      !parser.parse(source, None).unwrap().root_node().has_error(),
       "{source:?}"
     );
   }
@@ -353,20 +312,15 @@ fn string_newlines_cannot_skip_comments_before_nul() {
 }
 
 #[test]
-fn carriage_returns_inside_comments_preserve_the_following_pattern() {
+fn comments_with_carriage_returns_follow_public_query_api_syntax() {
   let language = grammar::LANGUAGE.into();
   let mut parser = parser();
-  let source = ";a\rb\r\n(_)";
-  assert!(Query::new(&language, source).is_ok());
-  let tree = parser.parse(source, None).unwrap();
-  let root = tree.root_node();
-  assert!(!root.has_error());
-  assert_eq!(
-    root.to_sexp(),
-    "(query (comment) (pattern body: (node_pattern node: (wildcard))))"
-  );
-  assert_eq!(root.named_child(0).unwrap().byte_range(), 0..4);
-  assert_eq!(root.named_child(1).unwrap().byte_range(), 6..9);
+  for (source, patterns) in [(";a\rb\r\n(_)", 1), (";x\r(_)", 0)] {
+    let query = Query::new(&language, source).unwrap();
+    assert_eq!(query.pattern_count(), patterns, "{source:?}");
+    let tree = parser.parse(source, None).unwrap();
+    assert!(!tree.root_node().has_error(), "{source:?}");
+  }
 }
 
 #[test]
@@ -425,96 +379,8 @@ fn highlight_captures_use_leaf_ranges_even_during_recovery() {
 }
 
 #[test]
-fn public_children_preserve_fields_delimiters_and_source_order() {
-  let source = "(node . child: (_)+ @x !absent)";
-  let tree = parser().parse(source, None).unwrap();
-  assert!(!tree.root_node().has_error());
-  let mut cursor = tree.walk();
-  let mut depth = 0;
-  let mut actual = Vec::new();
-  'walk: loop {
-    let node = cursor.node();
-    actual.push((
-      depth,
-      node.kind(),
-      cursor.field_name(),
-      node.is_named(),
-      node.byte_range(),
-    ));
-    assert_eq!(
-      node.start_position(),
-      Point {
-        row: 0,
-        column: node.start_byte()
-      }
-    );
-    assert_eq!(
-      node.end_position(),
-      Point {
-        row: 0,
-        column: node.end_byte()
-      }
-    );
-    if cursor.goto_first_child() {
-      depth += 1;
-      continue;
-    }
-    while !cursor.goto_next_sibling() {
-      if !cursor.goto_parent() {
-        break 'walk;
-      }
-      depth -= 1;
-    }
-  }
-  assert_eq!(
-    actual,
-    vec![
-      (0, "query", None, true, 0..31),
-      (1, "pattern", None, true, 0..31),
-      (2, "node_pattern", Some("body"), true, 0..31),
-      (3, "(", None, false, 0..1),
-      (3, "identifier", Some("node"), true, 1..5),
-      (3, "anchor", None, true, 6..7),
-      (3, "field_constraint", None, true, 8..22),
-      (4, "identifier", Some("name"), true, 8..13),
-      (4, ":", None, false, 13..14),
-      (4, "pattern", Some("pattern"), true, 15..22),
-      (5, "node_pattern", Some("body"), true, 15..18),
-      (6, "(", None, false, 15..16),
-      (6, "wildcard", Some("node"), true, 16..17),
-      (6, ")", None, false, 17..18),
-      (5, "quantifier", Some("quantifier"), true, 18..19),
-      (5, "capture", Some("capture"), true, 20..22),
-      (6, "@", None, false, 20..21),
-      (6, "identifier", Some("name"), true, 21..22),
-      (3, "negated_field", None, true, 23..30),
-      (4, "!", None, false, 23..24),
-      (4, "identifier", Some("name"), true, 24..30),
-      (3, ")", None, false, 30..31),
-    ]
-  );
-}
-
-#[test]
-fn bom_is_ignored_only_once_at_source_byte_zero() {
+fn bom_at_an_included_range_start_is_not_a_source_bom() {
   let mut parser = parser();
-  let source = "\u{feff}(node)\r\n";
-  let tree = parser.parse(source, None).unwrap();
-  assert!(!tree.root_node().has_error());
-  let pattern = tree.root_node().named_child(0).unwrap();
-  assert_eq!(pattern.byte_range(), 3..9);
-  assert_eq!(pattern.start_position(), Point { row: 0, column: 3 });
-  assert_eq!(tree.root_node().end_position(), Point { row: 1, column: 0 });
-  for invalid in [
-    " \u{feff}(node)",
-    "\u{feff}\u{feff}(node)",
-    "(node)\u{feff}",
-  ] {
-    assert!(
-      parser.parse(invalid, None).unwrap().root_node().has_error(),
-      "{invalid:?}"
-    );
-  }
   let embedded = "x\u{feff}(node)";
   parser
     .set_included_ranges(&[Range {
@@ -535,18 +401,3 @@ fn bom_is_ignored_only_once_at_source_byte_zero() {
       .has_error()
   );
 }
-
-#[test]
-fn crlf_and_multibyte_comment_ranges_keep_source_coordinates() {
-  let mut parser = parser();
-  let source = "; 日\r\n(node)";
-  let tree = parser.parse(source, None).unwrap();
-  let root = tree.root_node();
-  assert!(!root.has_error());
-  let comment = root.named_child(0).unwrap();
-  assert_eq!(comment.byte_range(), 0..5);
-  assert_eq!(comment.end_position(), Point { row: 0, column: 5 });
-  let pattern = root.named_child(1).unwrap();
-  assert_eq!(pattern.byte_range(), 7..13);
-  assert_eq!(pattern.start_position(), Point { row: 1, column: 0 });
-}

package/tree-sitter.json

@@ -12,7 +12,7 @@
     }
   ],
   "metadata": {
-    "version": "0.3.0",
+    "version": "0.3.1",
     "license": "MIT",
     "description": "Tree-sitter grammar for Tree-sitter Query.",
     "links": {