tree-sitter-bynk 0.377.2 → 0.404.0

package/grammar.js

@@ -74,6 +74,11 @@ module.exports = grammar({
     // whether a matcher (`called`/`never`/`before`) or an ordinary continuation
     // (`(`, an operator, …) follows.
     [$.observation_expr, $._primary],
+    // `trace` is contextual: `trace (` opens either the `trace(Cap.op)`
+    // builtin or an ordinary call to a function named `trace` (the compiler
+    // picks the builtin only on the exact `trace ( Ident . Ident )` shape). GLR
+    // keeps both; `trace_expr`'s dynamic precedence wins when both complete.
+    [$.trace_expr, $._contextual_identifier],
     // v0.140: inside `agent_decl`, a `store` field's own trailing
     // `@annotation`s are the same rule as the handler-position annotation
     // prefix that can immediately follow the last store field — one token of
@@ -202,6 +207,7 @@ module.exports = grammar({
         $.actor_decl,
         $.event_decl,
         $.asset_decl,
+        $.embed_decl,
       ),
 
     _context_body_item: ($) =>
@@ -219,6 +225,8 @@ module.exports = grammar({
         $.messages_decl,
         $.event_decl,
         $.asset_decl,
+        $.embed_decl,
+        $.removed_agent_decl,
       ),
 
     // v0.17: adapter items — a binding clause, capabilities, boundary types,
@@ -242,6 +250,7 @@ module.exports = grammar({
         $.messages_decl,
         $.event_decl,
         $.asset_decl,
+        $.embed_decl,
       ),
 
     _test_body_item: ($) =>
@@ -281,6 +290,17 @@ module.exports = grammar({
       seq(
         "binding",
         field("module", $.string_literal),
+        // #2321: `includes` is contextual (an identifier elsewhere), so it is a
+        // token only here.
+        optional(
+          seq(
+            alias("includes", $.includes_keyword),
+            "[",
+            optional(sep1(field("include", $.string_literal), ",")),
+            optional(","),
+            "]",
+          ),
+        ),
         optional(
           seq(
             "requires",
@@ -393,6 +413,18 @@ module.exports = grammar({
         optional(seq("at", field("at", $.string_literal))),
       ),
 
+    // #2387 (embedded text), slice 1: `embed name = "path"` — one project
+    // file's text as a `String` constant. Admitted in every body like `asset`;
+    // placement is a checker concern (`bynk.embed.outside_context_or_commons`
+    // rejects it in an adapter).
+    embed_decl: ($) =>
+      seq(
+        "embed",
+        field("name", $.identifier),
+        "=",
+        field("path", $.string_literal),
+      ),
+
     // 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.
@@ -867,11 +899,14 @@ module.exports = grammar({
       seq(
         "agent",
         field("name", $.identifier),
+        // State-migrations S3 (#2248): `agent New replaces Old` — a class
+        // rename, its stored data moving with it. `replaces` is contextual.
+        optional(seq("replaces", field("replaces", $.identifier))),
         "{",
         field("key", $.key_decl),
         // v0.81 (storage track): the agent's `store` fields (ADR 0108).
         repeat($.store_field),
-        repeat(choice($.invariant_decl, $.transition_decl)),
+        repeat(choice($.invariant_decl, $.transition_decl, $.migrate_decl)),
         // v0.140 (ADR 0163): handler-position annotations parse uniformly on
         // agent handlers too; the checker (not the grammar) restricts which
         // annotations apply to a non-HTTP handler. Only `on call` is a valid
@@ -901,6 +936,32 @@ module.exports = grammar({
         ":",
         field("predicate", $._expression),
       ),
+    // State-migrations S2 (#2224): `migrate from N [(old: T)] { … }` — a step
+    // carrying a stored record from schema version N to the current shape.
+    // `migrate` and `drop` are contextual keywords, like `store`.
+    migrate_decl: ($) =>
+      seq(
+        "migrate",
+        "from",
+        field("from", $.number_literal),
+        optional(
+          seq(
+            "(",
+            field("old", $.identifier),
+            ":",
+            field("old_type", $._type_ref),
+            ")",
+          ),
+        ),
+        "{",
+        repeat(choice($.let_stmt, $.assign_stmt, $.migrate_drop)),
+        "}",
+      ),
+    migrate_drop: ($) => seq("drop", field("field", $.identifier)),
+    // State-migrations S3 (#2248): `removed agent Old` — the class is gone and
+    // its stored data deleted. `removed` is contextual.
+    removed_agent_decl: ($) =>
+      seq("removed", "agent", field("name", $.identifier)),
     key_decl: ($) =>
       seq("key", field("name", $.identifier), ":", field("type", $._type_ref)),
     // v0.81 (storage track): `store <name>: <Kind>[…] [= init]`. `store` is a
@@ -954,6 +1015,26 @@ module.exports = grammar({
         // Events track, slice 0 (spine #936): a `from Events(E)` service's
         // one handler.
         $.event_handler,
+        // #2341 (L4, decision C): a `from http` service's rendering of the
+        // router's own rejections.
+        $.rejected_handler,
+      ),
+    // #2341 (L4, decision C): `on rejected(why: BoundaryRejection) ->
+    // HttpResult[()] { … }`. The generic handler shape; the checker refuses a
+    // `by`/`given` and checks the parameter and return type.
+    rejected_handler: ($) =>
+      seq(
+        "on",
+        "rejected",
+        "(",
+        optional(sep1($.param, ",")),
+        optional(","),
+        ")",
+        "->",
+        field("return_type", $._type_ref),
+        optional(field("by", $.by_clause)),
+        optional(field("given", $.given_clause)),
+        field("body", $.block),
       ),
     // Events track, slice 0 (spine #936): `on event(e: E) -> Effect[()] { … }`
     // — a `from Events(E)` subscriber's one handler. Same generic shape as
@@ -1330,7 +1411,8 @@ module.exports = grammar({
     // #2010: the `else match { <arms> }` form, whose arms cover the values the
     // `let` pattern does not.
     let_else_match: ($) => seq("match", "{", repeat($.match_arm), "}"),
-    // v0.182 (#664): `by <Actor>` (unit identity) or `by <Actor>(<identity>)`.
+    // v0.182 (#664): `by <Actor>` (unit identity) or `by <Actor>(<identity>)`;
+    // #2380: `by <Actor>(<identity>, <claims>)` for an `Oidc` actor.
     // `prec.right` so an immediately-following `(` is taken as the identity
     // argument rather than starting a fresh token sequence.
     call_site_actor: ($) =>
@@ -1338,7 +1420,15 @@ module.exports = grammar({
         seq(
           "by",
           field("actor", $.identifier),
-          optional(seq("(", field("identity", $._expression), ")")),
+          // #2380 (L5): an `Oidc` principal may pass its token's claims second.
+          optional(
+            seq(
+              "(",
+              field("identity", $._expression),
+              optional(seq(",", field("claims", $._expression))),
+              ")",
+            ),
+          ),
         ),
       ),
     // v0.79: `~> expr` — an asynchronous fire-and-forget send (no binder).
@@ -1348,7 +1438,11 @@ module.exports = grammar({
     do_stmt: ($) => seq("do", field("value", $._expression)),
     // v0.81 (storage track): `name := expr` — a `Cell` store write.
     assign_stmt: ($) =>
-      seq(field("target", $.identifier), ":=", field("value", $._expression)),
+      seq(
+        field("target", choice($.identifier, $._contextual_identifier)),
+        ":=",
+        field("value", $._expression),
+      ),
     // #2137: `advance Clock by <Duration>` — move the test harness's clock. The
     // compiler admits it only in a `case` body and only on `Clock`; `advance`
     // is contextual.
@@ -1433,8 +1527,8 @@ module.exports = grammar({
     // `List` of per-op records. A test-only builtin recognised by its
     // `trace ( Ident . Ident )` shape.
     trace_expr: ($) =>
-      prec(
-        PREC.postfix + 1,
+      prec.dynamic(
+        1,
         seq(
           "trace",
           "(",
@@ -1618,8 +1712,19 @@ module.exports = grammar({
         $.unit_literal,
         $.self_expr,
         $.identifier,
+        $._contextual_identifier,
       ),
 
+    // `trace` and `advance` 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
+    // head) the keyword always wins the lex. Re-admit the keyword token as an
+    // `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),
+
     // v0.20a: a lambda — `(params) => expr | block`. Conflicts with
     // paren_expr/unit_literal until the `=>` disambiguates (GLR conflict
     // declared below).
@@ -1633,7 +1738,10 @@ module.exports = grammar({
       ),
 
     lambda_param: ($) =>
-      seq(field("name", $.identifier), optional(seq(":", field("type", $._type_ref)))),
+      seq(
+        field("name", choice($.identifier, $._contextual_identifier)),
+        optional(seq(":", field("type", $._type_ref))),
+      ),
 
     paren_expr: ($) => seq("(", $._expression, ")"),
 
@@ -1668,7 +1776,7 @@ module.exports = grammar({
       prec.left(
         PREC.postfix,
         seq(
-          field("name", $.identifier),
+          field("name", choice($.identifier, $._contextual_identifier)),
           // v0.20a: optional explicit type arguments — `name[T, U](…)`.
           optional(seq("[", sep1(field("type_arg", $._type_ref), ","), "]")),
           "(",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tree-sitter-bynk",
-  "version": "0.377.2",
+  "version": "0.404.0",
   "description": "Tree-sitter grammar for the Bynk language.",
   "main": "bindings/node",
   "types": "bindings/node",

package/queries/highlights.scm

@@ -53,11 +53,17 @@
   "property"
   "invariant"
   "transition"
+  "migrate"
+  "drop"
+  "replaces"
+  "removed"
   "requires"
   "ensures"
   "messages"
   "event"
+  "rejected"
   "asset"
+  "embed"
 ] @keyword.declaration
 
 [
@@ -251,3 +257,6 @@
 ; -- Errors (tree-sitter recovery) --
 
 (ERROR) @error
+
+; #2321: `includes` is contextual (an identifier elsewhere), so it is its own node.
+(includes_keyword) @keyword.declaration