@dekobon/tree-sitter-groovy 0.4.0 → 0.6.0

package/README.md

@@ -166,6 +166,48 @@ 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 named `sealed` or `trait` is an `ERROR` when it
+  follows a modifier (`private boolean sealed`) or opens the member
+  (`static trait = 1`). `boolean sealed` and `String trait`, with no
+  modifier, parse, and so does an enum constant with either name
+  (`enum E { trait, sealed }`).
+  `record` is not affected: it is a keyword only directly before a
+  record header (`record Name(`), so `private Record record` and
+  `record.key()` parse.
+- **A member after an enum's trailing comma must start with a
+  modifier, `def` or a keyword** -- Groovy up to 4.x takes any member
+  there. `A,` followed by `String x` or by `E() { }` is an `ERROR`
+  (#97).
+- **Parameter modifiers have one order** -- annotations, then `final`,
+  then `def`, `var` or a type. `def String x`, `final @A x` and a
+  varargs parameter with no type (`... xs`) are an `ERROR` (#98).
+- **A line break does not end a statement** -- a newline is whitespace
+  to the grammar. Most code is unaffected, because the next token
+  cannot continue the statement. Known cases that read wrongly with no
+  `ERROR`: a bare name followed by a literal on the next line is one
+  parenthesis-free call (#90); a field with a modifier and no type
+  followed by a typed method is a typed field and a constructor (#96);
+  and inside brackets, `(a)` followed by a line that starts with `-`,
+  `+` or `(` is not the cast Groovy reads (#99).
+- **A method with modifiers and no return type is a constructor** --
+  `static f() { }` in a class body is a `constructor_declaration`,
+  and `abstract m()` is an `ERROR` (#91).
+- **Annotations come before modifiers** -- `private @Autowired Foo
+  foo` and `public @interface X { }` are an `ERROR` (#92).
 
 ## Contributing