tree-sitter-bynk 0.447.0 → 0.504.3

package/grammar.js

@@ -39,7 +39,7 @@ const PREC = {
 module.exports = grammar({
   name: "bynk",
 
-  externals: ($) => [$.doc_block, $.doc_line],
+  externals: ($) => [$.doc_block, $.doc_line, $.raw_string, $._type_app_open, $._error_sentinel],
 
   extras: ($) => [/\s+/, $.doc_line, $.line_comment, $.doc_block],
 
@@ -48,6 +48,10 @@ module.exports = grammar({
   word: ($) => $.identifier,
 
   conflicts: ($) => [
+    // #2654: `let (T { … })` is a parenthesised pattern either way; only the
+    // end of the statement (an `else` or none) says whether the record
+    // pattern stood alone.
+    [$._pattern, $._let_paren_record_pattern],
     // `match e { … }` / `if e { … }`: after a bare identifier `e`,
     // the `{` is ambiguous between opening the match/if body and opening a
     // record construction/spread `e { … }`. Keep all parses alive; the body
@@ -58,6 +62,10 @@ module.exports = grammar({
     // parenthesised expression (and `()` the unit literal) until the
     // closing `)` is followed — or not — by `=>`.
     [$.lambda_param, $._primary],
+    // #2712: `(T { f, …` opens a record construction or a record-pattern lambda
+    // parameter; the pattern's mandatory `..` (never an expression) settles it.
+    [$.field_init, $._lambda_record_field],
+    [$._primary, $._lambda_field_binding],
     [$._primary, $.lambda_expr],
     // v0.145: a match-arm `if`-guard is an `_expression` immediately followed by
     // the arm's `=>`. When the guard opens with `(`, one token can't tell a unit
@@ -208,6 +216,7 @@ module.exports = grammar({
         $.event_decl,
         $.asset_decl,
         $.embed_decl,
+        $.const_decl,
       ),
 
     _context_body_item: ($) =>
@@ -226,6 +235,7 @@ module.exports = grammar({
         $.event_decl,
         $.asset_decl,
         $.embed_decl,
+        $.const_decl,
         $.removed_agent_decl,
       ),
 
@@ -251,6 +261,7 @@ module.exports = grammar({
         $.event_decl,
         $.asset_decl,
         $.embed_decl,
+        $.const_decl,
       ),
 
     _test_body_item: ($) =>
@@ -259,6 +270,8 @@ module.exports = grammar({
         $.consumes_decl,
         $.env_clause,
         $.stub_clause,
+        $.fixture_decl,
+        $.fn_decl,
         $.case,
         $.property_decl,
       ),
@@ -324,17 +337,49 @@ module.exports = grammar({
         "}",
       ),
 
+    // -- Type parameters and bounds (constrained generics slice 0) --
+
+    // `T` or `T: Eq + C`. The constraint names are validated by the checker.
+    type_param: ($) =>
+      seq(
+        field("name", $.identifier),
+        optional(seq(":", sep1($.constraint, "+"))),
+      ),
+
+    constraint: ($) => $.identifier,
+
+    where_clause: ($) => seq("where", sep1($.where_bound, ",")),
+
+    where_bound: ($) =>
+      seq(
+        field("param", $.identifier),
+        ":",
+        sep1($.constraint, "+"),
+      ),
+
     // -- Type declarations --
 
+    // #2618: `private` before a `fn`, `type`, `messages`, `asset`, `embed` or
+    // `const` declaration makes it unit-private. The word is contextual: with
+    // `word` set to `identifier`, it lexes as a keyword only where a
+    // declaration may start, so `@cache(scope: private)` and a binding named
+    // `private` keep parsing as identifiers. Placement (a commons or context, never an
+    // adapter) is the compiler's call (`bynk.visibility.private_not_allowed`).
+    visibility_modifier: ($) => "private",
+
     type_decl: ($) =>
       seq(
+        optional(field("visibility", $.visibility_modifier)),
         "type",
         field("name", $.identifier),
         // v0.157 (ADR 0183): optional `[A, B]` type parameters — only a record
         // body may be generic (enforced by the checker, not the grammar).
-        optional(seq("[", sep1(field("type_param", $.identifier), ","), "]")),
+        optional(seq("[", sep1(field("type_param", $.type_param), ","), "]")),
         "=",
         field("body", $._type_body),
+        // Constrained generics slice 1: a trailing `derives Ord` clause, `+`
+        // separated like a bound list. `derives` is a contextual word.
+        optional(seq("derives", sep1(field("derive", $.constraint), "+"))),
       ),
 
     _type_body: ($) =>
@@ -404,6 +449,7 @@ module.exports = grammar({
     // (`bynk.asset.outside_context_or_commons` rejects it in an adapter).
     asset_decl: ($) =>
       seq(
+        optional(field("visibility", $.visibility_modifier)),
         "asset",
         field("name", $.identifier),
         "=",
@@ -419,12 +465,41 @@ module.exports = grammar({
     // rejects it in an adapter).
     embed_decl: ($) =>
       seq(
+        optional(field("visibility", $.visibility_modifier)),
         "embed",
         field("name", $.identifier),
         "=",
         field("path", $.string_literal),
       ),
 
+    // #2841: `fixture name = "fixtures/…"` in a suite body — a project file's
+    // text as a `String` constant for the suite's cases. Contextual `fixture`.
+    fixture_decl: ($) =>
+      seq(
+        "fixture",
+        field("name", $.identifier),
+        "=",
+        field("path", $.string_literal),
+      ),
+
+    // #2617 (named constants): `const Name: Type = <static expression>` — a
+    // named value. Admitted in every body like `embed`; placement
+    // (`bynk.resolve.const_outside_context_or_commons`), the name's case
+    // (`bynk.resolve.const_name_case`, upper-camel like `constant_name`) and
+    // the initialiser's static-ness are checker concerns. The name is an
+    // `identifier` because `word` unifies every word-shaped lexeme to it.
+    // A leading `private` makes it unit-private, as on `embed`.
+    const_decl: ($) =>
+      seq(
+        optional(field("visibility", $.visibility_modifier)),
+        "const",
+        field("name", $.identifier),
+        ":",
+        field("type", $._type_ref),
+        "=",
+        field("value", $._expression),
+      ),
+
     // v0.154 (ADR 0178): a sum body may carry a trailing `embeds E as V, …`
     // clause declaring error embeddings the `?` operator auto-converts.
     // `embeds`/`as` are contextual — matched only in this position.
@@ -498,6 +573,7 @@ module.exports = grammar({
         "NonNegative",
         "Positive",
         "NonEmpty",
+        "IsoDate",
       ),
     // v0.21/v0.142 (ADR 0166): a refinement-bound number may be negated —
     // `InRange(-1_000, 1_000_000)` — mirroring `parse_signed_num_literal`'s
@@ -507,12 +583,22 @@ module.exports = grammar({
       choice(
         seq(optional("-"), $.number_literal),
         seq(optional("-"), $.float_literal),
+        seq(optional("-"), $.decimal_literal),
         $.string_literal,
       ),
 
     _base_type: ($) => $.base_type,
     base_type: () =>
-      choice("Int", "String", "Bool", "Float", "Duration", "Instant", "Bytes"),
+      choice(
+        "Int",
+        "String",
+        "Bool",
+        "Float",
+        "Duration",
+        "Instant",
+        "Bytes",
+        "Decimal",
+      ),
 
     _type_ref: ($) =>
       choice(
@@ -617,15 +703,21 @@ module.exports = grammar({
 
     fn_decl: ($) =>
       seq(
+        optional(field("visibility", $.visibility_modifier)),
         "fn",
         field("name", choice($.method_name, $.identifier)),
         // v0.20a: optional `[A, B]` type parameters (functions only).
-        optional(seq("[", sep1(field("type_param", $.identifier), ","), "]")),
+        optional(seq("[", sep1(field("type_param", $.type_param), ","), "]")),
         "(",
         optional($._params),
         ")",
         "->",
         field("return_type", $._type_ref),
+        // #2868: a context function's capabilities, after the return type.
+        optional(field("given", $.given_clause)),
+        // Constrained generics slice 0: a method's `where A: Eq` clause bounds
+        // a receiver type's parameter.
+        optional($.where_clause),
         // v0.115: contract clauses between the return type and the body.
         repeat($.requires_clause),
         repeat($.ensures_clause),
@@ -681,7 +773,7 @@ module.exports = grammar({
         // #926: optional `[T, …]` type parameters on the op itself — resolved
         // only from an explicit type argument at the call site (mirroring
         // `fn_decl`'s own `[A, B]` slot, `grammar.js:525`).
-        optional(seq("[", sep1(field("type_param", $.identifier), ","), "]")),
+        optional(seq("[", sep1(field("type_param", $.type_param), ","), "]")),
         "(",
         optional(sep1($.param, ",")),
         optional(","),
@@ -701,6 +793,7 @@ module.exports = grammar({
     // mirroring `service_decl`/`agent_decl`'s existing permissive placement.
     messages_decl: ($) =>
       seq(
+        optional(field("visibility", $.visibility_modifier)),
         "messages",
         field("tag", $.string_literal),
         repeat(field("annotation", $.store_annotation)),
@@ -763,6 +856,9 @@ module.exports = grammar({
         // v0.142 (ADR 0166): the optional `limits { }` policy, likewise a
         // header-position `from http` concern restricted by the checker.
         optional(field("limits", $.limits_policy)),
+        // #2858: the optional `json { }` policy, likewise a header-position
+        // `from http` concern restricted by the checker.
+        optional(field("json", $.json_policy)),
         // v0.140 (ADR 0163): a handler may carry one or more `@name(args)`
         // annotations (`@cache(maxAge: 5.minutes)`, `@limit(maxBody: …)`) —
         // the same shape `store_annotation` already gives store fields.
@@ -805,6 +901,18 @@ module.exports = grammar({
       ),
     limits_field: ($) =>
       seq(field("name", $.identifier), ":", field("value", $._expression)),
+    // #2858: `json { <name>: <value>, … }`. `json` is a contextual keyword (like
+    // `limits`); the one field name, `options`, is an ordinary identifier matched
+    // by the checker.
+    json_policy: ($) =>
+      seq(
+        "json",
+        "{",
+        repeat(seq($.json_field, optional(","))),
+        "}",
+      ),
+    json_field: ($) =>
+      seq(field("name", $.identifier), ":", field("value", $._expression)),
     // v0.44: `from <protocol>` on the service header.
     // v0.103: `from websocket(in: I, out: O)` binds the inbound/outbound frame
     // types. `websocket`, `in`, and `out` are contextual (resolved by `word`).
@@ -865,14 +973,21 @@ module.exports = grammar({
     // than nested inside it. Nested inside the `Events` choice arm, not a
     // free-standing clause any protocol could carry — `via` on `http`/
     // `cron`/`queue`/`websocket` is a syntax error, not a checker
-    // diagnostic. Literal only (v1 of this clause); a range pattern
-    // (`via schema(2..)`) is unbuilt grammar, left to a future slice.
+    // diagnostic. A literal, an integer range (`via schema(2..)`, #990 —
+    // the same `int_range` a match pattern uses, #2699) or `_`.
     schema_dispatch_clause: ($) =>
       seq(
         "via",
         "schema",
         "(",
-        field("version", seq(optional("-"), $.number_literal)),
+        field(
+          "version",
+          choice(
+            $.int_range,
+            seq(optional("-"), $.number_literal),
+            $.wildcard_pattern,
+          ),
+        ),
         ")",
       ),
     event_pattern_field: ($) =>
@@ -1239,8 +1354,9 @@ module.exports = grammar({
     // v0.118 (testing track slice 6): a test-scope stub for one capability
     // operation — `stub Cap.op(<arg pattern>, …) <rhs>`. Only admitted inside a
     // suite/case body. An arg pattern is `_` (any) or a value expression; the
-    // right-hand side is `returns <expr>`, `returns each [ <outcome>, … ]` (a
-    // scripted sequence, where an outcome is `fails` or an expr), or `fails`.
+    // right-hand side is `returns <expr> [after <expr>]`, `returns each [ <outcome>, … ]`
+    // (a scripted sequence, where an outcome is `fails` or an expr), `fails`, or
+    // `never`.
     // `returns`/`each`/`fails` are contextual words. Keyword `stub` since the
     // keyword-hygiene batch (#548); formerly a pun on `provides`.
     stub_clause: ($) =>
@@ -1270,8 +1386,16 @@ module.exports = grammar({
             ),
             "]",
           ),
-          seq("returns", field("value", $._expression)),
+          // #2683: `returns <v> after <d>` completes on the test clock once
+          // `d` has passed; `never` does not complete. `after` and `never` are
+          // contextual words.
+          seq(
+            "returns",
+            field("value", $._expression),
+            optional(seq("after", field("after", $._expression))),
+          ),
           "fails",
+          "never",
         ),
       ),
     // #2134: a suite- or case-scoped `env { NAME = "value" … }` clause — the
@@ -1343,6 +1467,7 @@ module.exports = grammar({
         $.do_stmt,
         $.assign_stmt,
         $.advance_stmt,
+        $.par_stmt,
         prec(1, $.expect_expr),
       ),
 
@@ -1374,28 +1499,50 @@ module.exports = grammar({
     // lenient (a bare-name `variant_pattern` is admitted) because the compiler,
     // not the highlighter, reports `bynk.parse.let_else_on_binding`.
     let_else_stmt: ($) =>
-      seq(
-        "let",
-        field("pattern", choice($._let_pattern, alias($._let_or_pattern, $.or_pattern))),
-        field("bind", choice("=", "<-")),
-        field("value", $._expression),
-        optional(field("principal", $.call_site_actor)),
-        "else",
-        field("else", choice($.block, $.let_else_match)),
+      choice(
+        seq(
+          "let",
+          field("pattern", choice($._let_pattern, alias($._let_or_pattern, $.or_pattern))),
+          field("bind", choice("=", "<-")),
+          field("value", $._expression),
+          optional(field("principal", $.call_site_actor)),
+          "else",
+          field("else", choice($.block, $.let_else_match)),
+        ),
+        // #2654 (patterns track, slice 2): `let Item { sku, .. } = item` — the
+        // `else` is optional when the pattern is a record pattern (the compiler further
+        // requires it to be irrefutable, `let_pattern_without_else`; whether a
+        // field's sub-pattern is a binding or a variant is a matter of
+        // capitalisation, which this grammar cannot see). Parentheses around
+        // the pattern are transparent.
+        seq(
+          "let",
+          field("pattern", choice($.record_pattern, alias($._let_paren_record_pattern, $.paren_pattern))),
+          field("bind", choice("=", "<-")),
+          field("value", $._expression),
+          optional(field("principal", $.call_site_actor)),
+          optional(seq("else", field("else", choice($.block, $.let_else_match)))),
+        ),
       ),
+    _let_paren_record_pattern: ($) => seq("(", $.record_pattern, ")"),
     // #2010: the patterns that may open a `let … else`, mirroring the Rust
     // parser's `let_pattern_ahead`: a literal, a parenthesised pattern, or a
     // variant with a payload or a qualifier. A bare name stays a binding (and
     // a bare `_` a discard), so `let x = …` is never ambiguous here.
     _let_pattern: ($) =>
       choice(
+        $.int_range,
         $.literal_pattern,
         $.paren_pattern,
+        $.list_pattern,
         alias($._let_variant_pattern, $.variant_pattern),
       ),
     // `let Ok(x) | Err(x) = …`: an or-chain whose first alternative opens a
     // pattern; the rest are any patterns.
-    _let_or_pattern: ($) => prec.left(1, seq($._let_pattern, "|", $._pattern)),
+    // #2654: a record pattern may open the chain too (`let Item { .. } | …`),
+    // though on its own it is the `else`-less alternative of `let_else_stmt`.
+    _let_or_pattern: ($) =>
+      prec.left(1, seq(choice($._let_pattern, $.record_pattern), "|", $._pattern)),
     _let_variant_pattern: ($) => {
       const payload = seq("(", optional(sep1($._pattern_binding, ",")), optional(","), ")");
       return prec.right(
@@ -1456,6 +1603,28 @@ module.exports = grammar({
         field("amount", $._expression),
       ),
 
+    // #2640 (concurrent effects, slice 0): `par { let a <- e1  let b <- e2 }` —
+    // issue every effect, then wait for them all. `par` is contextual: it opens
+    // a statement only before `{`. The grammar stays permissive about the
+    // block's contents (any statement parses); the compiler admits only
+    // `let x <- e` and `do e` (`bynk.par.invalid_statement`).
+    par_stmt: ($) => seq("par", "{", repeat($._par_statement), "}"),
+
+    // Any statement but `let … else`, which would take the rest of the block as
+    // its arm and so has no room inside a `par` (the compiler's parser refuses
+    // it with `bynk.par.invalid_statement`).
+    _par_statement: ($) =>
+      choice(
+        $.let_stmt,
+        $.effect_let_stmt,
+        $.effect_send_stmt,
+        $.do_stmt,
+        $.assign_stmt,
+        $.advance_stmt,
+        $.par_stmt,
+        prec(1, $.expect_expr),
+      ),
+
     // A let/effect-let may bind the discard name `_`.
     _binding_name: ($) => choice($.identifier, alias("_", $.wildcard)),
 
@@ -1482,7 +1651,10 @@ module.exports = grammar({
         PREC.expect,
         seq(
           "expect",
-          field("cond", choice($.observation_expr, $.faults_expr, $._expression)),
+          field(
+            "cond",
+            choice($.observation_expr, $.faults_expr, $.snapshot_expr, $._expression),
+          ),
         ),
       ),
 
@@ -1499,6 +1671,18 @@ module.exports = grammar({
         "faults",
       ),
 
+    // #2842: a snapshot claim — `expect <value> matches snapshot "<name>"`
+    // compares the value's canonical JSON with a stored snapshot. `matches` and
+    // `snapshot` are contextual, as `faults` is: an expression is never followed
+    // by a bare identifier, so the words alone decide.
+    snapshot_expr: ($) =>
+      seq(
+        field("value", $._expression),
+        "matches",
+        "snapshot",
+        field("name", $.string_literal),
+      ),
+
     // v0.117: an observation — a `Cap.op` seam reference followed by one of the
     // sugar matchers. `called` / `never` / `once` / `times` / `with` / `before`
     // are contextual (state-lexed as keywords only here; ordinary identifiers
@@ -1601,11 +1785,62 @@ module.exports = grammar({
     _pattern: ($) =>
       choice(
         $.wildcard_pattern,
+        $.int_range,
         $.literal_pattern,
         $.variant_pattern,
+        $.record_pattern,
+        $.list_pattern,
         $.or_pattern,
         $.paren_pattern,
       ),
+    // #2641 (patterns track, slice 1): `Order { status: Paid, total, .. }`. Always
+    // open, with the trailing `..` mandatory so that adding a field to the record
+    // never breaks a pattern — the rule `event_pattern` already applies to
+    // events. A field is a bare name (binding it to a local of the same name) or
+    // `name: pattern`. After `is` a record pattern must be parenthesised (see
+    // `_is_pattern`), because there the `{` would also open the `if`'s block.
+    record_pattern: ($) =>
+      seq(
+        field("type", $.identifier),
+        "{",
+        repeat(seq($.record_pattern_field, ",")),
+        "..",
+        "}",
+      ),
+    // #2680 (patterns track, slice 4): `[]`, `[p, …]`, `[p, …, ..]`,
+    // `[p, …, ..rest]`. The rest marker is last and at most once; `..` takes a
+    // name or nothing (a literal after it is reserved for range patterns, and
+    // the compiler reports it). It needs no parentheses after `is`, where the
+    // pattern closes at `]`.
+    list_pattern: ($) =>
+      seq(
+        "[",
+        repeat(seq($._pattern, ",")),
+        optional(choice($._pattern, seq($.list_rest, optional(",")))),
+        "]",
+      ),
+    list_rest: ($) => seq("..", optional(field("name", $.identifier))),
+    record_pattern_field: ($) =>
+      choice(
+        seq(field("name", $.identifier), ":", field("pattern", $._pattern)),
+        field("name", $.identifier),
+      ),
+    // #2641: the patterns an `is` accepts without parentheses — `_pattern`
+    // without a record pattern at its tail, at the top level or as an
+    // or-alternative. Parenthesised, a record pattern is allowed anywhere (the
+    // hand-written parser's `is_pattern_tail` restriction).
+    _is_base_pattern: ($) =>
+      choice(
+        $.wildcard_pattern,
+        $.literal_pattern,
+        $.variant_pattern,
+        $.list_pattern,
+        $.paren_pattern,
+      ),
+    _is_pattern: ($) =>
+      choice($._is_base_pattern, alias($._is_or_pattern, $.or_pattern)),
+    _is_or_pattern: ($) =>
+      prec.left(1, seq($._is_pattern, "|", $._is_base_pattern)),
     // #474 §2.3.4: `p₁ | p₂ | … | pₙ` — an or-pattern, left-associative;
     // matches if any alternative matches. `|` is a pattern-position operator
     // only — not a valid expression operator, and lexically distinct from
@@ -1621,6 +1856,29 @@ module.exports = grammar({
     // never nested, parenthesized, or one alternative of an outer `|`-chain).
     paren_pattern: ($) => seq("(", $._pattern, ")"),
     wildcard_pattern: () => "_",
+    // #2699 (patterns track, slice 5; events slice 4b, #990): an inclusive
+    // integer range — `lo..hi`, `lo..` or `..hi`, each bound an optionally
+    // negative `Int` literal. One production shared by match patterns and
+    // `via schema(...)`. A bare `..` is never a range (it is `list_rest`), and
+    // `0..9` lexes as `number_literal ".." number_literal` since a float needs
+    // a digit on both sides of its `.`.
+    int_range: ($) => {
+      // Spelled out in each position (not a shared rule), so the parser does
+      // not have to reduce a bound before it can tell a range from a literal.
+      const bound = seq(optional("-"), $.number_literal);
+      return choice(
+        // Right-associative: after `x is 5..` a `-` is the high bound's sign
+        // (the hand-written parser reads it greedily), never a subtraction.
+        prec.right(
+          seq(
+            field("lo", bound),
+            "..",
+            optional(field("hi", bound)),
+          ),
+        ),
+        seq("..", field("hi", bound)),
+      );
+    },
     // v0.130 §2.3.4: a literal pattern — an integer (optionally negated), a
     // string, or a boolean. A closed set (ADR 0001); no `Float`, no `()`.
     literal_pattern: ($) =>
@@ -1666,7 +1924,7 @@ module.exports = grammar({
     is_expr: ($) =>
       prec.left(
         PREC.is,
-        seq(field("value", $._expression), "is", field("pattern", $._pattern)),
+        seq(field("value", $._expression), "is", field("pattern", $._is_pattern)),
       ),
 
     binary_expr: ($) =>
@@ -1709,6 +1967,7 @@ module.exports = grammar({
         $.block,
         $.number_literal,
         $.float_literal,
+        $.decimal_literal,
         $.string_literal,
         $.boolean_literal,
         $.unit_literal,
@@ -1717,7 +1976,7 @@ module.exports = grammar({
         $._contextual_identifier,
       ),
 
-    // `trace` and `advance` are contextual in the compiler — ordinary
+    // `trace`, `advance` and `par` are contextual in the compiler — ordinary
     // identifiers outside `trace(Cap.op)` / `advance Clock by …`. Here, as
     // `word`-shaped literals, they are extracted as keyword tokens, and where an
     // identifier and the keyword are both valid (an expression or statement
@@ -1725,7 +1984,8 @@ module.exports = grammar({
     // `identifier` in exactly those positions. The next tokens decide: `advance`
     // followed by an identifier can only open an `advance_stmt`, and `trace (`
     // is a declared conflict that `trace_expr`'s dynamic precedence settles.
-    _contextual_identifier: ($) => alias(choice("trace", "advance"), $.identifier),
+    _contextual_identifier: ($) =>
+      alias(choice("trace", "advance", "par"), $.identifier),
 
     // v0.20a: a lambda — `(params) => expr | block`. Conflicts with
     // paren_expr/unit_literal until the `=>` disambiguates (GLR conflict
@@ -1739,11 +1999,44 @@ module.exports = grammar({
         field("body", choice($._expression, $.block)),
       ),
 
+    // #2712 (patterns track, slice 6): a parameter is a name with an optional
+    // annotation, or an unannotated record pattern whose fields are bindings.
     lambda_param: ($) =>
+      choice(
+        seq(
+          field("name", choice($.identifier, $._contextual_identifier)),
+          optional(seq(":", field("type", $._type_ref))),
+        ),
+        field("pattern", alias($._lambda_record_pattern, $.record_pattern)),
+      ),
+    // The irrefutable subset a lambda parameter admits: each field is a bare
+    // name, `name: binding`, `name: _`, or a nested such pattern. (A bare
+    // capitalised name is a variant, a refutable pattern the compiler reports.)
+    _lambda_record_pattern: ($) =>
       seq(
-        field("name", choice($.identifier, $._contextual_identifier)),
-        optional(seq(":", field("type", $._type_ref))),
+        field("type", $.identifier),
+        "{",
+        repeat(seq(alias($._lambda_record_field, $.record_pattern_field), ",")),
+        "..",
+        "}",
       ),
+    _lambda_record_field: ($) =>
+      choice(
+        seq(
+          field("name", $.identifier),
+          ":",
+          field(
+            "pattern",
+            choice(
+              $._lambda_field_binding,
+              $.wildcard_pattern,
+              alias($._lambda_record_pattern, $.record_pattern),
+            ),
+          ),
+        ),
+        field("name", $.identifier),
+      ),
+    _lambda_field_binding: ($) => $.identifier,
 
     paren_expr: ($) => seq("(", $._expression, ")"),
 
@@ -1760,7 +2053,7 @@ module.exports = grammar({
           field("method", $.identifier),
           // v0.22b: optional explicit type arguments on a qualified static —
           // `Json.decode[T](…)` (same-line rule as `call` type application).
-          optional(seq("[", sep1(field("type_arg", $._type_ref), ","), "]")),
+          optional(seq(alias($._type_app_open, "["), sep1(field("type_arg", $._type_ref), ","), "]")),
           "(",
           optional(sep1(field("arg", $._expression), ",")),
           optional(","),
@@ -1775,12 +2068,25 @@ module.exports = grammar({
       ),
 
     call: ($) =>
-      prec.left(
-        PREC.postfix,
+      choice(
+        prec.left(
+          PREC.postfix,
+          seq(
+            field("name", choice($.identifier, $._contextual_identifier)),
+            "(",
+            optional(sep1(field("arg", $._expression), ",")),
+            optional(","),
+            ")",
+          ),
+        ),
+        // v0.20a: explicit type arguments — `name[T, U](…)`. The `[` is the
+        // same-line external token (#2700), so a list-pattern arm on the next
+        // line is never read as a type application.
         seq(
           field("name", choice($.identifier, $._contextual_identifier)),
-          // v0.20a: optional explicit type arguments — `name[T, U](…)`.
-          optional(seq("[", sep1(field("type_arg", $._type_ref), ","), "]")),
+          alias($._type_app_open, "["),
+          sep1(field("type_arg", $._type_ref), ","),
+          "]",
           "(",
           optional(sep1(field("arg", $._expression), ",")),
           optional(","),
@@ -1888,20 +2194,48 @@ module.exports = grammar({
     // as a method call on an integer literal.
     float_literal: () =>
       /[0-9]+(_[0-9]+)*\.[0-9]+(_[0-9]+)*([eE][+-]?[0-9]+(_[0-9]+)*)?|[0-9]+(_[0-9]+)*[eE][+-]?[0-9]+(_[0-9]+)*/,
+    // #2622: a decimal literal - digits, an optional fraction, a trailing `d`.
+    decimal_literal: () => /[0-9]+(_[0-9]+)*(\.[0-9]+(_[0-9]+)*)?d/,
     string_literal: ($) =>
-      seq(
-        '"',
-        // #2203: string text is one high-precedence immediate token, so a
-        // `//` inside a string (a URL) is text, not a line comment.
-        repeat(
-          choice(
-            token.immediate(prec(1, /[^"\\\n]+/)),
-            /\\[nt"\\]/,
-            $.string_interpolation,
+      choice(
+        seq(
+          '"',
+          // #2203: string text is one high-precedence immediate token, so a
+          // `//` inside a string (a URL) is text, not a line comment.
+          repeat(
+            choice(
+              token.immediate(prec(1, /[^"\\\n]+/)),
+              $.escape_sequence,
+              $.string_interpolation,
+            ),
           ),
+          '"',
         ),
-        '"',
-      ),
+        // #2619: a multi-line string. The opening `"""` is followed by a
+        // newline; the body may hold lone or doubled quotes; escapes and
+        // interpolation are those of an ordinary string. (Indentation stripping
+        // is a value rule, not a shape: the compiler checks it.)
+        seq(
+          token(/"""\r?\n/),
+          repeat(
+            choice(
+              token.immediate(prec(1, /[^"\\]+/)),
+              token.immediate(prec(1, /"{1,2}[^"\\]/)),
+              $.escape_sequence,
+              $.string_interpolation,
+            ),
+          ),
+          '"""',
+        ),
+        // #2619: a raw string (`r"…"`, `r#"…"#`, `r"""…"""`): no escapes, no
+        // interpolation. An external token — the `#` count is not regular.
+        $.raw_string,
+      ),
+    // `\n \t \r \0 \" \\` and `\u{1–6 hex digits}` (#2619). Whether a `\u{…}`
+    // names a scalar value (not a surrogate, at most 10FFFF) is the compiler's
+    // check.
+    escape_sequence: () =>
+      token.immediate(choice(/\\[ntr0"\\]/, /\\u\{[0-9a-fA-F]{1,6}\}/)),
     // v0.43: an interpolation hole `\(expr)`. A bare `\(` was an invalid
     // escape, so this is backward-compatible; `\\(` is an escaped backslash
     // followed by a literal `(`, so it is not a hole.