tree-sitter-bynk 0.314.23 → 0.371.3

package/README.md

@@ -3,7 +3,7 @@
 [![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue.svg)](#license)
 
 The [tree-sitter](https://tree-sitter.github.io/tree-sitter/) grammar for the
-[Bynk](https://github.com/accuser/bynk) language — the source of truth for
+[Bynk](https://github.com/bynk-lang/bynk) language — the source of truth for
 tree-sitter syntax highlighting (`queries/highlights.scm`), the playground's
 editor, and the Book's grammar reference (rendered from `src/grammar.json` by
 [`bynk-grammar`](https://crates.io/crates/bynk-grammar)).
@@ -45,5 +45,5 @@ test's dev-dependency edge is cycle-free.
 
 ## License
 
-Licensed under either of [Apache-2.0](https://github.com/accuser/bynk/blob/main/LICENSE-APACHE) or
-[MIT](https://github.com/accuser/bynk/blob/main/LICENSE-MIT) at your option.
+Licensed under either of [Apache-2.0](https://github.com/bynk-lang/bynk/blob/main/LICENSE-APACHE) or
+[MIT](https://github.com/bynk-lang/bynk/blob/main/LICENSE-MIT) at your option.

package/grammar.js

@@ -41,7 +41,7 @@ module.exports = grammar({
 
   externals: ($) => [$.doc_block],
 
-  extras: ($) => [/\s+/, $.line_comment, $.doc_block],
+  extras: ($) => [/\s+/, $.doc_line, $.line_comment, $.doc_block],
 
   // The DSL allows reserved words to be referenced inside specific rules via
   // tokens; we declare keywords so they take precedence over `identifier`.
@@ -201,6 +201,7 @@ module.exports = grammar({
         $.agent_decl,
         $.actor_decl,
         $.event_decl,
+        $.asset_decl,
       ),
 
     _context_body_item: ($) =>
@@ -217,6 +218,7 @@ module.exports = grammar({
         $.actor_decl,
         $.messages_decl,
         $.event_decl,
+        $.asset_decl,
       ),
 
     // v0.17: adapter items — a binding clause, capabilities, boundary types,
@@ -239,10 +241,18 @@ module.exports = grammar({
         $.actor_decl,
         $.messages_decl,
         $.event_decl,
+        $.asset_decl,
       ),
 
     _test_body_item: ($) =>
-      choice($.uses_decl, $.consumes_decl, $.stub_clause, $.case, $.property_decl),
+      choice(
+        $.uses_decl,
+        $.consumes_decl,
+        $.env_clause,
+        $.stub_clause,
+        $.case,
+        $.property_decl,
+      ),
 
     // -- Headers / clauses --
 
@@ -368,6 +378,21 @@ module.exports = grammar({
         field("body", $.record_type),
       ),
 
+    // #1883 (static assets), slice 1a: `asset name = "path"` — one static
+    // file the platform serves. Admitted in every body (commons, context,
+    // adapter) like `event`; placement is a checker concern
+    // (`bynk.asset.outside_context_or_commons` rejects it in an adapter).
+    asset_decl: ($) =>
+      seq(
+        "asset",
+        field("name", $.identifier),
+        "=",
+        field("path", $.string_literal),
+        // #1883, slice 2: an optional fixed URL path. `at` is contextual,
+        // matched only here (the `word` rule keeps it an identifier elsewhere).
+        optional(seq("at", field("at", $.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.
@@ -604,9 +629,16 @@ module.exports = grammar({
       seq(
         "capability",
         field("name", $.identifier),
-        "{",
-        repeat($.capability_op),
-        "}",
+        choice(
+          seq("{", repeat($.capability_op), "}"),
+          // S4a (#1966): `capability Sessions = Kv @option(…)`, a derived
+          // capability: a distinct instance of a platform capability.
+          seq(
+            "=",
+            field("base", $.identifier),
+            repeat(field("annotation", $.store_annotation)),
+          ),
+        ),
       ),
     capability_op: ($) =>
       seq(
@@ -1088,7 +1120,7 @@ module.exports = grammar({
     // The closed, compiler-known scheme set. `None`/`Internal` are zero-crypto;
     // `Bearer` (JWT/HS256), `Signature` (HMAC over the body), and `Oidc`
     // (JWKS/RS256+ES256) are compiler-generated verifiers.
-    scheme: () => choice("None", "Internal", "Bearer", "Signature", "Oidc"),
+    scheme: () => choice("None", "Internal", "Bearer", "Signature", "Oidc", "Foreign"),
     // v0.51: the keyed-args scheme config — `(key = value, …)`. Values are
     // string or integer literals; the checker validates which keys each scheme
     // admits (Bearer: secret; Signature: secret/header/timestamp/tolerance).
@@ -1159,8 +1191,17 @@ module.exports = grammar({
           "fails",
         ),
       ),
+    // #2134: a suite- or case-scoped `env { NAME = "value" … }` clause — the
+    // variables and secrets the suite's participants see. `env` is contextual:
+    // a keyword only at the head of a suite or case body member. Values are
+    // expressions here; the checker requires a `String` literal.
+    env_clause: ($) =>
+      seq("env", "{", repeat(seq($.env_entry, optional(","))), "}"),
+    env_entry: ($) =>
+      seq(field("name", $.identifier), "=", field("value", $._expression)),
+
     // v0.118: an optional `as <tier>` classifier plus a body of leading
-    // `stub` clauses, then the ordinary statements and tail. The tier words
+    // `stub` (and #2134 `env`) clauses, then the ordinary statements and tail. The tier words
     // (`unit`/`integration`/`system`) are contextual, as on `suite_decl`.
     case: ($) =>
       seq(
@@ -1168,7 +1209,7 @@ module.exports = grammar({
         field("name", $.string_literal),
         optional(seq("as", field("tier", choice("unit", "integration", "system")))),
         "{",
-        repeat($.stub_clause),
+        repeat(choice($.stub_clause, $.env_clause)),
         repeat($._statement),
         optional(field("tail", $._expression)),
         "}",
@@ -1214,9 +1255,11 @@ module.exports = grammar({
       choice(
         $.let_stmt,
         $.effect_let_stmt,
+        $.let_else_stmt,
         $.effect_send_stmt,
         $.do_stmt,
         $.assign_stmt,
+        $.advance_stmt,
         prec(1, $.expect_expr),
       ),
 
@@ -1241,6 +1284,52 @@ module.exports = grammar({
         // binder, and there is no actor sum.
         optional(field("principal", $.call_site_actor)),
       ),
+    // #2010: `let <pattern> (= | <-) <value> else <block>` or
+    // `… else match { <arms> }`. The `else` is the value of the rest of the
+    // enclosing block when the pattern does not match. The Rust parser reads a
+    // bare name after `let` as a binding, never a pattern; this grammar is more
+    // 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)),
+      ),
+    // #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(
+        $.literal_pattern,
+        $.paren_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)),
+    _let_variant_pattern: ($) => {
+      const payload = seq("(", optional(sep1($._pattern_binding, ",")), optional(","), ")");
+      return prec.right(
+        choice(
+          seq(
+            field("type", $.identifier),
+            ".",
+            field("variant", $.identifier),
+            optional(payload),
+          ),
+          seq(field("variant", $.identifier), payload),
+        ),
+      );
+    },
+    // #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>)`.
     // `prec.right` so an immediately-following `(` is taken as the identity
     // argument rather than starting a fresh token sequence.
@@ -1260,6 +1349,16 @@ module.exports = grammar({
     // v0.81 (storage track): `name := expr` — a `Cell` store write.
     assign_stmt: ($) =>
       seq(field("target", $.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.
+    advance_stmt: ($) =>
+      seq(
+        "advance",
+        field("capability", $.identifier),
+        "by",
+        field("amount", $._expression),
+      ),
 
     // A let/effect-let may bind the discard name `_`.
     _binding_name: ($) => choice($.identifier, alias("_", $.wildcard)),
@@ -1295,7 +1394,14 @@ module.exports = grammar({
     // call throws. `faults` is contextual (an ordinary identifier elsewhere),
     // mirroring the compiler's trailing-word parse; an expression is never
     // followed by a bare identifier, so the word alone decides.
-    faults_expr: ($) => seq(field("call", $._expression), "faults"),
+    // #1812: an optional call-site actor sits between the call and `faults`,
+    // in the same position as on an effect-let (`by User("bob")`).
+    faults_expr: ($) =>
+      seq(
+        field("call", $._expression),
+        optional(field("principal", $.call_site_actor)),
+        "faults",
+      ),
 
     // v0.117: an observation — a `Cap.op` seam reference followed by one of the
     // sugar matchers. `called` / `never` / `once` / `times` / `with` / `before`
@@ -1341,12 +1447,17 @@ module.exports = grammar({
 
     // v0.146 (ADR 0170): `else` is optional. A missing `else` defaults to a
     // unit branch (legal only for a unit then-branch, enforced by the checker).
+    // #2010: `prec.right` settles the dangling `else` in
+    // `let P = if c { … } else …` the way the Rust parser does: the `if`
+    // takes the `else`. (No other rule could follow an `if` with `else`.)
     if_expr: ($) =>
-      seq(
-        "if",
-        field("cond", $._expression),
-        field("then", $.block),
-        optional(seq("else", field("else", choice($.if_expr, $.block)))),
+      prec.right(
+        seq(
+          "if",
+          field("cond", $._expression),
+          field("then", $.block),
+          optional(seq("else", field("else", choice($.if_expr, $.block)))),
+        ),
       ),
 
     match_expr: ($) =>
@@ -1686,6 +1797,13 @@ module.exports = grammar({
     // dash sequence that's already been gobbled by the external scanner).
     line_comment: () => token(seq("--", /[^\n]*/)),
 
+    // #1888: a `--|` one-line doc. Both it and `line_comment` match a
+    // `--|` line to its end, so the higher lexical precedence makes it a
+    // doc. The compiler takes `--|` as a doc only when it is the first thing
+    // on its line; an extras token cannot see that, so a `--|` after code on
+    // the same line highlights as a doc here though it compiles as a comment.
+    doc_line: () => token(prec(1, seq("--|", /[^\n]*/))),
+
     // `doc_block` is provided by the external scanner — see src/scanner.c.
     // The grammar references it via the `externals` array above.
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tree-sitter-bynk",
-  "version": "0.314.23",
+  "version": "0.371.3",
   "description": "Tree-sitter grammar for the Bynk language.",
   "main": "bindings/node",
   "types": "bindings/node",
@@ -13,12 +13,12 @@
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/accuser/bynk.git",
+    "url": "git+https://github.com/bynk-lang/bynk.git",
     "directory": "tree-sitter-bynk"
   },
-  "homepage": "https://github.com/accuser/bynk/tree/main/tree-sitter-bynk",
+  "homepage": "https://github.com/bynk-lang/bynk/tree/main/tree-sitter-bynk",
   "bugs": {
-    "url": "https://github.com/accuser/bynk/issues"
+    "url": "https://github.com/bynk-lang/bynk/issues"
   },
   "scripts": {
     "install": "node-gyp-build",

package/queries/highlights.scm

@@ -57,6 +57,7 @@
   "ensures"
   "messages"
   "event"
+  "asset"
 ] @keyword.declaration
 
 [
@@ -98,6 +99,9 @@
   "fails"
 ] @keyword.operator
 
+; #2134: the contextual `env` word heading a suite/case `env { … }` clause.
+"env" @keyword
+
 ; #1706: the fault-claim word — contextual, like the observation words: the
 ; token exists only inside a `faults_expr`.
 "faults" @keyword.operator
@@ -145,6 +149,8 @@
 (call name: (identifier) @function)
 (method_call method: (identifier) @function.method)
 (capability_op name: (identifier) @function.method)
+; S4a (#1966): the base of a derived capability (`capability Sessions = Kv`).
+(capability_decl base: (identifier) @type)
 (provider_op name: (identifier) @function.method)
 (call_handler method: (identifier) @function.method)
 
@@ -240,6 +246,7 @@
 
 (line_comment) @comment
 (doc_block) @comment.documentation
+(doc_line) @comment.documentation
 
 ; -- Errors (tree-sitter recovery) --