@dekobon/tree-sitter-groovy 0.3.0 → 0.5.0

package/README.md

@@ -166,6 +166,27 @@ These are documented in detail in
   as `a + b` rather than splitting into two statements. Idiomatic
   Groovy places continuation operators at the end of the previous
   line.
+- **A `{` after `new T(...)` is always an anonymous class body** --
+  Groovy instead calls a closure on the new object when the `{`
+  starts a later line (outside parentheses and brackets) or cannot be
+  a class body, so `new ArrayList()\n{ list.add(1) }` and
+  `new T() { x -> x }` get an `ERROR` inside a `class_body`. Write
+  `new ArrayList().call { ... }` to keep the call.
+- **A `{ ... }` straight after a field with no initializer is an
+  instance initializer block** -- `int x { ... }` parses with no
+  `ERROR`. A record's compact constructor (`public Name { ... }`),
+  which is unsupported, takes the same reading. After a field *with*
+  an initializer a next-line `{` is that expression's trailing
+  closure, as in Groovy: end the field with `;` to get an
+  initializer block.
+- **`sealed` and `trait` are keywords where a class member can
+  start** -- a field or enum constant named `sealed` or `trait` is an
+  `ERROR` when it follows a modifier (`private boolean sealed`) or
+  opens the member (`static trait = 1`, `enum E { trait }`).
+  `boolean sealed` and `String trait`, with no modifier, parse.
+  `record` is not affected: it is a keyword only directly before a
+  record header (`record Name(`), so `private Record record` and
+  `record.key()` parse.
 
 ## Contributing
 

package/grammar.js

@@ -7,12 +7,12 @@
  * SPECIFICATION.md at the repository root. Every rule below maps to
  * a section there. Read the spec before making non-trivial changes.
  *
- * The external scanner (src/scanner.c) handles four context-sensitive
+ * The external scanner (src/scanner.c) handles three context-sensitive
  * lexing situations that pure grammar rules cannot disambiguate:
  *   - Slashy-string-start vs. division
- *   - Automatic-semicolon (newline-as-terminator)
- *   - Labelled-statement colon
- *   - Block-comment / Groovydoc single-token emit
+ *   - Line / block / Groovydoc comment single-token emit
+ *   - The contextual `record` keyword, emitted only before a record
+ *     header so the word stays an identifier everywhere else
  * See SPECIFICATION.md §6.
  */
 
