@dekobon/tree-sitter-groovy 0.2.0

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@dekobon/tree-sitter-groovy",
+  "version": "0.2.0",
+  "description": "Apache Groovy grammar for tree-sitter (dekobon fork)",
+  "main": "bindings/node",
+  "types": "bindings/node",
+  "keywords": [
+    "tree-sitter",
+    "parser",
+    "lexer",
+    "groovy",
+    "jenkins",
+    "gradle",
+    "spock",
+    "incremental",
+    "parsing"
+  ],
+  "files": [
+    "LICENSE-APACHE",
+    "LICENSE-MIT",
+    "grammar.js",
+    "binding.gyp",
+    "prebuilds/**",
+    "bindings/node/*",
+    "queries/*",
+    "src/**",
+    "tree-sitter.json",
+    "*.wasm"
+  ],
+  "homepage": "https://github.com/dekobon/tree-sitter-groovy",
+  "bugs": {
+    "url": "https://github.com/dekobon/tree-sitter-groovy/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dekobon/tree-sitter-groovy.git"
+  },
+  "scripts": {
+    "install": "node-gyp-build",
+    "prestart": "tree-sitter build --wasm",
+    "start": "tree-sitter playground",
+    "test": "node --test bindings/node/*_test.js",
+    "lint": "eslint .",
+    "prebuildify": "prebuildify --napi --strip"
+  },
+  "author": {
+    "email": "elijah@zupancic.name",
+    "name": "Elijah Zupancic"
+  },
+  "license": "Apache-2.0 OR MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "node-addon-api": "^8.7.0",
+    "node-gyp-build": "^4.8.4"
+  },
+  "peerDependencies": {
+    "tree-sitter": "^0.25.0"
+  },
+  "peerDependenciesMeta": {
+    "tree-sitter": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "eslint": "^9.39.4",
+    "eslint-config-treesitter": "^1.0.2",
+    "prebuildify": "^6.0.1",
+    "tree-sitter-cli": "^0.25.10"
+  },
+  "tree-sitter": [
+    {
+      "scope": "source.groovy",
+      "injection-regex": "^groovy$",
+      "file-types": [
+        "groovy",
+        "gradle",
+        "gvy",
+        "gy",
+        "jenkinsfile"
+      ]
+    }
+  ]
+}

package/queries/groovy/folds.scm

@@ -0,0 +1,18 @@
+; Fold regions for Groovy. nvim-treesitter / Neovim folding ranges
+; are taken from any node captured as @fold; the node's start and
+; end positions become the fold's bounds.
+;
+; See SPECIFICATION.md §9 — folds cover class / method / closure /
+; control-flow bodies plus large literal collections.
+
+(class_body) @fold
+(enum_body) @fold
+(switch_block) @fold
+(block) @fold
+(closure) @fold
+(list_literal) @fold
+(map_literal) @fold
+(argument_list) @fold
+
+(groovydoc_comment) @fold
+(block_comment) @fold

package/queries/groovy/highlights.scm

