@konomanoasa/tree-sitter-query 0.1.0

package/Cargo.toml

@@ -0,0 +1,36 @@
+[package]
+name = "konomanoasa-tree-sitter-query"
+version = "0.1.0"
+edition = "2024"
+description = "Tree-sitter grammar for Tree-sitter Query."
+readme = "README.md"
+repository = "https://github.com/konomanoasa/tree-sitter-query"
+license = "MIT"
+build = "bindings/rust/build.rs"
+links = "tree-sitter-query"
+include = [
+  "/LICENSE",
+  "/README.md",
+  "/bindings/rust/*.rs",
+  "/queries/*.scm",
+  "/src/*.c",
+  "/src/node-types.json",
+  "/src/tree_sitter/*.h",
+  "/test/bindings.test.rs",
+]
+
+[lib]
+path = "bindings/rust/lib.rs"
+
+[[test]]
+name = "bindings"
+path = "test/bindings.test.rs"
+
+[dependencies]
+tree-sitter-language = "0.1.8"
+
+[dev-dependencies]
+tree-sitter = "0.27.0"
+
+[build-dependencies]
+cc = "1.4"

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 konomanoasa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+# tree-sitter-query
+
+[![CI](https://github.com/konomanoasa/tree-sitter-query/actions/workflows/ci.yaml/badge.svg)](https://github.com/konomanoasa/tree-sitter-query/actions/workflows/ci.yaml)
+[![crates.io](https://img.shields.io/crates/v/konomanoasa-tree-sitter-query)](https://crates.io/crates/konomanoasa-tree-sitter-query)
+[![npm](https://img.shields.io/npm/v/@konomanoasa/tree-sitter-query)](https://www.npmjs.com/package/@konomanoasa/tree-sitter-query)
+
+[Tree-sitter](https://tree-sitter.github.io/tree-sitter/) grammar for
+Tree-sitter Query Language.
+
+## Installation
+
+```sh
+npm install @konomanoasa/tree-sitter-query
+```
+
+## Development
+
+Development uses Node.js 24 or later.
+
+```sh
+npm install
+npm run build
+npm test
+```
+
+## Specifications
+
+- [Tree-sitter query syntax](https://tree-sitter.github.io/tree-sitter/using-parsers/queries/1-syntax.html)
+- [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)
+
+## License
+
+[MIT](LICENSE)

package/bindings/rust/build.rs

@@ -0,0 +1,23 @@
+use std::{env, path::Path};
+
+fn main() {
+  let mut build = cc::Build::new();
+  build.std("c17");
+  if build.get_compiler().is_like_msvc() {
+    build.flag("-utf-8");
+  }
+  if env::var("TARGET").expect("Cargo must provide TARGET")
+    == "wasm32-unknown-unknown"
+  {
+    let headers = env::var_os("DEP_TREE_SITTER_LANGUAGE_WASM_HEADERS")
+      .expect("tree-sitter-language must provide WebAssembly headers");
+    build.include(&headers);
+    println!("cargo::rerun-if-changed={}", Path::new(&headers).display());
+  }
+
+  println!("cargo::rerun-if-changed=src");
+  build
+    .include("src")
+    .file("src/parser.c")
+    .compile("tree-sitter-query");
+}

package/bindings/rust/lib.rs

@@ -0,0 +1,12 @@
+use tree_sitter_language::LanguageFn;
+
+unsafe extern "C" {
+  fn tree_sitter_query() -> *const ();
+}
+
+pub const LANGUAGE: LanguageFn =
+  unsafe { LanguageFn::from_raw(tree_sitter_query) };
+
+pub const NODE_TYPES: &str = include_str!("../../src/node-types.json");
+
+pub const HIGHLIGHTS_QUERY: &str = include_str!("../../queries/highlights.scm");

package/grammar.js

@@ -0,0 +1,191 @@
+const name = /[A-Za-z0-9_-][A-Za-z0-9_.-]*/;
+const stringContent = /[^"\\\n]+/;
+
+const postfixed = ($, body) =>
+  seq(
+    field("body", body),
+    repeat(
+      choice(field("capture", $.capture), field("quantifier", $.quantifier)),
+    ),
+  );
+
+const anchored = ($, member) => seq(optional($.anchor), member);
+
+const fieldConstraint = ($, target) =>
+  seq(
+    field(
+      "name",
+      choice(
+        alias($._field_identifier, $.identifier),
+        alias("MISSING", $.identifier),
+      ),
+    ),
+    ":",
+    field("pattern", target),
+  );
+
+// The Query API accepts no layout or comment around the subtype separator.
+const subtyped = ($, name) =>
+  seq(
+    field("supertype", name),
+    token.immediate("/"),
+    field(
+      "subtype",
+      choice(
+        alias($._immediate_identifier, $.identifier),
+        alias($._immediate_string, $.string),
+      ),
+    ),
+  );
+
+const call = ($, marker) =>
+  seq(
+    "(",
+    "#",
+    field("name", alias($._immediate_identifier, $.identifier)),
+    token.immediate(marker),
+    repeat(field("argument", choice($.capture, $.string, $._name))),
+    ")",
+  );
+
+export default grammar({
+  name: "query",
+  extras: ($) => [/[ \t\r\n\v\f]/, $.comment],
+  rules: {
+    query: ($) => repeat($._member),
+    _member: ($) => choice($._child_pattern, $._call),
+    _call_only_member: ($) => choice($._call_only_child_pattern, $._call),
+    _call: ($) => choice($.predicate, $.directive),
+    pattern: ($) => postfixed($, choice($._delimited, $.string, $.wildcard)),
+    _call_only_pattern: ($) =>
+      postfixed(
+        $,
+        choice(
+          alias($._call_only_group, $.group),
+          alias($._call_only_alternation, $.alternation),
+        ),
+      ),
+    // "(_" always opens a node pattern, so a group never starts with a bare wildcard.
+    _group_pattern: ($) => postfixed($, choice($._delimited, $.string)),
+    _delimited: ($) => choice($.node_pattern, $.group, $.alternation),
+    node_pattern: ($) =>
+      seq(
+        "(",
+        choice(
+          field("node", alias($._untyped_missing_node, $.missing_node)),
+          seq(
+            field(
+              "node",
+              choice($.identifier, $.wildcard, $.supertype, $.missing_node),
+            ),
+            repeat($._node_annotation),
+            optional(
+              seq(
+                anchored($, $._matching_child_pattern),
+                repeat(
+                  choice(
+                    $._node_annotation,
+                    anchored($, $._matching_child_pattern),
+                  ),
+                ),
+                optional($.anchor),
+              ),
+            ),
+          ),
+        ),
+        ")",
+      ),
+    _child_pattern: ($) =>
+      choice($._matching_child_pattern, $._call_only_child_pattern),
+    _matching_child_pattern: ($) => choice($.pattern, $.field_constraint),
+    _call_only_child_pattern: ($) =>
+      choice(
+        alias($._call_only_pattern, $.pattern),
+        alias($._call_only_field_constraint, $.field_constraint),
+      ),
+    _node_annotation: ($) =>
+      choice(anchored($, $._call_only_member), $.negated_field),
+    field_constraint: ($) => fieldConstraint($, $._matching_child_pattern),
+    _call_only_field_constraint: ($) =>
+      fieldConstraint($, $._call_only_child_pattern),
+    negated_field: ($) => seq("!", field("name", $._name)),
+    supertype: ($) =>
+      subtyped($, choice($.identifier, alias($.wildcard, $.identifier))),
+    _untyped_missing_node: () => "MISSING",
+    missing_node: ($) =>
+      seq(
+        "MISSING",
+        field(
+          "type",
+          choice($._name, $.string, alias($._missing_supertype, $.supertype)),
+        ),
+      ),
+    _missing_supertype: ($) => subtyped($, $._name),
+    group: ($) =>
+      seq(
+        "(",
+        choice(
+          alias($._group_pattern, $.pattern),
+          seq(
+            $._call_only_group_start,
+            repeat(anchored($, $._call_only_member)),
+            anchored($, $._matching_child_pattern),
+          ),
+        ),
+        repeat(anchored($, $._member)),
+        ")",
+      ),
+    _call_only_group: ($) =>
+      seq(
+        "(",
+        $._call_only_group_start,
+        repeat(anchored($, $._call_only_member)),
+        ")",
+      ),
+    _call_only_group_start: ($) =>
+      choice($._call, alias($._call_only_pattern, $.pattern)),
+    alternation: ($) =>
+      seq(
+        "[",
+        repeat($._call_only_member),
+        $._matching_child_pattern,
+        repeat($._member),
+        "]",
+      ),
+    _call_only_alternation: ($) => seq("[", repeat1($._call_only_member), "]"),
+    quantifier: () => token(choice("+", "*", "?")),
+    anchor: () => ".",
+    capture: ($) =>
+      seq("@", field("name", alias($._immediate_identifier, $.identifier))),
+    predicate: ($) => call($, "?"),
+    directive: ($) => call($, "!"),
+    identifier: () => name,
+    _field_identifier: () => /[A-Za-z0-9-][A-Za-z0-9_.-]*/,
+    _immediate_identifier: () => token.immediate(name),
+    _name: ($) =>
+      choice(
+        $.identifier,
+        alias($.wildcard, $.identifier),
+        alias("MISSING", $.identifier),
+      ),
+    wildcard: () => "_",
+    string: ($) => seq('"', $._string_tail),
+    _immediate_string: ($) => seq(token.immediate('"'), $._string_tail),
+    _string_tail: ($) =>
+      seq(
+        repeat(choice($.string_content, $.escape_sequence)),
+        token.immediate('"'),
+      ),
+    // Content outranks the comment extra so that ; stays inside the string.
+    string_content: () =>
+      token.immediate(
+        prec(
+          1,
+          repeat1(choice(stringContent, seq("\0", optional(stringContent)))),
+        ),
+      ),
+    // Distinct NUL transitions prevent the generated lexer from treating it as EOF.
+    escape_sequence: () => token.immediate(choice(/\\(.|\n)/, prec(1, "\\\0"))),
+    comment: () => /;[^\r\n]*(\r+[^\r\n]+)*/,
+  },
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@konomanoasa/tree-sitter-query",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Tree-sitter grammar for Tree-sitter Query.",
+  "license": "MIT",
+  "repository": "git+https://github.com/konomanoasa/tree-sitter-query.git",
+  "files": [
+    "Cargo.toml",
+    "bindings/rust/*.rs",
+    "grammar.js",
+    "queries/*.scm",
+    "src/*.c",
+    "src/*.json",
+    "src/tree_sitter/*.h",
+    "test/bindings.test.rs",
+    "tree-sitter.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "npm run tree-sitter -- build-all",
+    "check": "biome check . && node scripts/check-generated.js && npm test",
+    "format": "biome check --write .",
+    "generate": "npm run tree-sitter -- generate-all",
+    "test": "npm run tree-sitter -- test-corpus --rebuild && node --test --test-concurrency=1 \"test/*.test.js\"",
+    "test:bindings": "cargo test --locked",
+    "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",
+    "tree-sitter": "node scripts/tree-sitter.js"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.5.14",
+    "@types/node": "26.5.1",
+    "tree-sitter-cli": "0.27.0"
+  },
+  "allowScripts": {
+    "tree-sitter-cli": true
+  }
+}

package/queries/highlights.scm

@@ -0,0 +1,59 @@
+(identifier) @type
+
+(string_content) @string
+
+(escape_sequence) @string.escape
+
+(comment) @comment
+
+[
+  "("
+  ")"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "\""
+  ":"
+  "/"
+] @punctuation.delimiter
+
+[
+  "@"
+  "#"
+] @punctuation.special
+
+(wildcard) @character.special
+
+[
+  (quantifier)
+  (anchor)
+] @operator
+
+(missing_node
+  "MISSING" @keyword)
+
+(field_constraint
+  name: (identifier) @property)
+
+(negated_field
+  "!" @operator
+  name: (identifier) @property)
+
+(capture
+  name: (identifier) @variable)
+
+(predicate
+  name: (identifier) @function.call
+  "?" @punctuation.special)
+
+(directive
+  name: (identifier) @function.call
+  "!" @punctuation.special)
+
+(predicate
+  argument: (identifier) @string)
+
+(directive
+  argument: (identifier) @string)