@@ -79,6 +79,18 @@ module.exports = grammar({
   // is the contract this rule set will fulfil.
   word: $ => $.identifier,
 
+  // §5.2 — `new` is a hard keyword. Keyword extraction alone still
+  // lexes it as `identifier` wherever the keyword has no action,
+  // which let `def f = (Foo) new T()` after another member split
+  // into a field `= (Foo)` and a method `T()` returning `new`. The
+  // empty `property` set keeps `foo.new` (Apache `namePart`) valid;
+  // `_property_name` also names methods, so `new` is not reserved
+  // where a method name may follow (`def new`, `int new`).
+  reserved: {
+    global: _ => ['new'],
+    property: _ => [],
+  },
+
   extras: $ => [
     /\s/,
     $.line_comment,
@@ -102,6 +114,7 @@ module.exports = grammar({
     $.line_comment,
     $.block_comment,
     $.groovydoc_comment,
+    $._record_keyword,
   ],
 
   conflicts: $ => [
@@ -109,7 +122,7 @@ module.exports = grammar({
     // (list_literal vs map_literal — tree-sitter resolves without
     //  an explicit conflict because `:` after the first element
     //  always disambiguates within one token of lookahead.)
-    //
+
     // §5.15 — inside `( … )` an identifier could be either an
     // _expression (parenthesized_expression) or a _type
     // (parenthesized_type_cast). Tree-sitter explores both via
@@ -145,6 +158,25 @@ module.exports = grammar({
     // decides; the conflict keeps both alternatives alive until
     // then.
     [$.variable_declarator, $._property_name],
+
+    // §4 — `static NAME` inside a class body: after one or more
+    // modifiers and one identifier, that identifier could be the
+    // modifier-only field_declaration's variable_declarator name
+    // (`static MEDIUM_TTL = 900`) or the start of a typed
+    // field_declaration/method_declaration's `_type` (`static Foo
+    // bar`). The next token (`=`/`,`/`;` vs a second identifier)
+    // disambiguates.
+    [$.variable_declarator, $._type],
+
+    // §4 — `enum E { E(v, w) { } }`: after `E(` an identifier could be
+    // a constant's argument (`_expression`) or a constructor's untyped
+    // parameter (`formal_parameter`); the `{` after `)` decides. The
+    // conflict is global by necessity — it is between the two
+    // reductions, not their containers — and was checked inert
+    // outside an enum body: declaring it on the v0.3.0 grammar makes
+    // tree-sitter report it unnecessary. Regenerate without it to
+    // confirm that still holds.
+    [$.formal_parameter, $._expression],
   ],
 
   rules: {
@@ -232,9 +264,9 @@ module.exports = grammar({
       field('statement', $._statement),
     )),
 
-    // §4 — block of statements, used in control-flow bodies and
-    // (eventually) method bodies. Shares `{ ... }` syntax with
-    // closure (§5.8). A `prec(1, …)` keeps block preferred at use
+    // §4 — block of statements: control-flow, method and constructor
+    // bodies, static / instance initializers. Shares `{ ... }` syntax
+    // with closure (§5.8). A `prec(1, …)` keeps block preferred at use
     // sites where both `block` and a closure-bearing `_statement`
     // are valid alternatives (e.g. the body slot of `if` / `while`).
     block: $ => prec(1, seq(
@@ -390,9 +422,10 @@ module.exports = grammar({
 
     // §4 — `catch_formal_parameter` accepts either a single _type
     // or a multi_type for Java 7+ / Groovy multi-catch. Closes
-    // murtaza64 #39.
+    // murtaza64 #39. The type itself is optional — Groovy allows a
+    // bare `catch (e) { … }`, implicitly typed as Exception.
     catch_formal_parameter: $ => seq(
-      field('type', choice($._type, $.multi_type)),
+      optional(field('type', choice($._type, $.multi_type))),
       field('name', $.identifier),
     ),
 
@@ -525,23 +558,56 @@ module.exports = grammar({
       field('body', $.class_body),
     ),
 
-    // §4 — `{ method* }` for v1. Field declarations, static
-    // initialisers, and inner classes land later.
+    // §4 — member list shared by class / interface / trait / record /
+    // `@interface` bodies and the anonymous inner class body of
+    // `object_creation_expression`.
     // The body accepts `;` as an empty member / terminator the same
     // way statement lists do (§5.10): a field or abstract method is
     // commonly written `int x = 1;` / `void f();`, and a stray `;` is
     // a no-op member. `;` is anonymous, so it never appears in the AST.
+    //
+    // A bare `block` is an instance initializer. It sits in the member
+    // repeat — here and in the three identical repeats of `enum_body` —
+    // rather than in `_class_member`, because `enum_body` also places
+    // a lone `_class_member` directly after its constants. A block in
+    // that slot is an LR conflict on `A() {` (constructor, or constant
+    // plus initializer) and, once that is resolved, silently accepts
+    // `A { }` (a constant with an anonymous class body, unsupported)
+    // as constant-plus-initializer.
     class_body: $ => seq(
       '{',
-      repeat(choice($._class_member, ';')),
+      repeat(choice($._class_member, $.block, ';')),
       '}',
     ),
 
+    // Nested type declarations are members, as in Apache's
+    // `memberDeclaration`. Each kind must be listed: a declaration
+    // keyword with no action at member start lexes as an identifier,
+    // so `class Inner { … }` would silently parse as a field `Inner`
+    // of type `class` followed by an instance initializer block, and
+    // a nested `record R(int x) { }` as a method `R` returning
+    // `record`. The record keyword comes from the scanner (§6.7), so
+    // listing it here does not reserve `record` as a member name.
+    //
+    // The price: `trait` and `sealed` are keywords wherever a member
+    // can start, as they already are where a statement can. A member
+    // cannot open with one of them as a plain identifier, with or
+    // without modifiers (`static trait = 1`, `sealed() { }`), nor use
+    // one as the name after `modifier(s) Type`, because `private Foo`
+    // is already a complete field (`private boolean sealed` is an
+    // ERROR; `boolean sealed` is not). See divergence 12. No
+    // `conflicts` entry is needed.
     _class_member: $ => choice(
       $.method_declaration,
       $.field_declaration,
       $.constructor_declaration,
       $.static_initializer,
+      $.enum_declaration,
+      $.class_declaration,
+      $.interface_declaration,
+      $.trait_declaration,
+      $.record_declaration,
+      $.annotation_type_declaration,
     ),
 
     // §4 — constructors share the method_declaration shape but have
@@ -573,12 +639,28 @@ module.exports = grammar({
     // more declarators (each with optional initializer). Method
     // declarations share the same prefix; `prec(2, …)` on
     // `method_declaration` and the trailing `(` discriminate.
-    field_declaration: $ => seq(
-      repeat($.annotation),
-      repeat($._modifier),
-      choice('def', field('type', $._type)),
-      $.variable_declarator,
-      repeat(seq(',', $.variable_declarator)),
+    //
+    // A modifier alone (no `def`, no type) also introduces a field —
+    // `static MEDIUM_TTL = 900` infers Object, a common constant-field
+    // idiom. Gated behind `repeat1($._modifier)` (not `repeat`) so this
+    // alternative can't match a bare, modifier-less identifier, which
+    // would collide with a plain expression_statement.
+    field_declaration: $ => choice(
+      // Prefer the typed field when both parses succeed, rather than
+      // splitting `private final int v\n C() {}` after `int`.
+      prec.dynamic(1, seq(
+        repeat($.annotation),
+        repeat($._modifier),
+        choice('def', field('type', $._type)),
+        $.variable_declarator,
+        repeat(seq(',', $.variable_declarator)),
+      )),
+      seq(
+        repeat($.annotation),
+        repeat1($._modifier),
+        $.variable_declarator,
+        repeat(seq(',', $.variable_declarator)),
+      ),
     ),
 
     // §4 — `def name(params) body`. Typed return type (`String foo()
@@ -626,10 +708,13 @@ module.exports = grammar({
       ')',
     ),
 
-    // §5.13 — formal parameter with optional type, optional
-    // varargs marker (`Type... name`), and optional default value
+    // §5.13 — formal parameter with optional annotations (Spring's
+    // `@PathVariable`, `@RequestBody`, JPA's `@Param`, … — ubiquitous
+    // on framework-facing methods), optional type, optional varargs
+    // marker (`Type... name`), and optional default value
     // (`name = expr`).
     formal_parameter: $ => seq(
+      repeat($.annotation),
       optional(field('type', choice($._type, $.varargs_type))),
       field('name', $.identifier),
       optional(seq('=', field('default', $._expression))),
@@ -637,13 +722,36 @@ module.exports = grammar({
 
     varargs_type: $ => seq($._type, '...'),
 
-    // §4 — enum. Closes murtaza64 #36 first half. Constants list
-    // (optionally trailing-comma) optionally followed by `;` and
-    // further class members. Constants may carry constructor
-    // arguments (`RED(0xff0000)`); v1 supports that via the
-    // optional argument_list.
+    // §4 — enum. Closes murtaza64 #36 first half. Constants may
+    // carry constructor arguments (`RED(0xff0000)`) via the optional
+    // argument_list.
+    //
+    // The body follows GroovyParser.g4 `classBody` for `t == 2`:
+    // after the constants either a trailing `,` closes the list, or
+    // members follow after `;`, `,;`, or nothing at all — Groovy's
+    // own parser treats the newline as the separator (GROOVY-7773,
+    // GROOVY-9306), and newlines are extras here, so the member
+    // simply follows the last constant. `A,` directly before a
+    // member is rejected, as in Groovy. With no constants the body
+    // is an ordinary member list.
+    //
+    // An instance initializer (`block`) is accepted wherever the
+    // member list repeats — after `;`, after a first member, or with
+    // no constants — but not directly after a constant. Newlines are
+    // extras, so `A\n{ … }` (in the .g4 a constant, then an
+    // initializer) cannot be told from `A { … }` (a constant with an
+    // anonymous class body, unsupported); both stay errors.
+    //
+    // The three member repeats are spelled out, and must stay
+    // identical to the one in `class_body`, so that the generator
+    // folds all four into one aux symbol (`aux_sym_class_body_repeat1`).
+    // A differing copy, or a hidden rule that is not inlined, adds a
+    // symbol and renumbers every id after it — the alias kinds
+    // `named_argument`, `quoted_identifier` and `type_identifier`
+    // included — which a patch release must not do.
     enum_declaration: $ => seq(
       repeat($.annotation),
+      repeat($._modifier),
       'enum',
       field('name', $.identifier),
       field('body', $.enum_body),
@@ -651,30 +759,77 @@ module.exports = grammar({
 
     enum_body: $ => seq(
       '{',
-      optional(seq(
-        $.enum_constant,
-        repeat(seq(',', $.enum_constant)),
-        optional(','),
-      )),
-      optional(seq(';', repeat(choice($._class_member, ';')))),
+      choice(
+        seq(
+          $.enum_constant,
+          repeat(seq(',', $.enum_constant)),
+          optional(choice(
+            ',',
+            seq(optional(','), ';', repeat(choice($._class_member, $.block, ';'))),
+            seq($._class_member, repeat(choice($._class_member, $.block, ';'))),
+          )),
+        ),
+        repeat(choice($._class_member, $.block, ';')),
+      ),
       '}',
     ),
 
-    enum_constant: $ => seq(
+    // §4 — `prec(1)` makes a bare identifier at the start of the body
+    // a constant rather than the type of the first member: `A\n E() { }`
+    // is a constant followed by a constructor, not a method `E`
+    // returning `A`. The mirror case with no constants, `int f() { }`
+    // as the first thing in the body, therefore reads as constant `int`
+    // plus constructor `f` — a newline is whitespace here and nothing
+    // else tells the two apart; a modifier, `def`, or a leading `;`
+    // makes it a member. Static precedence rather than `prec.dynamic`
+    // with an `[enum_constant, _type]` conflict: both yield the same
+    // tree on every valid shape, but the GLR form silently accepts
+    // `A\n B` (constants missing their comma, which Groovy rejects) as
+    // a field `A B`, where this form reports the ERROR. Annotations
+    // share the prefix with an annotated member; the same precedence
+    // decides after them, so `@Foo A\n int x` is a constant and a
+    // field.
+    enum_constant: $ => prec(1, seq(
+      repeat($.annotation),
       field('name', $.identifier),
       optional(field('arguments', $.argument_list)),
-    ),
+    )),
 
-    // §4 — record (Groovy 4+). `record Name(Type a, Type b) [{ body }]`.
-    // `record` is a contextual keyword — tree-sitter's word: directive
-    // keeps `record` usable as a plain identifier elsewhere.
-    record_declaration: $ => prec.right(seq(
+    // §4 — record (Groovy 4+), after Apache's `classDeclaration`:
+    // `[modifiers] record Name[<T>](Type a, Type b) [implements I] [{ body }]`.
+    // Records cannot `extends`, and the body is optional here where
+    // Groovy requires it.
+    // §5.2 / §6.7 — `record` is a contextual keyword. The keyword
+    // comes from the external scanner, which emits it only when a
+    // name follows on the same line and `(` or `<` after that; in
+    // every other position the word lexes as `identifier`. A grammar literal
+    // cannot do this: keyword extraction yields the keyword wherever
+    // it has an action, which made `record.key()` at statement start,
+    // and `private Record record` once record_declaration became a
+    // class member, errors. The alias keeps the anonymous `record`
+    // node that the queries capture.
+    //
+    // The dynamic precedence settles a GLR tie the scanner creates.
+    // After `private Record`, the `[variable_declarator, _type]`
+    // conflict forks on the next word: `record` is the field's name
+    // in one branch and a type in the other. When a record header
+    // follows on the next line, the first branch lexes its `record`
+    // as the keyword and the second as that field's name, and both
+    // survive (`private Record` / `record record` / constructor
+    // `Inner(int x) { }` is a valid member list). Without a weight,
+    // which tree wins depends on tree shape, and a comment between
+    // the two lines flipped it. Favouring the record declaration is
+    // right whenever both parse.
+    record_declaration: $ => prec.dynamic(1, prec.right(seq(
       repeat($.annotation),
-      'record',
+      repeat($._modifier),
+      alias($._record_keyword, 'record'),
       field('name', $.identifier),
+      optional(field('type_parameters', $.type_parameters)),
       field('components', $.record_components),
+      optional($.super_interfaces),
       optional(field('body', $.class_body)),
-    )),
+    ))),
 
     record_components: $ => seq(
       '(',
@@ -779,16 +934,18 @@ module.exports = grammar({
       optional(field('arguments', $.argument_list)),
     ),
 
-    // §4 — `for (x in xs)`. Untyped variable for v1. Typed
-    // (`for (Type x in xs)`) lands later. The `in` keyword here
-    // is a structural delimiter, not the membership_expression
-    // operator — context disambiguates because the for-header is
-    // not an expression position.
+    // §4 — `for (x in xs)`, plus the Java-compatible enhanced-for
+    // form Groovy accepts side by side: `for (Type x : xs)` / `for
+    // (def x : xs)`. The `in` / `:` keyword here is a structural
+    // delimiter, not the membership_expression operator or a
+    // labelled_statement colon — context disambiguates because the
+    // for-header is not an expression position.
     for_in_statement: $ => seq(
       'for',
       '(',
+      optional(choice('def', field('type', $._type))),
       field('variable', $.identifier),
-      'in',
+      choice('in', ':'),
       field('value', $._expression),
       ')',
       field('body', choice($.block, $._statement)),
@@ -965,17 +1122,48 @@ module.exports = grammar({
       ))));
     },
 
-    // §3.2 / §5.15 — `new Foo(args)`. We only handle the plain
-    // constructor-call form here; array creation `new Foo[10]`,
-    // generic types, and array initialisers land later. PREC.PRIMARY
-    // so it composes with the access tier from the left
-    // (`new Foo().bar`).
+    // §3.2 — `new Foo(args)` and the anonymous inner class
+    // `new Foo(args) { members }`. Array creation `new Foo[10]` and
+    // array initialisers land later. PREC.PRIMARY only labels the
+    // §3.1 tier. The number decides nothing: the rule's one conflict
+    // (below) is against itself, where it cancels out, and
+    // `new Foo().bar` composes without any precedence.
+    //
+    // The optional body takes every `{` that follows the arguments.
+    // Right associativity does that statically — the shift into
+    // `class_body` beats reducing the bodiless form — so no conflict
+    // is declared and the closure reading never forks.
+    //
+    // Apache is narrower. Its `creator` has no `nls` before the body,
+    // so `new T()\n{ … }` is a closure called on the new object
+    // (observed on Groovy 4.0.33). By the same grammar a same-line
+    // `{` whose content cannot be class members should be one too
+    // (`new T() { x -> x }`; not run through the compiler). Here both
+    // are read as a body, usually with an ERROR in it (divergence 11).
+    // Parsing them needs a declared conflict on this rule with
+    // `prec.dynamic` on the body, and that form was not taken: a body
+    // holding one member `class_body` cannot parse, or one still
+    // being typed, would then fall back silently to the closure tree
+    // that #68 reported.
     object_creation_expression: $ => prec.right(PREC.PRIMARY, seq(
       'new',
-      field('type', $._type),
+      field('type', choice($._type, alias($._diamond_type, $.generic_type))),
       field('arguments', $.argument_list),
+      optional(field('body', $.class_body)),
     )),
 
+    // §3.2 — Apache's createdName permits diamond, but ordinary types
+    // (including nested type arguments) do not. Keep the public shape.
+    _diamond_type: $ => prec.right(PREC.ARRAY_TYPE, seq(
+      field('base', choice(
+        alias($.identifier, $.type_identifier),
+        $.qualified_type,
+      )),
+      field('arguments', alias($._diamond_type_arguments, $.type_arguments)),
+    )),
+
+    _diamond_type_arguments: _ => seq(token.immediate('<'), '>'),
+
     // §5.15 — C-style cast `(Foo) x`. Distinct from
     // `parenthesized_expression` followed by something (resolved
     // by tree-sitter's GLR; declared as a conflict if needed).
@@ -1102,7 +1290,7 @@ module.exports = grammar({
     // keywords, or special chars. `map."key with spaces"` and
     // `def "abstract"() { … }` both rely on this.
     _property_name: $ => choice(
-      $.identifier,
+      reserved('property', $.identifier),
       alias($.string_literal, $.quoted_identifier),
     ),
 
@@ -1135,10 +1323,35 @@ module.exports = grammar({
     // expression so subscript / future field_access / future
     // safe_navigation chains compose naturally. PREC.POSTFIX
     // matches subscript so chains like `obj[i](x)[j]` work.
-    method_invocation: $ => prec.left(PREC.POSTFIX, seq(
-      field('function', $._expression),
-      field('arguments', $.argument_list),
-    )),
+    //
+    // Trailing closure (§5.5's command_chain covers the bare-
+    // identifier statement form; this covers the general expression
+    // form used constantly on property-access chains: `list.find {
+    // it > 5 }`, `list.inject(0) { acc, x -> acc + x }`). Groovy
+    // treats a closure literal as the call's last argument whether
+    // or not parens are present, so `argument_list` becomes optional
+    // once a trailing closure is there to anchor the call.
+    //
+    // The args-and-closure alternative sits one precedence level
+    // above plain POSTFIX so `f(x) { … }` reduces to a single
+    // method_invocation node (arguments AND closure fields on the
+    // same node) instead of GLR instead reaching the same span by
+    // nesting a closure-only method_invocation around a plain call.
+    method_invocation: $ => choice(
+      prec.left(PREC.POSTFIX + 1, seq(
+        field('function', $._expression),
+        field('arguments', $.argument_list),
+        field('closure', $.closure),
+      )),
+      prec.left(PREC.POSTFIX, seq(
+        field('function', $._expression),
+        field('arguments', $.argument_list),
+      )),
+      prec.left(PREC.POSTFIX, seq(
+        field('function', $._expression),
+        field('closure', $.closure),
+      )),
+    ),
 
     // §3.2 / §5.11 — argument list. Positional args are `_expression`;
     // named args (Groovy's `k: v` in call position) are `map_entry`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dekobon/tree-sitter-groovy",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Apache Groovy grammar for tree-sitter (dekobon fork)",
   "main": "bindings/node",
   "types": "bindings/node",
@@ -67,10 +67,16 @@
     }
   },
   "devDependencies": {
-    "eslint": "^9.39.4",
+    "eslint": "^10.14.0",
     "eslint-config-treesitter": "^1.0.2",
+    "globals": "^17.14.0",
     "prebuildify": "^6.0.1",
-    "tree-sitter-cli": "^0.26.13"
+    "tree-sitter-cli": "^0.27.2"
+  },
+  "overrides": {
+    "eslint-config-treesitter": {
+      "eslint-plugin-jsdoc": "^62.9.0"
+    }
   },
   "tree-sitter": [
     {