@willbooster/tree-sitter-kotlin 1.6.1 → 1.6.3

package/README.md

@@ -98,15 +98,21 @@ cargo test
   `script/known-failures.txt`. The first run clones them. The example repositories are pinned to commits in
   `script/parse-examples`. After a grammar change or a moved pin alters that list, `script/parse-examples` rewrites
   it; review its diff before committing;
-- a performance check (`test/unit/performance.test.ts`) that recovering from an error on each of 10,000 lines takes
-  linear time, since consumers parse files while they are being edited. It loads the Wasm build through
-  @willbooster/web-tree-sitter, which `bun run build/ci` rebuilds after regenerating the parser;
+- a performance check (`test/unit/performance.test.ts`) that recovering from an error on each line takes linear time
+  (ten times the lines take about ten times the CPU time, under a ceiling), since consumers parse files while they are being edited.
+  It loads the Wasm build through @willbooster/web-tree-sitter, which `bun run build/ci` rebuilds after regenerating
+  the parser;
+- a check that comments containing NUL characters parse (`test/unit/nulCharacters.test.ts`);
+- a check that `package.json` and `Cargo.lock` test the same runtime version (`test/unit/runtimeVersion.test.ts`);
 - checks that the Wasm build parses Kotlin through @willbooster/web-tree-sitter in Chromium
-  (`test/unit/browser.test.ts`) and in Cloudflare Workers with and without
-  Node.js compatibility (`test/unit/workers.test.ts`).
+  (`test/unit/browser.test.ts`) and in Cloudflare Workers with and without Node.js compatibility
+  (`test/unit/workers.test.ts`).
 
-CI also runs these tests on Linux arm64 and macOS, where the Rust binding compiles the parser natively, and fuzzes the parser with libFuzzer and sanitizers
-(`.github/workflows/robustness.yml`).
+The tests and `script/parse-examples` compile the parser into `.tmp/tree-sitter-lib` rather than the CLI's cache shared
+by every checkout.
+
+CI also runs these tests on Linux arm64 and macOS, where the Rust binding compiles the parser natively, and fuzzes the
+parser with libFuzzer and sanitizers (`.github/workflows/robustness.yml`).
 
 ### References
 

package/grammar.js

@@ -16,7 +16,6 @@ const PREC = {
   AS: 12,
   CALL: 13,
   UNARY: 14,
-  DELEGATION: 15,
 };
 
 // oxlint-disable-next-line unicorn/prefer-module -- This package is CommonJS, so tree-sitter loads grammar.js as CommonJS.
@@ -108,6 +107,10 @@ module.exports = grammar({
     'val',
     // never scanned: it tells the scanner where a primary constructor may start
     $._primary_constructor_position,
+    // empty: it ends a delegation expression in a class header before `{` (see `explicit_delegation`)
+    $._delegation_end,
+    // the `)` that ends a call's arguments (see `value_arguments`)
+    $._arguments_end,
   ],
 
   inline: ($) => [$._statements, $._identifier, $._control_structure_body],
@@ -309,9 +312,9 @@ module.exports = grammar({
 
     property_delegate: ($) => seq('by', $.expression),
 
-    // Above PREC.CALL so that, as in Kotlin, a `{` after the delegation expression starts the class body instead of a
-    // trailing lambda. The last operand of an operator expression still takes the lambda (#29).
-    explicit_delegation: ($) => prec(PREC.DELEGATION, seq($.type, 'by', $.expression)),
+    // As in Kotlin, a `{` after the delegation expression starts the class body, never a trailing lambda, also after the
+    // last operand of an operator (`B by a ?: b { … }`): the scanner ends the expression before it.
+    explicit_delegation: ($) => seq($.type, 'by', $.expression, optional($._delegation_end)),
 
     getter: ($) =>
       prec.right(
@@ -410,7 +413,7 @@ module.exports = grammar({
         optional($.class_body)
       ),
 
-    value_arguments: ($) => seq('(', optionalCommaSep1($.value_argument), ')'),
+    value_arguments: ($) => valueArguments($, '('),
 
     value_argument: ($) => seq(optional(seq($._identifier, '=')), optional('*'), $.expression),
 
@@ -474,7 +477,15 @@ module.exports = grammar({
     use_site_target: () =>
       seq(choice('field', 'property', 'get', 'set', 'receiver', 'param', 'setparam', 'delegate'), ':'),
 
-    _unescaped_annotation: ($) => choice($.constructor_invocation, $.type),
+    // As in Kotlin, a `(` right after an annotation's name always starts its arguments; lexing it as a separate immediate
+    // token keeps an annotated parenthesized expression from being read there. After whitespace, Kotlin's reading
+    // depends on the context, so both readings remain.
+    _unescaped_annotation: ($) =>
+      choice($.constructor_invocation, alias($._annotation_invocation, $.constructor_invocation), $.type),
+
+    _annotation_invocation: ($) => seq($.type, alias($._annotation_arguments, $.value_arguments)),
+
+    _annotation_arguments: ($) => valueArguments($, alias(token.immediate('('), '(')),
 
     type: ($) =>
       choice($.user_type, $.nullable_type, $.function_type, $.non_nullable_type, $.parenthesized_type, 'dynamic'),
@@ -636,8 +647,10 @@ module.exports = grammar({
 
     infix_expression: ($) => prec.left(PREC.INFIX, seq($.expression, $.identifier, $.expression)),
 
+    // Right-associative so that a trailing lambda after arguments belongs to the same call (`f(x) { … }`), as in
+    // Kotlin, instead of calling the result of `f(x)`.
     call_expression: ($) =>
-      prec.left(
+      prec.right(
         PREC.CALL,
         seq(
           $.expression,
@@ -664,7 +677,7 @@ module.exports = grammar({
           $.function_value_parameters,
           optional(seq(':', $.type)),
           optional($.type_constraints),
-          optional($.function_body)
+          $.function_body
         )
       ),
 
@@ -956,3 +969,17 @@ function commaSep1(rule) {
 function optionalCommaSep1(rule) {
   return optional(seq(rule, repeat(seq(',', rule)), optional(',')));
 }
+
+/**
+ * Creates the arguments of a call or an annotation. Whether a call takes a trailing lambda depends on the token after
+ * its arguments, which the lookahead of the scanned `)` reaches, so an edit there makes incremental parsing reparse the
+ * call instead of reusing a call without the lambda.
+ *
+ * @param {GrammarSymbols<string>} $
+ * @param {RuleOrLiteral} open
+ *
+ * @returns {SeqRule}
+ */
+function valueArguments($, open) {
+  return seq(open, optionalCommaSep1($.value_argument), alias($._arguments_end, ')'));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@willbooster/tree-sitter-kotlin",
-  "version": "1.6.1",
+  "version": "1.6.3",
   "description": "Kotlin grammar for tree-sitter",
   "keywords": [
     "incremental",
@@ -45,7 +45,7 @@
     "@willbooster/oxfmt-config": "1.2.2",
     "@willbooster/oxlint-config": "1.4.8",
     "@willbooster/wb": "22.13.1",
-    "@willbooster/web-tree-sitter": "1.0.7",
+    "@willbooster/web-tree-sitter": "1.0.8",
     "conventional-changelog-conventionalcommits": "10.4.0",
     "lefthook": "2.1.14",
     "oxfmt": "0.70.0",

package/tree-sitter.json

@@ -13,7 +13,7 @@
     }
   ],
   "metadata": {
-    "version": "1.6.1",
+    "version": "1.6.3",
     "license": "MIT",
     "description": "Kotlin grammar for tree-sitter",
     "authors": [