@@ -0,0 +1,235 @@
+; tree-sitter-groovy highlight queries.
+;
+; Capture names follow nvim-treesitter conventions:
+; https://neovim.io/doc/user/treesitter.html#treesitter-highlight-groups
+;
+; Precedence rule: tree-sitter highlight queries are last-match-wins
+; per node. Layers below are ordered from broadest to most specific:
+;   1. comments / number / string / boolean / null
+;   2. anonymous-token operators (also captures . , ?., etc.)
+;   3. generic identifier → @variable  (the catch-all)
+;   4. keywords (@keyword, @keyword.control, @keyword.operator)
+;   5. field / property captures off the dot family
+;   6. declared names (class / method / record / formal parameter)
+;   7. call-site captures (@function.call) — must come AFTER property
+;      so a method-named field beats the property capture
+;   8. type uses (@type on type_identifier) — must come AFTER
+;      @variable so aliased identifier-as-type wins
+;   9. annotation usage (the @attribute capture)
+
+; -- Layer 1: comments and literals --------------------------------
+
+(line_comment) @comment
+(block_comment) @comment
+(groovydoc_comment) @comment.documentation
+
+(number_literal) @number
+(string_literal) @string
+(string_fragment) @string
+(boolean_literal) @boolean
+(null_literal) @constant.builtin
+
+; GString interpolation — `${expr}` and `$identifier` (per §5.7).
+(gstring_brace_interpolation
+  "${" @punctuation.special
+  "}" @punctuation.special)
+(gstring_dollar_interpolation
+  value: (identifier) @variable)
+
+; -- Layer 2: operators (anonymous tokens) -------------------------
+
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "!"
+  "~"
+  "<<"
+  ">>"
+  ">>>"
+  "<"
+  "<="
+  ">"
+  ">="
+  "=="
+  "!="
+  "&"
+  "^"
+  "|"
+  "&&"
+  "||"
+  ".."
+  "..<"
+  "<.."
+  "<..<"
+  "==="
+  "!=="
+  "<=>"
+  "=~"
+  "==~"
+  "?:"
+  "?"
+  "==>"
+  "="
+  "+="
+  "-="
+  "*="
+  "/="
+  "%="
+  "**="
+  "<<="
+  ">>="
+  ">>>="
+  "&="
+  "^="
+  "|="
+  "?="
+  "**"
+  "++"
+  "--"
+  "."
+  "?."
+  "??."
+  "*."
+  ".&"
+  ".@"
+  "::"
+  "*:"
+] @operator
+
+; -- Layer 3: generic identifier fallback --------------------------
+
+(identifier) @variable
+
+; -- Layer 4: keywords ---------------------------------------------
+
+[
+  "new"
+  "as"
+  "in"
+  "instanceof"
+] @keyword.operator
+
+; `!in` and `!instanceof` are composite tokens (literal + trailing
+; whitespace) per SPECIFICATION.md §3.2.2 lexer rule, so they
+; cannot be referenced as direct anonymous tokens in a `[ … ]`
+; group. Capture them through the operator field instead.
+(membership_expression operator: _ @keyword.operator)
+(instanceof_expression operator: _ @keyword.operator)
+
+[
+  "if"
+  "else"
+  "while"
+  "do"
+  "for"
+  "return"
+  "break"
+  "continue"
+  "throw"
+  "throws"
+  "assert"
+  "try"
+  "catch"
+  "finally"
+  "switch"
+  "case"
+  "default"
+  "yield"
+] @keyword.control
+
+[
+  "class"
+  "trait"
+  "interface"
+  "enum"
+  "record"
+  "def"
+  "var"
+  "package"
+  "import"
+  "pipeline"
+  "sealed"
+  "non-sealed"
+  "permits"
+  "extends"
+  "implements"
+] @keyword
+
+[
+  "public"
+  "private"
+  "protected"
+  "static"
+  "final"
+  "abstract"
+  "synchronized"
+  "native"
+  "transient"
+  "volatile"
+  "strictfp"
+] @keyword.modifier
+
+(shebang) @keyword.directive
+
+; -- Layer 5: dot-family property captures -------------------------
+
+(field_access                    field: [(identifier) (quoted_identifier)] @property)
+(safe_navigation_expression     property: [(identifier) (quoted_identifier)] @property)
+(safe_chain_dot_expression      property: [(identifier) (quoted_identifier)] @property)
+(spread_dot_expression          property: [(identifier) (quoted_identifier)] @property)
+(direct_field_access_expression  field: [(identifier) (quoted_identifier)] @property)
+(method_pointer_expression      method: [(identifier) (quoted_identifier)] @function)
+; `Foo::new` — the `new` literal is captured as @keyword.operator at
+; layer 4 instead of @function here.
+(method_reference_expression       name: (identifier) @function)
+
+; -- Layer 6: declared names ---------------------------------------
+
+(class_declaration name: (identifier) @type.definition)
+(trait_declaration name: (identifier) @type.definition)
+(interface_declaration name: (identifier) @type.definition)
+(enum_declaration name: (identifier) @type.definition)
+(record_declaration name: (identifier) @type.definition)
+(annotation_type_declaration name: (identifier) @type.definition)
+(enum_constant name: (identifier) @constant)
+(method_declaration name: [(identifier) (quoted_identifier)] @function)
+(constructor_declaration name: (identifier) @constructor)
+(formal_parameter name: (identifier) @variable.parameter)
+(closure_parameter name: (identifier) @variable.parameter)
+(record_component name: (identifier) @variable.parameter)
+(variable_declarator name: (identifier) @variable)
+(field_declaration (variable_declarator name: (identifier) @property))
+
+; Labels (declaration + use sites)
+(labeled_statement label: (identifier) @label)
+(break_statement label: (identifier) @label)
+(continue_statement label: (identifier) @label)
+
+; -- Layer 7: call sites (after layer 5 so method-named fields win) -
+
+(method_invocation
+  function: (identifier) @function.call)
+
+(method_invocation
+  function: (field_access
+              field: (identifier) @function.call))
+
+(command_chain
+  receiver: (identifier) @function.call)
+
+; -- Layer 8: types (after @variable so aliased identifier wins) ---
+
+(type_identifier) @type
+
+; Java/Groovy primitive types and `void` highlight as builtin.
+((type_identifier) @type.builtin
+  (#match? @type.builtin "^(boolean|byte|char|double|float|int|long|short|void)$"))
+
+; -- Layer 9: annotation usage -------------------------------------
+
+(annotation
+  "@" @attribute
+  name: (qualified_name) @attribute)

package/queries/groovy/indents.scm

@@ -0,0 +1,35 @@
+; Indent rules for Groovy.
+;
+; nvim-treesitter conventions:
+;   @indent.begin  — node whose contents are indented one level
+;   @indent.end    — node that closes an indent block
+;   @indent.dedent — node that dedents by one level
+;   @indent.branch — node that aligns with its enclosing block
+;
+; See SPECIFICATION.md §9.
+
+[
+  (class_body)
+  (enum_body)
+  (switch_block)
+  (block)
+  (closure)
+  (list_literal)
+  (map_literal)
+  (argument_list)
+  (formal_parameters)
+  (record_components)
+] @indent.begin
+
+[
+  "}"
+  "]"
+  ")"
+] @indent.end
+
+; Branch labels — case / default lines align with the switch_block.
+[
+  (switch_case)
+  (switch_arrow_case)
+  (switch_default)
+] @indent.branch

package/queries/groovy/injections.scm

@@ -0,0 +1,38 @@
+; Language injections per SPECIFICATION.md §9.2.
+;
+; Doc comments inject as a documentation language. Slashy and
+; dollar-slashy string literals inject as `regex` so editors
+; highlight the pattern body. Named-call DSL strings
+; (`sql.execute """..."""`, `xmlSlurper.parseText """..."""`)
+; inject the embedded language when the receiver name matches.
+
+((groovydoc_comment) @injection.content
+ (#set! injection.language "javadoc"))
+
+; Slashy regex `/.../` — the leading `/` is what distinguishes it
+; from the plain-string flavours at the query layer (single-,
+; triple-single-, double-, triple-double-quoted strings all
+; share the `string_literal` node kind).
+((string_literal) @injection.content
+  (#match? @injection.content "^/[^/]")
+  (#set! injection.language "regex"))
+
+; Dollar-slashy regex `$/.../$`.
+((string_literal) @injection.content
+  (#match? @injection.content "^\\$/")
+  (#set! injection.language "regex"))
+
+; `sql.execute """SELECT ..."""` and similar SQL DSL idioms.
+; Matches a method invocation whose receiver chain ends in `sql`
+; or `Sql` and whose first argument is a triple-double-quoted
+; string. The injection content is the body's literal-fragment
+; range, so `${param}` interpolations stay tree-sitter-parsable
+; rather than being swallowed by the SQL highlighter.
+((method_invocation
+   function: (field_access
+     object: (identifier) @_recv
+     field: (identifier))
+   arguments: (argument_list
+     (string_literal (string_fragment) @injection.content)))
+ (#match? @_recv "^[Ss]ql$")
+ (#set! injection.language "sql"))

package/queries/groovy/locals.scm

@@ -0,0 +1,32 @@
+; Local-scope captures per SPECIFICATION.md §9.3.
+;
+; nvim-treesitter / Neovim local-scope query language:
+;   @local.scope      — node introduces a fresh scope
+;   @local.definition — captures a binding (formal, declarator, …)
+;   @local.reference  — captures a use site of an identifier
+
+; Scopes — anywhere a new symbol table is opened.
+[
+  (class_body)
+  (block)
+  (closure)
+  (method_declaration)
+  (constructor_declaration)
+  (static_initializer)
+  (for_statement)
+  (for_in_statement)
+  (catch_clause)
+] @local.scope
+
+; Definitions — bound names introduced inside their enclosing scope.
+(formal_parameter name: (identifier) @local.definition.parameter)
+(closure_parameter name: (identifier) @local.definition.parameter)
+(variable_declarator name: (identifier) @local.definition.var)
+(field_declaration
+  (variable_declarator name: (identifier) @local.definition.field))
+(for_in_statement variable: (identifier) @local.definition.var)
+(catch_formal_parameter name: (identifier) @local.definition.var)
+(record_component name: (identifier) @local.definition.parameter)
+
+; References — bare identifiers used as values.
+(identifier) @local.reference

package/queries/groovy/tags.scm

@@ -0,0 +1,67 @@
+; Tag captures per SPECIFICATION.md §2.1.
+;
+; Tag-query convention (matches tree-sitter-tags / nvim-treesitter):
+;   @definition.<kind>  — declaration site of a top-level symbol
+;   @reference.<kind>   — call / instantiation reference
+;   @name               — the identifier inside the tag, used to
+;                         resolve the symbol name when emitting tags
+;
+; Captures are kept conservative: only declarations whose name is a
+; bare `identifier` are tagged. Quoted-identifier method names
+; (`def "abstract"() { … }`) are skipped — `ctags` consumers expect
+; plain symbol names.
+
+; --- Definitions ----------------------------------------------------
+
+(class_declaration
+  name: (identifier) @name) @definition.class
+
+(interface_declaration
+  name: (identifier) @name) @definition.interface
+
+(trait_declaration
+  name: (identifier) @name) @definition.trait
+
+(annotation_type_declaration
+  name: (identifier) @name) @definition.interface
+
+(enum_declaration
+  name: (identifier) @name) @definition.enum
+
+(record_declaration
+  name: (identifier) @name) @definition.class
+
+(method_declaration
+  name: (identifier) @name) @definition.method
+
+(constructor_declaration
+  name: (identifier) @name) @definition.constructor
+
+(field_declaration
+  (variable_declarator
+    name: (identifier) @name)) @definition.field
+
+(enum_constant
+  name: (identifier) @name) @definition.constant
+
+; --- References -----------------------------------------------------
+
+(method_invocation
+  function: (identifier) @name) @reference.call
+
+(method_invocation
+  function: (field_access
+    field: (identifier) @name)) @reference.call
+
+(object_creation_expression
+  type: (type_identifier) @name) @reference.class
+
+(object_creation_expression
+  type: (generic_type
+    base: (type_identifier) @name)) @reference.class
+
+(superclass (type_identifier) @name) @reference.class
+
+(super_interfaces (type_identifier) @name) @reference.implementation
+
+(extends_interfaces (type_identifier) @name) @reference.implementation