@dekobon/tree-sitter-groovy 0.4.0 → 0.6.0

package/grammar.js

@@ -1,19 +1,24 @@
 /**
  * @file Apache Groovy grammar for tree-sitter
  * @author Elijah Zupancic <elijah@zupancic.name>
- * @license MIT
+ * @license Apache-2.0 OR MIT
  *
  * The authoritative design document for this grammar is
  * 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 the 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
- * See SPECIFICATION.md §6.
+ *   - 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
+ *   - Three decisions that depend on what shares a line: the key of
+ *     a named argument in a parenthesis-free call, a subscript `[`,
+ *     and the `)` of a cast
+ *   - The `!in` operator, which depends on the character after it
+ * Inside a string body it emits nothing. See SPECIFICATION.md §6 and
+ * the `externals` list below.
  */
 
 /// <reference types="tree-sitter-cli/dsl" />
@@ -54,11 +59,50 @@ const PREC = {
 };
 /* eslint-enable no-multi-spaces */
 
+/*
+ * Identifier characters, after GroovyLexer.g4 `JavaLetter` and
+ * `JavaLetterOrDigit`: Java's `Character.isJavaIdentifierStart` and
+ * `isJavaIdentifierPart` without the identifier-ignorable characters.
+ * In Unicode general categories that is L, Nl, Sc and Pc to start a
+ * name, and Nd, Mn and Mc as well to continue it. `$` is in Sc and
+ * `_` is in Pc.
+ */
+const ID_START = String.raw`\p{L}\p{Nl}\p{Sc}\p{Pc}`;
+const ID_PART = ID_START + String.raw`\p{Nd}\p{Mn}\p{Mc}`;
+
+/**
+ * The source of an identifier pattern, in Rust regex syntax.
+ *
+ * The ASCII characters are spelled out and come first, so that the
+ * lexer has a state that loops on them with plain comparisons. The
+ * Unicode classes compile to a binary search over several hundred
+ * ranges; written as one class, every character of every ASCII name
+ * went through that search, which made the lexer about 2.5 times
+ * slower per identifier character.
+ *
+ * @param {boolean} dollar Whether `$` is an identifier character. It
+ *   is not in a GString `$name` path (GroovyLexer.g4
+ *   `IdentifierInGString`).
+ * @returns {string} The pattern source.
+ */
+function identifierPattern(dollar) {
+  const asciiStart = dollar ? 'A-Za-z_$' : 'A-Za-z_';
+  const asciiPart = asciiStart + '0-9';
+  const otherStart = String.raw`[${ID_START}--[\x00-\x7F]]`;
+  const otherPart = String.raw`[${ID_PART}--[\x00-\x7F]]`;
+  const anyPart = `[${asciiPart}${otherPart}]`;
+  return `(?:[${asciiStart}][${asciiPart}]*(?:${otherPart}${anyPart}*)?|${otherStart}${anyPart}*)`;
+}
+
 /**
  * GString body segment choice shared between `"..."` and `"""..."""`.
  * The text rule differs (single-quoted bans newlines, triple-quoted
  * allows them) but every other alternative is identical.
  *
+ * `_string_body` is never emitted. Listing it here makes it valid
+ * wherever a body segment may start, which is how the external scanner
+ * learns that it is inside a string (SPECIFICATION.md §6.10).
+ *
  * @param {GrammarSymbols<string>} $ Grammar reference symbols.
  * @param {RuleOrLiteral} textRule The flavour-specific literal-text rule.
  * @returns {ChoiceRule} The shared body-segment choice.
@@ -69,25 +113,145 @@ function gstringPart($, textRule) {
     $.gstring_dollar_interpolation,
     $.gstring_brace_interpolation,
     alias($._gstring_literal_dollar, $.string_fragment),
+    $._string_body,
+  );
+}
+
+/**
+ * The members of a type body, listed once. `enum_body` repeats the
+ * list for the member directly after a trailing comma, where a plain
+ * constructor is not allowed (see `enum_declaration`), and the two
+ * lists must not drift apart.
+ *
+ * @param {GrammarSymbols<string>} $ Grammar reference symbols.
+ * @param {RuleOrLiteral | null} constructor The constructor rule for
+ *   this position, or null where a constructor cannot appear.
+ * @returns {RuleOrLiteral[]} The member rules, in a fixed order.
+ */
+function classMembers($, constructor) {
+  return [
+    $.method_declaration,
+    $.field_declaration,
+    ...(constructor ? [constructor] : []),
+    $.static_initializer,
+    $.enum_declaration,
+    $.class_declaration,
+    $.interface_declaration,
+    $.trait_declaration,
+    $.record_declaration,
+    $.annotation_type_declaration,
+  ];
+}
+
+/**
+ * A constructor. The enum position directly after a trailing comma
+ * requires an access modifier (see `enum_declaration`); everywhere
+ * else any modifiers are optional.
+ *
+ * @param {GrammarSymbols<string>} $ Grammar reference symbols.
+ * @param {RuleOrLiteral} modifiers The modifier list for this position.
+ * @returns {PrecRightRule} The constructor rule body.
+ */
+function constructorDeclaration($, modifiers) {
+  return prec.right(3, seq(
+    repeat($.annotation),
+    modifiers,
+    field('name', $.identifier),
+    field('parameters', $.formal_parameters),
+    optional($.throws_clause),
+    field('body', $.block),
+  ));
+}
+
+/**
+ * A method parameter or a closure parameter. Apache's `closure` takes
+ * the `formalParameterList` of a method, so the two have one shape:
+ * annotations, `final`, then `def`, `var` or a type (a `varargs_type`
+ * included), the name, and a default value.
+ *
+ * Apache's `variableModifiersOpt` is wider: annotations and modifiers
+ * in any order, `def` or `var` together with a type, and `...` with no
+ * type. Those are not accepted (divergence 14).
+ *
+ * @param {GrammarSymbols<string>} $ Grammar reference symbols.
+ * @returns {ChoiceRule} The parameter rule body.
+ */
+function parameter($) {
+  const defaultValue = optional(seq('=', field('default', $._expression)));
+  return choice(
+    seq(
+      repeat($.annotation),
+      optional('final'),
+      choice(
+        seq(
+          optional(choice('def', 'var', field('type', choice($._type, $.varargs_type)))),
+          field('name', $.identifier),
+        ),
+        // `var` is a contextual keyword and a valid name: `def f(var)`.
+        // With no name after it, it is the name.
+        field('name', alias('var', $.identifier)),
+      ),
+      defaultValue,
+    ),
+    // `_` is a literal directly after an annotation where a statement
+    // can start (see `_placeholder_declarator`), and an annotated
+    // closure parameter starts there too: `{ @A _ -> }`, or with `_`
+    // as the type, `{ @A _ x -> }`. Anywhere else in a parameter `_`
+    // is an ordinary identifier.
+    seq(
+      repeat1($.annotation),
+      choice(
+        field('name', alias('_', $.identifier)),
+        seq(
+          field('type', alias('_', $.type_identifier)),
+          field('name', $.identifier),
+        ),
+      ),
+      defaultValue,
+    ),
   );
 }
 
 module.exports = grammar({
   name: 'groovy',
 
-  // Placeholder for the real implementation. SPECIFICATION.md §3-§7
-  // is the contract this rule set will fulfil.
+  // Keywords are extracted from this token. A keyword is lexed as
+  // such only in a state where it has a parse action, or where it is
+  // reserved (`reserved` below); anywhere else the same text is an
+  // `identifier`. Several comments in this file depend on that.
   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/,
+    // §5.10 — a line escape, `\` at the end of a line. Groovy's lexer
+    // skips it as it skips spaces and tabs.
+    /\\\r?\n/,
     $.line_comment,
     $.block_comment,
     $.groovydoc_comment,
   ],
 
   // Externals listed here must have a matching branch in
-  // `src/scanner.c` AND be referenced by at least one rule below.
+  // `src/scanner.c` AND be referenced by at least one rule below
+  // (`_command_named_key` and `_subscript_open` included). There are
+  // two exceptions. No rule references `_error_sentinel`: it exists so
+  // the scanner can detect error recovery, when tree-sitter marks
+  // every external valid. It is kept last here and in the scanner's
+  // `TokenType` enum, and the two orders must match. The scanner never
+  // emits `_string_body`: a string body references it so that the
+  // scanner can tell it is inside one.
   // Tokens the spec §6 proposes as external scanner branches but
   // that this grammar implements in-grammar (GString interpolation
   // via regex tokens, slashy body via in-grammar `_slashy_text`,
@@ -102,10 +266,40 @@ module.exports = grammar({
     $.line_comment,
     $.block_comment,
     $.groovydoc_comment,
+    $._record_keyword,
+    // §5.5 — empty token before the `name:` key of a named argument in
+    // a parenthesis-free call. Scanner-side so the newline before a Spock
+    // label (`result` then `where:`) is not swallowed, and so
+    // `Type name =` stays a declaration.
+    $._command_named_key,
+    // §5.10 — `[` on the same line as the token before it (spaces, tabs and
+    // line escapes allowed). A `[` after a newline isn't one and can only
+    // start a list or map literal: a statement, not a subscript of the line
+    // above.
+    $._subscript_open,
+    // §6.11 — a `)` with something after it on the same line. A cast
+    // that closes with it outranks a parenthesized expression; a cast
+    // whose operand is on a later line ranks below one, so `x = (a)`
+    // followed by `foo()` is two statements.
+    $._cast_close,
+    // §6.12 — the `!in` operator, which needs whitespace or an opening
+    // bracket after it. The scanner reads that character and leaves it.
+    $._not_in,
+    // §6.10 — never emitted: valid only between the quotes of a string
+    // whose body is lexed in pieces. Comments are extras, so the parser
+    // offers them there too; the scanner must emit nothing, or `//` and
+    // `/*` at a piece boundary become comments.
+    $._string_body,
+    // Never referenced by a rule: valid only during error recovery, when
+    // the scanner must not emit context-sensitive tokens.
+    $._error_sentinel,
   ],
 
   conflicts: $ => [
-    // See SPECIFICATION.md §7. Populated as rules accumulate.
+    // `final def x` / `final x = 1` in a block vs. a modified member at top level.
+    [$._modifier, $.local_variable_declaration],
+    // This array is the authoritative list; SPECIFICATION.md §7 is
+    // the list predicted before the grammar existed.
     // (list_literal vs map_literal — tree-sitter resolves without
     //  an explicit conflict because `:` after the first element
     //  always disambiguates within one token of lookahead.)
@@ -164,6 +358,39 @@ module.exports = grammar({
     // tree-sitter report it unnecessary. Regenerate without it to
     // confirm that still holds.
     [$.formal_parameter, $._expression],
+    // §4 — after an enum's trailing comma, `private` may open a
+    // constructor (`private E() { }`) or any other member.
+    [$._modifier, $._modified_constructor_declaration],
+    // §5.8 — a closure's parameter list and a closure body that opens
+    // with a declaration share their first tokens, and so does a
+    // block, whose `{` may also open a closure. The `->` decides, or
+    // the first token that only one reading accepts.
+    //
+    // `{ final x -> }` vs. a body opening with a final local (#56) or
+    // with a modified declaration; all three stay alive at `final`.
+    [$._modifier, $.local_variable_declaration, $.closure_parameter],
+    // `{ String a = 'x', b -> }` vs. `{ String a = 'x', b = 'y' }`, and
+    // `{ def a, b -> }` vs. `{ def a, b }`. These two fork at every
+    // `,` of a declaration that opens a closure or block, and both
+    // stacks run to the end of the list: 15% to 60% more work for a
+    // list of two to eight names, about twice for a long one. A list
+    // of one name does not fork.
+    [$._initialized_declarator, $.closure_parameter],
+    [$.variable_declarator, $.closure_parameter],
+    // `{ @A _ x -> }`, a parameter of type `_`, vs. `{ @A _` as the
+    // declaration of the placeholder followed by a statement `x`.
+    [$._placeholder_declarator, $.closure_parameter],
+    // An untyped default, `{ a = 1 -> }` vs. `{ a = 1 }`, needs no
+    // entry: see `expression_statement`.
+    //
+    // Two things keep these forks from changing a valid parse, and a
+    // new rule must keep both. `closure_parameter` carries no dynamic
+    // precedence, so a reading that survives to the `->` wins by being
+    // the only one left. And `->` appears nowhere at the top level of
+    // a closure body: only in `closure_parameters` and in the arrow
+    // forms of `switch`. On invalid input the parameter reading can
+    // win, because a missing `->` is a cheaper repair than an ERROR:
+    // `{ x = 1, y }` recovers as two parameters.
   ],
 
   rules: {
@@ -198,6 +425,7 @@ module.exports = grammar({
       $.assert_statement,
       $.yield_statement,
       $.try_statement,
+      $.synchronized_statement,
       $.class_declaration,
       $.trait_declaration,
       $.interface_declaration,
@@ -217,18 +445,51 @@ module.exports = grammar({
     // §5.5 — command_chain is the parenthesis-free method-call
     // form (`println 'hello'`, `events 'a', 'b', 'c'`). v1 is
     // intentionally conservative: receiver is a bare identifier
-    // and arguments are restricted to literal-shaped expressions
-    // and closures (no risk of mis-parsing `foo bar` as a command
-    // call on a bare identifier). Multi-argument lists are supported
-    // (comma-separated literal arguments per Gradle / Jenkins DSL
-    // idioms). Chained `foo bar baz` and complex argument shapes
-    // land later. Closes a subset of murtaza64 #5.
+    // and the first argument is restricted to literal-shaped
+    // expressions, closures and named arguments (no risk of
+    // mis-parsing `foo bar` as a command call on a bare identifier).
+    // After a comma an argument is a named argument or any
+    // expression: Apache's `argumentListElement` without spread
+    // arguments (`foo 'a', *args` is an ERROR). Chained
+    // `foo bar baz` lands later. Closes a subset of murtaza64 #5.
     command_chain: $ => prec(2, seq(
       field('receiver', $.identifier),
-      field('argument', $._command_argument),
-      repeat(seq(',', field('argument', $._command_argument))),
+      field('argument', choice($._command_argument, alias($._command_named_argument, $.named_argument))),
+      repeat(seq(',', field('argument', choice(
+        alias($._command_named_argument, $.named_argument),
+        alias($._command_continued_named_argument, $.named_argument),
+        $._expression,
+      )))),
     )),
 
+    // §5.5 item 3 — named arguments in a parenthesis-free call:
+    // `exclude group: 'a', module: 'b'`, `archiveArtifacts artifacts: 'x'`,
+    // GORM's `name blank: false, size: 1..100`. `_command_named_key`
+    // is an empty token that the external scanner emits before a name
+    // only when `:` follows it on the same line, so `Type name = …` and
+    // a bare statement followed by a Spock label on the next line are
+    // unaffected. The name itself is an ordinary `identifier`. A
+    // keyword is a valid key (Apache `namedArgLabel`): it has no
+    // action after the empty token, so it lexes as an identifier, and
+    // the empty `property` set does the same for the reserved `new`.
+    _command_named_argument: $ => seq(
+      $._command_named_key,
+      field('key', reserved('property', $.identifier)),
+      ':',
+      field('value', $._expression),
+    ),
+
+    // After a comma a newline cannot end the statement, so a key on a
+    // continuation line (`sh script: 'make',` then `returnStdout: true`)
+    // needs no scanner token. Same-line keys normally come from the
+    // scanner; `case` and `default`, which the scanner rejects, reach
+    // this rule on the same line too (`foo 'a', default: 1`).
+    _command_continued_named_argument: $ => seq(
+      field('key', $.identifier),
+      ':',
+      field('value', $._expression),
+    ),
+
     _command_argument: $ => choice(
       $.string_literal,
       $.number_literal,
@@ -243,17 +504,18 @@ module.exports = grammar({
     // labeled_statement and expression_statement alive after
     // `identifier`; the `:` decides. A scanner-token form
     // (`_label_colon`) was attempted but interacted with
-    // not-yet-implemented named-argument command chains
-    // (`archiveArtifacts artifacts: 'x'`); see divergence #5.
+    // named-argument command chains (`archiveArtifacts artifacts: 'x'`),
+    // which now have their key decided by `_command_named_key`
+    // instead; see the §6.5 row in `docs/divergences-from-spec.md`.
     labeled_statement: $ => prec(1, seq(
       field('label', $.identifier),
       ':',
       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(
@@ -370,8 +632,7 @@ module.exports = grammar({
     // §4 — try / catch / finally. At least one of catch/finally is
     // required per Java/Groovy semantics; the grammar relaxes that
     // to allow a bare `try { … }` and lets downstream tooling
-    // surface the error if needed. Try-with-resources lands later
-    // with local variable declarations.
+    // surface the error if needed.
     try_statement: $ => seq(
       'try',
       optional(field('resources', $.resource_specification)),
@@ -380,6 +641,16 @@ module.exports = grammar({
       optional($.finally_clause),
     ),
 
+    // §4 — `synchronized (lock) { … }` (Apache `#synchronizedStmtAlt`).
+    // The body must be a block.
+    synchronized_statement: $ => seq(
+      'synchronized',
+      '(',
+      field('lock', $._expression),
+      ')',
+      field('body', $.block),
+    ),
+
     // §4 — `try (Foo f = expr; Bar b = expr) { … }`. Resources
     // are typed or `def`-style declarators with required `=`
     // initializer (per Java-style try-with-resources). Multiple
@@ -393,8 +664,15 @@ module.exports = grammar({
     ),
 
     resource: $ => seq(
-      optional(field('type', $._type)),
-      field('name', $.identifier),
+      optional('final'),
+      choice(
+        seq(
+          optional(choice('def', 'var', field('type', $._type))),
+          field('name', $.identifier),
+        ),
+        // `var` alone is the name: `try (var = open())`.
+        field('name', alias('var', $.identifier)),
+      ),
       '=',
       field('value', $._expression),
     ),
@@ -412,8 +690,15 @@ module.exports = grammar({
     // murtaza64 #39. The type itself is optional — Groovy allows a
     // bare `catch (e) { … }`, implicitly typed as Exception.
     catch_formal_parameter: $ => seq(
-      optional(field('type', choice($._type, $.multi_type))),
-      field('name', $.identifier),
+      optional('final'),
+      choice(
+        seq(
+          optional(choice('def', 'var', field('type', choice($._type, $.multi_type)))),
+          field('name', $.identifier),
+        ),
+        // `var` alone is the name: `catch (var)`.
+        field('name', alias('var', $.identifier)),
+      ),
     ),
 
     multi_type: $ => seq(
@@ -455,6 +740,7 @@ module.exports = grammar({
       field('name', $.identifier),
       optional(field('type_parameters', $.type_parameters)),
       optional($.extends_interfaces),
+      optional($.super_interfaces),
       optional($.permits_clause),
       field('body', $.class_body),
     ),
@@ -501,17 +787,17 @@ module.exports = grammar({
       repeat(seq(',', $._type)),
     ),
 
-    // §4 — trait / interface extend multiple interfaces (no
-    // `implements` keyword in that position).
+    // §4 — trait / interface list their super-interfaces with `extends`.
     extends_interfaces: $ => seq(
       'extends',
       $._type,
       repeat(seq(',', $._type)),
     ),
 
-    // §4 — Java-style modifiers. Each one is a hard reserved
-    // keyword (§5.2) so the `word: $.identifier` directive keeps
-    // them from accidentally being treated as identifiers.
+    // §4 — Java-style modifiers. Each one is a hard reserved keyword
+    // in Groovy (§5.2). Here it is a keyword only where a modifier can
+    // stand; anywhere else the word lexes as an identifier, and input
+    // such as `foo(private)` parses with no ERROR (#93).
     _modifier: _ => choice(
       'public',
       'private',
@@ -545,30 +831,46 @@ 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 four 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, ';')),
       '}',
     ),
 
-    // A nested enum (`static enum EventType { … }` inside a domain
-    // class) is common enough in real Groovy that leaving it out
-    // silently misparses `enum` as a field_declaration's type name.
-    // Nested class/interface/trait land separately (bigger surface,
-    // own conflict set) — out of scope here.
-    _class_member: $ => choice(
-      $.method_declaration,
-      $.field_declaration,
-      $.constructor_declaration,
-      $.static_initializer,
-      $.enum_declaration,
-    ),
+    // 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(...classMembers($, $.constructor_declaration)),
 
     // §4 — constructors share the method_declaration shape but have
     // no return type and the name matches the enclosing class. We
@@ -577,13 +879,16 @@ module.exports = grammar({
     // tell constructors apart from methods. `prec(3, …)` wins over
     // both field and method when the identifier is followed by `(`
     // and no return type precedes it.
-    constructor_declaration: $ => prec.right(3, seq(
-      repeat($.annotation),
-      repeat($._modifier),
-      field('name', $.identifier),
-      field('parameters', $.formal_parameters),
-      optional($.throws_clause),
-      field('body', $.block),
+    constructor_declaration: $ => constructorDeclaration($, repeat($._modifier)),
+
+    // The constructor form for the member directly after an enum's
+    // trailing comma (see `enum_declaration`). Only access modifiers
+    // qualify: `static f() { }` there is a method. The weight is above
+    // a method with a body, which matches the same text through its
+    // modifier-only form.
+    _modified_constructor_declaration: $ => prec.dynamic(4, constructorDeclaration(
+      $,
+      repeat1(choice('public', 'private', 'protected')),
     )),
 
     // §4 — `static { … }` class-body initializer block. Runs once
@@ -607,38 +912,74 @@ module.exports = grammar({
     // 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(
+      // splitting `private final int v\n C() {}` after `int`. The
+      // weight is above a method body's: the split reading holds a
+      // method (`v C() {}`), which would otherwise tie.
+      prec.dynamic(4, seq(
         repeat($.annotation),
         repeat($._modifier),
         choice('def', field('type', $._type)),
         $.variable_declarator,
         repeat(seq(',', $.variable_declarator)),
       )),
-      seq(
+      // The negative weight settles the split that the typed weight
+      // cannot. `private final int v` followed by `public A() { }` is
+      // also `private final int`, a field `v public` and a constructor
+      // `A() { }`: a keyword is an identifier wherever it has no
+      // action. Both readings hold one typed field, so they tied, and
+      // a comment between the two members made the split win.
+      prec.dynamic(-1, seq(
         repeat($.annotation),
         repeat1($._modifier),
         $.variable_declarator,
         repeat(seq(',', $.variable_declarator)),
-      ),
+      )),
     ),
 
-    // §4 — `def name(params) body`. Typed return type (`String foo()
-    // { … }`) lands once we can disambiguate from local variable
-    // declaration. Modifiers and throws clause similarly defer.
-    // prec(1) wins over local_variable_declaration when `(` follows
-    // the name, so `def f() { … }` at script-top-level parses as a
-    // method rather than a `def f` variable followed by `(…) { … }`.
-    method_declaration: $ => prec.right(2, seq(
-      repeat($.annotation),
-      repeat($._modifier),
-      optional(field('type_parameters', $.method_type_parameters)),
-      choice('def', field('return_type', $._type)),
-      field('name', $._property_name),
-      field('parameters', $.formal_parameters),
-      optional($.throws_clause),
-      optional(field('body', $.block)),
-    )),
+    // §4 — `def name(params) body`, or a return type in place of
+    // `def`, with modifiers and a throws clause. The static precedence
+    // wins over local_variable_declaration when `(` follows the name,
+    // so `def f() { … }` at script-top-level parses as a method
+    // rather than a `def f` variable followed by `(…) { … }`.
+    // Modifiers alone (no `def`, no return type) also introduce a
+    // method outside a class body: `final f() { }`. In a class body
+    // that shape stays a constructor_declaration.
+    //
+    // A method with a body carries a dynamic precedence because its
+    // tokens also parse as statements: `String f() { }` as the
+    // expression `String` followed by the call `f() { }`, and
+    // `def f(a) { }` as a variable `f` followed by the cast
+    // `(a) { }`. Without a weight, a comment before the method made
+    // the split win. The weight is above the blank final local's
+    // (`final Type name`, see local_variable_declaration):
+    // `final String f(a) { }` is also that local followed by the cast
+    // `(a) { }`.
+    //
+    // A method without a body carries a negative one. Its tokens are
+    // also `x` followed by the call `foo()`, and outside a class body
+    // only that reading is valid Groovy: a script method needs a
+    // body. In a class body nothing competes, so abstract and
+    // interface methods are unaffected.
+    method_declaration: $ => {
+      const signature = seq(
+        repeat($.annotation),
+        choice(
+          seq(
+            repeat($._modifier),
+            optional(field('type_parameters', $.method_type_parameters)),
+            choice('def', field('return_type', $._type)),
+          ),
+          repeat1($._modifier),
+        ),
+        field('name', $._property_name),
+        field('parameters', $.formal_parameters),
+        optional($.throws_clause),
+      );
+      return prec.right(2, choice(
+        prec.dynamic(-1, signature),
+        prec.dynamic(3, seq(signature, field('body', $.block))),
+      ));
+    },
 
     // §4 / §5.14 — method-level generic type parameters
     // (`<T> T identity(T x) { x }`). Distinct from `type_parameters`
@@ -672,13 +1013,11 @@ module.exports = grammar({
     // `@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))),
-    ),
+    // (`name = expr`). `final` is the only modifier accepted here.
+    // `def` and `var` stand in place of the type and are keywords, so
+    // `def f(def a)` has no `type`. The shape is `parameter()`, shared
+    // with `closure_parameter`.
+    formal_parameter: $ => parameter($),
 
     varargs_type: $ => seq($._type, '...'),
 
@@ -691,17 +1030,51 @@ module.exports = grammar({
     // 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. The member list is spelled three
-    // times rather than shared with `class_body` through a hidden
-    // rule: a new rule renumbers the aux symbols and ~100 symbol ids,
-    // which a patch release must not do.
+    // simply follows the last constant. With no constants the body
+    // is an ordinary member list.
+    //
+    // Groovy up to 4.x also accepts a member directly after a trailing
+    // `,` (`A, B,\n private int x`): GroovyParser.g4 on those branches
+    // has `enumConstants (nls COMMA)? sep?` before the member list.
+    // Groovy 5 requires a `;`. Without this alternative the modifier
+    // had no action after the `,`, lexed as an identifier, and became
+    // a constant named `private` with no ERROR.
+    //
+    // The alternative is narrower than Groovy, which takes any member
+    // there (divergence 13). `prec(1)` on `enum_constant` keeps a bare
+    // identifier after the `,` a constant, so the member has to start
+    // with something that cannot be one: a modifier, `def`, a
+    // declaration keyword, or an annotation followed by one of those.
+    // `A,\n String x` is an ERROR, and so is an instance initializer.
+    // A constructor needs an access modifier. `B(x) { … }` after a
+    // `,`, with or without annotations, reads as a constant with an
+    // anonymous class body (unsupported, so an ERROR). With an access
+    // modifier it cannot be a constant, and with no constructor form
+    // here `private B(x) { }` parsed, with no ERROR, as a method named
+    // `B`: the modifier-only form of `method_declaration` took it.
+    // Other modifiers do not make a constructor, so `static f() { }`
+    // is a method.
+    //
+    // 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 four member repeats are spelled out, and must stay
+    // identical to the one in `class_body`, so that the generator
+    // folds all five 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),
+      optional($.super_interfaces),
       field('body', $.enum_body),
     ),
 
@@ -713,11 +1086,19 @@ module.exports = grammar({
           repeat(seq(',', $.enum_constant)),
           optional(choice(
             ',',
-            seq(optional(','), ';', repeat(choice($._class_member, ';'))),
-            seq($._class_member, repeat(choice($._class_member, ';'))),
+            seq(optional(','), ';', repeat(choice($._class_member, $.block, ';'))),
+            seq($._class_member, repeat(choice($._class_member, $.block, ';'))),
+            seq(
+              ',',
+              choice(...classMembers(
+                $,
+                alias($._modified_constructor_declaration, $.constructor_declaration),
+              )),
+              repeat(choice($._class_member, $.block, ';')),
+            ),
           )),
         ),
-        repeat(choice($._class_member, ';')),
+        repeat(choice($._class_member, $.block, ';')),
       ),
       '}',
     ),
@@ -733,22 +1114,63 @@ module.exports = grammar({
     // 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.
-    enum_constant: $ => prec(1, seq(
-      field('name', $.identifier),
-      optional(field('arguments', $.argument_list)),
-    )),
+    // 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: $ => choice(
+      prec(1, seq(
+        repeat($.annotation),
+        field('name', $.identifier),
+        optional(field('arguments', $.argument_list)),
+      )),
+      // `sealed` and `trait` are keywords wherever a member can start
+      // (divergence 12): at the first constant and, since #89, after
+      // every `,`. A constant may still have either name, so the
+      // keyword is accepted as one. The negative precedence gives way
+      // to a declaration when one follows: `sealed class`, `trait T {`.
+      prec(-1, seq(
+        repeat($.annotation),
+        field('name', alias(choice('sealed', 'trait'), $.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(
       '(',
@@ -767,6 +1189,7 @@ module.exports = grammar({
     // §4 — package and import. Trailing `;` is optional in Groovy;
     // we accept both forms by not requiring it.
     package_declaration: $ => seq(
+      repeat($.annotation),
       'package',
       field('name', $.qualified_name),
     ),
@@ -777,6 +1200,7 @@ module.exports = grammar({
     // imports only appear in this position, so the lexer-wide
     // longest-match is safe.
     import_declaration: $ => seq(
+      repeat($.annotation),
       'import',
       optional('static'),
       field('name', $.qualified_name),
@@ -795,19 +1219,80 @@ module.exports = grammar({
     // would conflict with method_invocation `Type(x)` and is
     // disallowed in v1. Multiple declarators per statement
     // (`def a = 1, b = 2`) are supported in all three forms.
+    // `final` is the only modifier accepted here.
+    // `final x = 1` with no type or `def` is the modifier-only form;
+    // the variable is dynamically typed, as with `def`. `final` also
+    // allows the typed form without an initializer (`final String
+    // name`, a blank final), with a single declarator.
+    //
+    // The typed forms carry a dynamic precedence because their tokens
+    // also parse another way: `String s = 'a'` as the expression
+    // `String` followed by `s = 'a'`, and `final String s = 'a'` as
+    // the modifier-only `final String` followed by `s = 'a'`. Without
+    // a weight, which tree wins depends on tree shape, and a comment
+    // before the declaration flipped it. The blank form ranks above
+    // the initialized one, or `final String name` followed by
+    // `name = 'a'` would tie with `final String` followed by
+    // `name name = 'a'`.
+    //
+    // Newlines do not end a declaration, so these read wrongly with
+    // no ERROR node:
+    // - `final x` followed by a line that starts with an identifier
+    //   reads `x` as the type and that identifier as the name. `y = 2`
+    //   becomes `final x y = 2`, the same resolution modifier-only
+    //   fields get (`static x` then `y = 1`), and `String s = 'a'`
+    //   becomes `final x String` followed by `s = 'a'`.
+    // - `final String name` followed by a line reading `foo() { }` is
+    //   `final String` followed by the method `name foo() { }`. A
+    //   method with a body outranks the blank form, so that
+    //   `final String f(a) { }` stays a method (see method_declaration).
+    // - A bare `x` followed by a line reading `y = 1` is the typed
+    //   declaration `x y = 1`.
+    //
+    // Annotations may come first on every form (Apache
+    // `variableModifier`): `@Field def x = 1` in a script,
+    // `@SuppressWarnings('unchecked') List<String> xs = []` in a body.
     local_variable_declaration: $ => prec.right(choice(
       seq(
+        repeat($.annotation),
+        optional('final'),
         choice('def', 'var'),
         $.variable_declarator,
         repeat(seq(',', $.variable_declarator)),
       ),
-      seq(
+      prec.dynamic(1, seq(
+        repeat($.annotation),
+        optional('final'),
         field('type', $._type),
         $._initialized_declarator,
         repeat(seq(',', $._initialized_declarator)),
+      )),
+      seq(
+        repeat($.annotation),
+        'final',
+        $.variable_declarator,
+        repeat(seq(',', $.variable_declarator)),
       ),
+      prec.dynamic(2, seq(
+        repeat($.annotation),
+        'final',
+        field('type', $._type),
+        field('name', $.identifier),
+      )),
+      prec.dynamic(2, seq(
+        repeat1($.annotation),
+        alias($._placeholder_declarator, $.variable_declarator),
+      )),
     )),
 
+    // `@Library('shared') _`, the Jenkins idiom: an annotation needs a
+    // declaration to stand on, and `_` is the name used for it. Apache
+    // takes any name there (`variableModifiers variableDeclarators`).
+    // Only `_` is accepted here, as a literal: with any identifier,
+    // `@A x` followed by `y = 1` on the next line would also be a typed
+    // local `x y = 1`, and nothing but the line break tells them apart.
+    _placeholder_declarator: $ => field('name', alias('_', $.identifier)),
+
     _initialized_declarator: $ => seq(
       field('name', $.identifier),
       '=',
@@ -862,6 +1347,7 @@ module.exports = grammar({
     for_in_statement: $ => seq(
       'for',
       '(',
+      optional('final'),
       optional(choice('def', field('type', $._type))),
       field('variable', $.identifier),
       choice('in', ':'),
@@ -870,7 +1356,29 @@ module.exports = grammar({
       field('body', choice($.block, $._statement)),
     ),
 
-    expression_statement: $ => $._expression,
+    // A statement that is `name = value` keeps the name unreduced.
+    // A closure can open with the same tokens as a parameter with a
+    // default (`{ a = 1 -> a }`), and so can an `if` / `while` / `for`
+    // block, because its `{` may also open a closure. With `name`
+    // already reduced to an expression, the two readings needed a
+    // fork that ran to the end of the value: 14% to 32% more work for
+    // `ext { version = '1.0' }` or `if (c) { a = 1 }`, and twice the
+    // work for a long value. Here both readings shift the `=` and one
+    // stack parses the value; the token after it decides.
+    //
+    // The form is limited to the start of a statement. Inside an
+    // expression it would take `b = 1` out of `a + b = 1`, which the
+    // operator precedence reads as `(a + b) = 1`.
+    expression_statement: $ => choice(
+      $._expression,
+      alias($._statement_assignment, $.assignment_expression),
+    ),
+
+    _statement_assignment: $ => prec.right(PREC.ASSIGN, seq(
+      field('left', $.identifier),
+      field('operator', '='),
+      field('right', $._expression),
+    )),
 
     // §3.2 PRIMARY — minimal alternative set for now. Every primary
     // expression form from §3.2 / §5 will land in this choice over
@@ -1001,21 +1509,18 @@ module.exports = grammar({
       optional($._dotted_type_tail),
     )),
 
-    // §3.2 — `x in xs` and `x !in xs`. RELATIONAL level. Both
+    // §3.2 / §3.2.2 — `x in xs` and `x !in xs`. RELATIONAL level. Both
     // operators share one node kind; the `operator` field
-    // distinguishes them. `!in` is wrapped in `token(prec(1, …))`
-    // so it lexes as a single token despite the embedded space
-    // requirement implied by §3.2.2's trailing-context rule —
-    // Apache's `NOT_IN` predicate is approximated by requiring at
-    // least one trailing whitespace, `[`, `(`, or `{` after `!in`.
-    // §3.2 / §3.2.2 — `x in xs` and `x !in xs`. `!in` is a single
-    // token whose match requires a trailing whitespace / bracket
-    // character (Apache `NOT_IN` predicate) so `a !inXs` does not
-    // mis-tokenise as `!in` followed by `Xs`.
+    // distinguishes them. `!in` is an operator only before whitespace
+    // or `[`, `(`, `{` (Apache's `NOT_IN` predicate), so that
+    // `a !inXs` is not `!in` followed by `Xs`. The external scanner
+    // makes that check (§6.12) and leaves the character where it is.
+    // As a regex the token had to include it, which made
+    // `a !in[1, 2]` an ERROR: the `[` was part of the operator.
     membership_expression: $ => {
       const ops = [
         'in',
-        token(prec(1, seq('!in', /[ \t\r\n\[({]/))),
+        alias($._not_in, '!in'),
       ];
       return choice(...ops.map(op => prec.left(PREC.RELATIONAL, seq(
         field('element', $._expression),
@@ -1041,15 +1546,34 @@ 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', 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
@@ -1069,12 +1593,47 @@ module.exports = grammar({
     // by tree-sitter's GLR; declared as a conflict if needed).
     // PREC.UNARY right-associative so `(Foo) -x` parses as
     // `(Foo)(-x)` and the type binds to the rightward expression.
-    parenthesized_type_cast: $ => prec.right(PREC.UNARY, seq(
-      '(',
-      field('type', $._type),
-      ')',
-      field('value', $._expression),
-    )),
+    //
+    // Two weights rank the cast against the other reading of the same
+    // tokens, a parenthesized expression followed by something. Both
+    // follow Apache's `castParExpression castOperandExpression`.
+    //
+    // With the operand on the line of the `)`, the cast wins wherever
+    // it parses, as the cast alternative comes first in Apache's
+    // `expression`: `(a) + b`, `(a) [0]` and `(a) (b)` are casts.
+    // `_cast_close` (§6.11) is the `)` that has something after it on
+    // its line.
+    //
+    // With the operand on a later line, the cast loses to any other
+    // complete reading. Apache's rule has no `nls` between the two
+    // parts, so where a line break can end a statement, `x = (a)`
+    // followed by `foo()` is two statements. Inside `(…)` and `[…]`
+    // Groovy ignores line breaks and reads a cast. Rejecting the cast
+    // outright would lose every such case: the scanner cannot tell
+    // which brackets enclose it. Ranking it last keeps the ones where
+    // nothing else parses, `foo((String)` followed by `x)`. It loses
+    // the ones where the later line can also continue the expression:
+    // `foo((a)` followed by `- b)` is a subtraction here and a cast
+    // in Groovy (divergence 15, #99).
+    //
+    // Without the weights nothing ranked the two readings and the
+    // stack order decided. Inside a closure or block, `a = (int) y`
+    // followed by a line that starts with a literal lost the cast
+    // once #83 added its forks.
+    parenthesized_type_cast: $ => choice(
+      prec.dynamic(1, prec.right(PREC.UNARY, seq(
+        '(',
+        field('type', $._type),
+        alias($._cast_close, ')'),
+        field('value', $._expression),
+      ))),
+      prec.dynamic(-1, prec.right(PREC.UNARY, seq(
+        '(',
+        field('type', $._type),
+        ')',
+        field('value', $._expression),
+      ))),
+    ),
 
     // §4 — `_type`. Supports unqualified type identifiers,
     // qualified types (`java.util.List`), array types
@@ -1101,7 +1660,7 @@ module.exports = grammar({
       repeat1(seq('.', alias($.identifier, $.type_identifier))),
     )),
 
-    array_type: $ => prec(PREC.ARRAY_TYPE, seq($._type, '[', ']')),
+    array_type: $ => prec(PREC.ARRAY_TYPE, seq($._type, alias($._subscript_open, '['), ']')),
 
     // §4 / §5.14 — Java-style generic type arguments. Allows nested
     // generics (`Map<String, List<Integer>>`) and bounded wildcards
@@ -1190,7 +1749,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),
     ),
 
@@ -1256,7 +1815,7 @@ module.exports = grammar({
     // §3.2 / §5.11 — argument list. Positional args are `_expression`;
     // named args (Groovy's `k: v` in call position) are `map_entry`
     // aliased to `named_argument` so downstream tools can tell them
-    // apart from positional values. Spread (`*expr`) lands later.
+    // apart from positional values.
     argument_list: $ => seq(
       '(',
       optional(seq(
@@ -1285,9 +1844,12 @@ module.exports = grammar({
     // explicit ask of dekobon #247 for the `?[]` row. Both at
     // PREC.POSTFIX, left-associative — `a[b][c]` parses as
     // `(a[b])[c]`.
+    // `[` must be on the object's line (see `_subscript_open`): a Grails
+    // controller action that ends in `[model: value]` on its own line returns
+    // a map; it isn't a subscript of the statement before it.
     subscript_expression: $ => prec.left(PREC.POSTFIX, seq(
       field('object', $._expression),
-      '[',
+      alias($._subscript_open, '['),
       field('index', $._expression),
       ']',
     )),
@@ -1295,6 +1857,9 @@ module.exports = grammar({
     // `?[` is one token. `a ? [b] : c` (with space) still parses
     // as ternary plus list because tree-sitter's lexer never
     // crosses a whitespace boundary to extend a multi-char token.
+    // Unlike `[` (see `_subscript_open`), `?[` may still follow a
+    // newline: no statement starts with `?[`, so there is nothing
+    // to split off.
     safe_subscript_expression: $ => prec.left(PREC.POSTFIX, seq(
       field('object', $._expression),
       '?[',
@@ -1448,7 +2013,7 @@ module.exports = grammar({
         ['%',   PREC.MULTIPLICATIVE],
         // SHIFT — §3.1 level 6. Ranges (`..`, `..<`, etc.) share
         // this precedence level but use distinct node kinds, so
-        // they live in their own rule (lands later).
+        // they live in their own rule.
         ['<<',  PREC.SHIFT_OR_RANGE],
         ['>>',  PREC.SHIFT_OR_RANGE],
         ['>>>', PREC.SHIFT_OR_RANGE],
@@ -1486,7 +2051,12 @@ module.exports = grammar({
     // form; `{ a, b -> body }` has identifier parameters;
     // `{ String a, int b -> body }` has typed parameters; `{ body }`
     // has no `->` and an implicit `it` parameter (we do NOT emit a
-    // synthetic `it` per §5.8). Default values and varargs land later.
+    // synthetic `it` per §5.8). A parameter takes what a method
+    // parameter does (Apache's closure uses `formalParameterList`):
+    // annotations, `final`, then `def`, `var` or a type (varargs
+    // included), and a default; both rules are `parameter()`. The
+    // body may open with the same words, so the `->` decides between
+    // the two readings.
     closure: $ => seq(
       '{',
       optional($.closure_parameters),
@@ -1502,18 +2072,18 @@ module.exports = grammar({
       '->',
     ),
 
-    closure_parameter: $ => seq(
-      optional(field('type', $._type)),
-      field('name', $.identifier),
-    ),
+    closure_parameter: $ => parameter($),
 
     // §3.2 PRIMARY / §5.13 — list literal with trailing-comma support.
     // Empty list is `[]`; the empty map literal is the distinct `[:]`
-    // form (see map_literal). Tree-sitter splits the parse between
-    // list_literal and map_literal until a `:` or `]` disambiguates;
-    // the conflict declaration above keeps both alternatives alive.
+    // form (see map_literal). After the first element, a `:` or its
+    // absence tells a list from a map within one token of lookahead,
+    // so no conflict entry is needed.
+    // Either `[` token opens a literal, so a same-line `[` resolves as
+    // it did with one token: `if (a) { } [1].each { }` is still a block
+    // followed by a list, not a subscripted closure.
     list_literal: $ => seq(
-      '[',
+      choice('[', alias($._subscript_open, '[')),
       optional(seq(
         $._expression,
         repeat(seq(',', $._expression)),
@@ -1531,7 +2101,7 @@ module.exports = grammar({
     map_literal: $ => {
       const entry = choice($.map_entry, $.spread_map_entry);
       return seq(
-        '[',
+        choice('[', alias($._subscript_open, '[')),
         choice(
           ':',
           seq(
@@ -1560,9 +2130,15 @@ module.exports = grammar({
     ),
 
     // §3.2 PRIMARY — `( expr )`. Distinct from `parenthesized_type_cast`
-    // (§5.15), which lands once we have `_type`. The parser disambiguates
-    // by what's inside the parens.
-    parenthesized_expression: $ => seq('(', $._expression, ')'),
+    // (§5.15); the parser disambiguates by what's inside the parens
+    // and after them. `_cast_close` is the `)` that has something
+    // after it on its line (§6.11). It closes this rule too, so that
+    // `(a) * b` and `((a))` stay open to both readings.
+    parenthesized_expression: $ => seq(
+      '(',
+      $._expression,
+      choice(')', alias($._cast_close, ')')),
+    ),
 
     // §3.2 — single `unary_expression` node kind but two precedence
     // alternatives, matching Apache §3.1:
@@ -1673,17 +2249,27 @@ module.exports = grammar({
 
     // §5.7 — triple-double GString. Like `_double_quoted_string`
     // but newlines and embedded `"` / `""` are part of the body.
+    //
+    // One or two quotes are text when an ordinary character or an
+    // escape follows them. Before `$` they are lexed one at a time, as
+    // fragments of their own: the text token must not take a `$` that
+    // starts an interpolation (`"""say "$name"""`), and a regex
+    // cannot look ahead. The closer is longer than one quote, so it
+    // still wins at `"""`.
     _triple_double_quoted_string: $ => seq(
       '"""',
-      repeat(gstringPart($, $._triple_gstring_text)),
+      repeat(choice(
+        gstringPart($, $._triple_gstring_text),
+        alias(token.immediate('"'), $.string_fragment),
+      )),
       token.immediate('"""'),
     ),
 
     _triple_gstring_text: _ => token.immediate(repeat1(choice(
       /[^"\\$]/,
       /\\[\s\S]/,
-      /"[^"]/,
-      /""[^"]/,
+      /"(\\[\s\S]|[^"\\$])/,
+      /""(\\[\s\S]|[^"\\$])/,
     ))),
 
     // §5.7 — `$identifier(.identifier)*` interpolation. The whole
@@ -1697,9 +2283,9 @@ module.exports = grammar({
       )),
     ),
 
-    _gstring_dollar_path: _ => token.immediate(
-      /\$[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*/,
-    ),
+    _gstring_dollar_path: _ => token.immediate(new RustRegex(
+      String.raw`\$${identifierPattern(false)}(?:\.${identifierPattern(false)})*`,
+    )),
 
     // §5.7 / §6.3 — `${expression}` interpolation.
     gstring_brace_interpolation: $ => seq(
@@ -1715,15 +2301,25 @@ module.exports = grammar({
     // `$$` (literal `$`), `$/` (literal `/`), and any other
     // non-`/` non-`$` char. The closer `/$` is `token.immediate`
     // so it always wins over text when `/` is followed by `$`.
+    //
+    // A run of slashes is text only up to an ordinary character
+    // (`a//b`). The text token must not take a `/` that the closer
+    // needs, and a regex cannot look ahead, so the slashes of a run
+    // that ends at `$` are lexed one at a time: for `//$` the single
+    // `/` matches first, then `/$` is the longer match and closes
+    // the string. Each such slash is its own `string_fragment`.
     _dollar_slashy_string: $ => seq(
       '$/',
-      repeat(gstringPart($, $._dollar_slashy_text)),
+      repeat(choice(
+        gstringPart($, $._dollar_slashy_text),
+        alias(token.immediate('/'), $.string_fragment),
+      )),
       token.immediate('/$'),
     ),
 
     _dollar_slashy_text: _ => token.immediate(repeat1(choice(
       /[^/$]/,
-      /\/[^$]/,
+      /\/+[^/$]/,
       /\$\$/,
       /\$\//,
     ))),
@@ -1741,6 +2337,8 @@ module.exports = grammar({
       /[0-9][0-9_]*[GgLlIiDdFf]?/,
     )),
 
-    identifier: _ => /[A-Za-z_$][A-Za-z0-9_$]*/,
+    // Groovy's lexer takes any Java letter, not only ASCII; see
+    // `identifierPattern` above for the classes.
+    identifier: _ => new RustRegex(identifierPattern(true)),
   },
 });