@willbooster/tree-sitter-c-sharp 1.0.0 → 1.0.2

package/README.md

@@ -27,6 +27,8 @@ The grammar is based upon the Roslyn grammar with changes in order to:
 Known gaps:
 
 - `async`, `var` and `await` cannot be used as identifiers everywhere they are valid
+- A pointer dereference can be assigned to only when its operand is a variable, member access, element access,
+  or another dereference (`*p = 1`, `*(p) = 1`, `*a.b = 1`); `*(int*)p = 1` and `*(p + 1) = 1` are not recognized
 - File-based apps preprocessor directives (`#:property`, `#:package`, `#:sdk`, `#:project`) are not yet recognized
 
 ## Usage
@@ -74,11 +76,13 @@ parser.setLanguage(await Language.load(cSharp));
 
 The package also ships the node types in `src/node-types.json`.
 
-In Rust, depend on the [crate](https://crates.io/crates/willbooster-tree-sitter-c-sharp):
+In Rust, depend on the [crate](https://crates.io/crates/willbooster-tree-sitter-c-sharp) and the
+[runtime](https://crates.io/crates/willbooster-tree-sitter), whose fixes keep incremental reparses consistent with
+fresh parses:
 
 ```toml
 [dependencies]
-tree-sitter = "0.27"
+tree-sitter = { package = "willbooster-tree-sitter", version = "1.0.3" }
 tree-sitter-c-sharp = { package = "willbooster-tree-sitter-c-sharp", version = "1" }
 ```
 
@@ -115,6 +119,9 @@ cargo test
   which needs Chromium installed once by `bunx playwright install chromium`) and in Cloudflare Workers with and without
   `nodejs_compat` (`test/unit/workers.test.ts`).
 
+`cargo test` also replays edits that `tree-sitter fuzz` found to break incremental parsing, with the
+willbooster-tree-sitter runtime that fixes them; `tree-sitter fuzz` itself runs the runtime built into tree-sitter-cli.
+
 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`).
 

package/grammar.js

@@ -1133,6 +1133,7 @@ module.exports = grammar({
         // Parallels `_pointer_indirection_expression` (the `*` operator),
         // which is similarly aliased back into `lvalue_expression`.
         alias($._address_of_expression, $.prefix_unary_expression),
+        alias($._value_indirection_expression, $.prefix_unary_expression),
         $.reftype_expression,
         $.refvalue_expression,
         $.stackalloc_expression,
@@ -1230,16 +1231,31 @@ module.exports = grammar({
           // `&` and `*` are intentionally NOT in this choice list:
           //   * `&` → `_address_of_expression` (operand restricted to lvalue
           //           — see comment on that rule for the #413 rationale)
-          //   * `*` → `_pointer_indirection_expression` (same shape,
-          //           restricted to lvalue, surfaced in `lvalue_expression`)
-          // Both are aliased back to `prefix_unary_expression` so the
+          //   * `*` → `_pointer_indirection_expression` and
+          //           `_value_indirection_expression`
+          // They are aliased back to `prefix_unary_expression` so the
           // public AST is unaffected.
           choice('++', '--', '+', '-', '!', '~', '^'),
           $.expression
         )
       ),
 
-    _pointer_indirection_expression: ($) => prec.right(PREC.UNARY, seq('*', $.lvalue_expression)),
+    // Pointer indirection is split by its operand. Dereferencing an lvalue
+    // (`*p`, `*(p)`, `**pp`) yields an lvalue, so it is surfaced in
+    // `lvalue_expression` and can be assigned to. Dereferencing any other
+    // expression (`*(long*)&v`, `*(p + 1)`) is only read: surfacing it in
+    // `lvalue_expression` too would let `=` follow every expression that can
+    // be its operand, which grows the parser from 8,495 to 13,339 states.
+    //
+    // A parenthesized expression followed by `*` is a multiplication, not a
+    // cast of a dereference (C# spec §12.9.8 Cast expressions: `(a) * b` is
+    // a cast only when `a` cannot be an expression), so a dereference's
+    // penalty outweighs the cast's +1. `*(p) + 1` is likewise the sum of a
+    // dereference of `(p)` (-2), not a dereference of a cast of `+1`
+    // (-4 + 1), so dereferencing a non-lvalue carries the larger penalty.
+    _pointer_indirection_expression: ($) => prec.dynamic(-2, prec.right(PREC.UNARY, seq('*', $.lvalue_expression))),
+
+    _value_indirection_expression: ($) => prec.dynamic(-4, prec.right(PREC.UNARY, seq('*', $.non_lvalue_expression))),
 
     // Address-of is split out from `prefix_unary_expression` so that
     // `&` can't act as a fallback when the lexer would otherwise

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@willbooster/tree-sitter-c-sharp",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "C# grammar for tree-sitter",
   "keywords": [
     "incremental",

package/tree-sitter.json

@@ -19,7 +19,7 @@
     }
   ],
   "metadata": {
-    "version": "1.0.0",
+    "version": "1.0.2",
     "license": "MIT",
     "description": "C# grammar for tree-sitter",
     "authors": [