tree-sitter-bynk 0.330.4 → 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

@@ -245,7 +245,14 @@ module.exports = grammar({
       ),
 
     _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 --
 
@@ -622,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(
@@ -1106,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).
@@ -1177,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(
@@ -1186,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)),
         "}",
@@ -1232,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),
       ),
 
@@ -1259,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.
@@ -1278,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)),
@@ -1366,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: ($) =>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tree-sitter-bynk",
-  "version": "0.330.4",
+  "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

@@ -99,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
@@ -146,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)