@gram-data/tree-sitter-gram 0.3.5 → 0.3.6

package/editors/zed/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "gram_zed_extension"
+version = "0.1.0"
+edition = "2021"
+license = "MIT"
+publish = false
+repository = "https://github.com/gram-data/tree-sitter-gram"
+build = "build.rs"
+
+[lib]
+path = "src/lib.rs"
+crate-type = ["cdylib"]
+
+[dependencies]
+zed_extension_api = "0.7"
+
+# Standalone workspace root so this crate is not treated as a stray member of the
+# repository workspace (see root `Cargo.toml` `[workspace]`).
+[workspace]
+members = ["."]

package/editors/zed/README.md

@@ -5,6 +5,7 @@ A [Zed](https://zed.dev) extension providing syntax highlighting and language su
 ## Features
 
 - **Syntax Highlighting**: Full syntax highlighting for all Gram constructs including subjects, nodes, relationships, and data types
+- **Language server**: When [`gram-lsp`](../../tools/lsp/) is on your `PATH`, Zed starts it for `.gram` files (diagnostics, hover, definitions, references, completions)
 - **Subject Pattern Matching**: Automatic matching for `()`, `[]`, and `{}`
 - **File Type Detection**: Automatic recognition of `.gram` files
 - **Smart Indentation**: Proper indentation handling for nested structures
@@ -40,7 +41,7 @@ Then restart Zed.
 
 ## Usage
 
-Once installed, the extension automatically provides syntax highlighting for any file with a `.gram` extension.
+Once installed, the extension provides syntax highlighting for `.gram` files. With `gram-lsp` installed and on `PATH`, Zed also attaches the language server automatically.
 
 ### Example Gram Syntax
 
@@ -108,14 +109,25 @@ To work on this extension:
    - Select the `editors/zed` directory
    - Restart Zed
 
-3. Make changes to the extension files
-4. Restart Zed to see changes
+3. Build the Wasm extension once after Rust changes (Zed loads the cdylib):
+
+   ```bash
+   rustup target add wasm32-wasip1
+   cd editors/zed && cargo check --target wasm32-wasip1
+   ```
+
+4. Make changes to the extension files
+5. Restart Zed to see changes
 
 ### Extension Structure
 
 ```
 editors/zed/
-├── extension.toml          # Extension metadata; points at grammar repo (repository + rev)
+├── Cargo.toml              # Wasm extension crate (zed_extension_api)
+├── build.rs                # Embeds `extension.toml` version for release asset lookup
+├── Cargo.lock
+├── src/lib.rs              # `language_server_command`: PATH, then GitHub release download
+├── extension.toml          # Extension metadata; grammar repo + `[language_servers.gram-lsp]`
 ├── languages/
 │   └── gram/
 │       ├── config.toml     # Zed language config (brackets, suffixes, etc.)
@@ -144,6 +156,12 @@ After either command, `extension.toml` is updated in place. For local dev you ty
 
 **If Zed shows an old version (e.g. 0.1.11) after installing the dev extension:** Zed may be using a cached clone of the grammar (at an old rev) or an older copy of the extension. Try: (1) Uninstall the Gram extension from Zed’s Extensions panel. (2) Delete the grammar cache: remove `editors/zed/grammars/` if it exists (Zed recreates it when needed). (3) Run `npm run zed:dev` again so `extension.toml` has the current version and rev. (4) In Zed, run “Install Dev Extension” and select `editors/zed` again. Restart Zed and recheck the extension version.
 
+### Bundled `gram-lsp` (GitHub Releases)
+
+Zed extensions ship a **Wasm** adapter only; native `gram-lsp` binaries cannot be embedded in that bundle. Instead, when `gram-lsp` is **not** on `PATH`, the extension downloads a platform archive from **this repo’s GitHub Release** whose tag is **`v` + `version` from `extension.toml`** (for example `v0.3.5` for `version = "0.3.5"`).
+
+Maintainers: pushing a **`v*`** tag runs **`.github/workflows/gram-lsp-release-assets.yml`**, which builds `gram-lsp` for common targets and uploads `gram-lsp-{target}.tar.gz` to the matching GitHub Release. Filenames must stay in sync with `editors/zed/src/lib.rs`. Keep `extension.toml`’s `version` aligned with the tag you ship to the Zed extension registry (for example tag `v0.3.5` and `version = "0.3.5"`) so installs download the intended binaries.
+
 ## Contributing
 
 Contributions are welcome! Please see the main [repository](https://github.com/gram-data/tree-sitter-gram) for contribution guidelines.
@@ -156,7 +174,7 @@ To improve syntax highlighting and editor behavior:
 
 ## License
 
-This extension is part of the tree-sitter-gram project and is licensed under the ISC License. See the main repository's [LICENSE](../../LICENSE) file for details.
+This extension is part of the tree-sitter-gram project and is licensed under the MIT License. See the main repository's [LICENSE](../../LICENSE) file for details.
 
 ## Learn More
 

package/editors/zed/build.rs

@@ -0,0 +1,26 @@
+//! Expose `extension.toml`'s `version = "…"` as `env!("GRAM_EXT_VERSION")` for release lookups.
+
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+
+fn main() {
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR"));
+    let ext_toml = manifest_dir.join("extension.toml");
+    println!("cargo:rerun-if-changed={}", ext_toml.display());
+
+    let content = fs::read_to_string(&ext_toml).unwrap_or_else(|e| panic!("read {}: {e}", ext_toml.display()));
+    let version = parse_version(&content)
+        .unwrap_or_else(|| panic!("{}: missing `version = \"…\"` line", ext_toml.display()));
+    println!("cargo:rustc-env=GRAM_EXT_VERSION={version}");
+}
+
+fn parse_version(toml: &str) -> Option<String> {
+    for line in toml.lines() {
+        let line = line.trim();
+        if let Some(rest) = line.strip_prefix("version = \"") {
+            return rest.split('"').next().map(str::to_string);
+        }
+    }
+    None
+}

package/editors/zed/extension.toml

@@ -1,11 +1,16 @@
 id = "gram"
 name = "Gram Language Support"
-version = "0.3.5"
+version = "0.3.6"
 schema_version = 1
 authors = ["Gram Data Contributors"]
 description = "Support for Gram notation - composable data patterns"
 
+capabilities = [
+  { kind = "process:exec", command = "*", args = ["stdio"] },
+  { kind = "download_file", host = "github.com", path = ["gram-data", "tree-sitter-gram", "**"] },
+]
+
 # path = "grammars/tree-sitter-gram"
 [grammars.gram]
 repository = "https://github.com/gram-data/tree-sitter-gram"
-rev = "869488b6bbea325b4c4153a7a6bee97df7931a58"
+rev = "184b524f4a0653bee3a07c44907dc266d698cb6e"

package/editors/zed/languages/gram/config.toml

@@ -12,5 +12,5 @@ word_characters = ["_"]
 [prettier]
 allowed = false
 
-# [language_servers]
-# Add language server configuration here if you develop one for Gram
+# Language servers are declared in extension.toml (`[language_servers.gram-lsp]`)
+# and started from `src/lib.rs`. Per-server options go in Zed settings.json under `lsp`.

package/editors/zed/src/lib.rs

@@ -0,0 +1,156 @@
+//! Zed extension host glue: starts `gram-lsp` from `PATH` or downloads a release asset.
+
+use zed_extension_api::{
+    self as zed,
+    github_release_by_tag_name,
+    set_language_server_installation_status,
+    Architecture, Command, DownloadedFileType, Extension, LanguageServerId,
+    LanguageServerInstallationStatus, Os, Result, Worktree, current_platform, download_file,
+    make_file_executable,
+};
+
+const GRAM_REPO: &str = "gram-data/tree-sitter-gram";
+
+struct GramExtension {
+    /// Relative path (under the extension work dir) or absolute path from `which`.
+    cached_binary: Option<String>,
+}
+
+impl GramExtension {
+    fn rust_target_triple() -> Result<&'static str> {
+        match current_platform() {
+            (Os::Mac, Architecture::Aarch64) => Ok("aarch64-apple-darwin"),
+            (Os::Mac, Architecture::X8664) => Ok("x86_64-apple-darwin"),
+            (Os::Linux, Architecture::Aarch64) => Ok("aarch64-unknown-linux-gnu"),
+            (Os::Linux, Architecture::X8664) => Ok("x86_64-unknown-linux-gnu"),
+            (Os::Windows, Architecture::Aarch64) => Ok("aarch64-pc-windows-msvc"),
+            (Os::Windows, Architecture::X8664) => Ok("x86_64-pc-windows-msvc"),
+            (Os::Linux, Architecture::X86) | (Os::Windows, Architecture::X86) => Err(
+                "gram-lsp: 32-bit platforms are not supported; install gram-lsp on PATH manually"
+                    .into(),
+            ),
+            (Os::Mac, Architecture::X86) => Err(
+                "gram-lsp: unexpected macOS x86 architecture; install gram-lsp on PATH manually"
+                    .into(),
+            ),
+        }
+    }
+
+    fn gram_lsp_bin_name(os: Os) -> &'static str {
+        match os {
+            Os::Windows => "gram-lsp.exe",
+            Os::Mac | Os::Linux => "gram-lsp",
+        }
+    }
+
+    fn ensure_downloaded(
+        &mut self,
+        language_server_id: &LanguageServerId,
+    ) -> Result<String> {
+        let version = env!("GRAM_EXT_VERSION");
+        let extract_dir = format!("gram-lsp-{version}");
+        let (os, _) = current_platform();
+        let bin_name = Self::gram_lsp_bin_name(os);
+        let relative_binary = format!("{extract_dir}/{bin_name}");
+
+        let triple = Self::rust_target_triple()?;
+        let asset_name = format!("gram-lsp-{triple}.tar.gz");
+        let tag = format!("v{version}");
+
+        set_language_server_installation_status(
+            language_server_id,
+            &LanguageServerInstallationStatus::Downloading,
+        );
+
+        let release = match github_release_by_tag_name(GRAM_REPO, &tag) {
+            Ok(r) => r,
+            Err(e) => {
+                let detail = format!(
+                    "GitHub release {tag}: {e}. Install `gram-lsp` on PATH or publish release assets (see .github/workflows/gram-lsp-release-assets.yml)."
+                );
+                set_language_server_installation_status(
+                    language_server_id,
+                    &LanguageServerInstallationStatus::Failed(detail.clone()),
+                );
+                return Err(format!("gram-lsp: no GitHub release for {tag}: {e}"));
+            }
+        };
+
+        let asset = match release.assets.iter().find(|a| a.name == asset_name) {
+            Some(a) => a,
+            None => {
+                let msg = format!(
+                    "gram-lsp: release {tag} has no asset {asset_name}. Build with the gram-lsp-release-assets workflow."
+                );
+                set_language_server_installation_status(
+                    language_server_id,
+                    &LanguageServerInstallationStatus::Failed(msg.clone()),
+                );
+                return Err(msg);
+            }
+        };
+
+        if let Err(e) = download_file(
+            &asset.download_url,
+            &extract_dir,
+            DownloadedFileType::GzipTar,
+        ) {
+            set_language_server_installation_status(
+                language_server_id,
+                &LanguageServerInstallationStatus::Failed(e.clone()),
+            );
+            return Err(format!("gram-lsp: download failed: {e}"));
+        }
+
+        if let Err(e) = make_file_executable(&relative_binary) {
+            set_language_server_installation_status(
+                language_server_id,
+                &LanguageServerInstallationStatus::Failed(e.clone()),
+            );
+            return Err(format!("gram-lsp: chmod failed: {e}"));
+        }
+
+        set_language_server_installation_status(
+            language_server_id,
+            &LanguageServerInstallationStatus::None,
+        );
+
+        self.cached_binary = Some(relative_binary.clone());
+        Ok(relative_binary)
+    }
+}
+
+impl Extension for GramExtension {
+    fn new() -> Self {
+        Self {
+            cached_binary: None,
+        }
+    }
+
+    fn language_server_command(
+        &mut self,
+        language_server_id: &LanguageServerId,
+        worktree: &Worktree,
+    ) -> Result<Command> {
+        if language_server_id.as_ref() != "gram-lsp" {
+            return Err(format!(
+                "unsupported language server id: {}",
+                language_server_id.as_ref()
+            ));
+        }
+
+        if let Some(path) = &self.cached_binary {
+            return Ok(Command::new(path).arg("stdio"));
+        }
+
+        if let Some(path) = worktree.which("gram-lsp") {
+            self.cached_binary = Some(path.clone());
+            return Ok(Command::new(path).arg("stdio"));
+        }
+
+        let path = self.ensure_downloaded(language_server_id)?;
+        Ok(Command::new(path).arg("stdio"))
+    }
+}
+
+zed::register_extension!(GramExtension);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gram-data/tree-sitter-gram",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "subject-oriented notation for structured data",
   "homepage": "https://gram-data.github.io",
   "repository": {

package/src/parser.c

@@ -1,4 +1,4 @@
-/* Automatically @generated by tree-sitter */
+/* Automatically @generated by tree-sitter v0.25.10 */
 
 #include "tree_sitter/parser.h"
 
@@ -4368,7 +4368,7 @@ TS_PUBLIC const TSLanguage *tree_sitter_gram(void) {
     .metadata = {
       .major_version = 0,
       .minor_version = 3,
-      .patch_version = 5,
+      .patch_version = 6,
     },
   };
   return &language;

package/src/tree_sitter/array.h

@@ -52,91 +52,67 @@ extern "C" {
 
 /// Reserve `new_capacity` elements of space in the array. If `new_capacity` is
 /// less than the array's current capacity, this function has no effect.
-#define array_reserve(self, new_capacity)        \
-  ((self)->contents = _array__reserve(           \
-    (void *)(self)->contents, &(self)->capacity, \
-    array_elem_size(self), new_capacity)         \
-  )
+#define array_reserve(self, new_capacity) \
+  _array__reserve((Array *)(self), array_elem_size(self), new_capacity)
 
 /// Free any memory allocated for this array. Note that this does not free any
 /// memory allocated for the array's contents.
-#define array_delete(self) _array__delete((self), (void *)(self)->contents, sizeof(*self))
+#define array_delete(self) _array__delete((Array *)(self))
 
 /// Push a new `element` onto the end of the array.
-#define array_push(self, element)                                 \
-  do {                                                            \
-    (self)->contents = _array__grow(                              \
-      (void *)(self)->contents, (self)->size, &(self)->capacity,  \
-      1, array_elem_size(self)                                    \
-    );                                                            \
-   (self)->contents[(self)->size++] = (element);                  \
-  } while(0)
+#define array_push(self, element)                            \
+  (_array__grow((Array *)(self), 1, array_elem_size(self)), \
+   (self)->contents[(self)->size++] = (element))
 
 /// Increase the array's size by `count` elements.
 /// New elements are zero-initialized.
-#define array_grow_by(self, count)                                               \
-  do {                                                                           \
-    if ((count) == 0) break;                                                     \
-    (self)->contents = _array__grow(                                             \
-      (self)->contents, (self)->size, &(self)->capacity,                         \
-      count, array_elem_size(self)                                               \
-    );                                                                           \
+#define array_grow_by(self, count) \
+  do { \
+    if ((count) == 0) break; \
+    _array__grow((Array *)(self), count, array_elem_size(self)); \
     memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)); \
-    (self)->size += (count);                                                     \
+    (self)->size += (count); \
   } while (0)
 
 /// Append all elements from one array to the end of another.
-#define array_push_all(self, other) \
+#define array_push_all(self, other)                                       \
   array_extend((self), (other)->size, (other)->contents)
 
 /// Append `count` elements to the end of the array, reading their values from the
 /// `contents` pointer.
-#define array_extend(self, count, other_contents)                 \
-  (self)->contents = _array__splice(                              \
-    (void*)(self)->contents, &(self)->size, &(self)->capacity,    \
-    array_elem_size(self), (self)->size, 0, count, other_contents \
+#define array_extend(self, count, contents)                    \
+  _array__splice(                                               \
+    (Array *)(self), array_elem_size(self), (self)->size, \
+    0, count,  contents                                        \
   )
 
 /// Remove `old_count` elements from the array starting at the given `index`. At
 /// the same index, insert `new_count` new elements, reading their values from the
 /// `new_contents` pointer.
-#define array_splice(self, _index, old_count, new_count, new_contents) \
-  (self)->contents = _array__splice(                                   \
-    (void *)(self)->contents, &(self)->size, &(self)->capacity,        \
-    array_elem_size(self), _index, old_count, new_count, new_contents  \
+#define array_splice(self, _index, old_count, new_count, new_contents)  \
+  _array__splice(                                                       \
+    (Array *)(self), array_elem_size(self), _index,                \
+    old_count, new_count, new_contents                                 \
   )
 
 /// Insert one `element` into the array at the given `index`.
-#define array_insert(self, _index, element)                     \
-  (self)->contents = _array__splice(                            \
-    (void *)(self)->contents, &(self)->size, &(self)->capacity, \
-    array_elem_size(self), _index, 0, 1, &(element)             \
-  )
+#define array_insert(self, _index, element) \
+  _array__splice((Array *)(self), array_elem_size(self), _index, 0, 1, &(element))
 
 /// Remove one element from the array at the given `index`.
 #define array_erase(self, _index) \
-  _array__erase((void *)(self)->contents, &(self)->size, array_elem_size(self), _index)
+  _array__erase((Array *)(self), array_elem_size(self), _index)
 
 /// Pop the last element off the array, returning the element by value.
 #define array_pop(self) ((self)->contents[--(self)->size])
 
 /// Assign the contents of one array to another, reallocating if necessary.
-#define array_assign(self, other)                                   \
-  (self)->contents = _array__assign(                                \
-    (void *)(self)->contents, &(self)->size, &(self)->capacity,     \
-    (const void *)(other)->contents, (other)->size, array_elem_size(self) \
-  )
+#define array_assign(self, other) \
+  _array__assign((Array *)(self), (const Array *)(other), array_elem_size(self))
 
 /// Swap one array with another
-#define array_swap(self, other)                                     \
-  do {                                                              \
-    struct Swap swapped_contents = _array__swap(                    \
-      (void *)(self)->contents, &(self)->size, &(self)->capacity,   \
-      (void *)(other)->contents, &(other)->size, &(other)->capacity \
-    );                                                              \
-    (self)->contents = swapped_contents.self_contents;              \
-    (other)->contents = swapped_contents.other_contents;            \
-  } while (0)
+#define array_swap(self, other) \
+  _array__swap((Array *)(self), (Array *)(other))
 
 /// Get the size of the array contents
 #define array_elem_size(self) (sizeof *(self)->contents)
@@ -181,112 +157,82 @@ extern "C" {
 
 // Private
 
-// Pointers to individual `Array` fields (rather than the entire `Array` itself)
-// are passed to the various `_array__*` functions below to address strict aliasing
-// violations that arises when the _entire_ `Array` struct is passed as `Array(void)*`.
-//
-// The `Array` type itself was not altered as a solution in order to avoid breakage
-// with existing consumers (in particular, parsers with external scanners).
+typedef Array(void) Array;
 
 /// This is not what you're looking for, see `array_delete`.
-static inline void _array__delete(void *self, void *contents, size_t self_size) {
-  if (contents) ts_free(contents);
-  if (self) memset(self, 0, self_size);
+static inline void _array__delete(Array *self) {
+  if (self->contents) {
+    ts_free(self->contents);
+    self->contents = NULL;
+    self->size = 0;
+    self->capacity = 0;
+  }
 }
 
 /// This is not what you're looking for, see `array_erase`.
-static inline void _array__erase(void* self_contents, uint32_t *size,
-                                size_t element_size, uint32_t index) {
-  assert(index < *size);
-  char *contents = (char *)self_contents;
+static inline void _array__erase(Array *self, size_t element_size,
+                                uint32_t index) {
+  assert(index < self->size);
+  char *contents = (char *)self->contents;
   memmove(contents + index * element_size, contents + (index + 1) * element_size,
-          (*size - index - 1) * element_size);
-  (*size)--;
+          (self->size - index - 1) * element_size);
+  self->size--;
 }
 
 /// This is not what you're looking for, see `array_reserve`.
-static inline void *_array__reserve(void *contents, uint32_t *capacity,
-                                  size_t element_size, uint32_t new_capacity) {
-  void *new_contents = contents;
-  if (new_capacity > *capacity) {
-    if (contents) {
-      new_contents = ts_realloc(contents, new_capacity * element_size);
+static inline void _array__reserve(Array *self, size_t element_size, uint32_t new_capacity) {
+  if (new_capacity > self->capacity) {
+    if (self->contents) {
+      self->contents = ts_realloc(self->contents, new_capacity * element_size);
     } else {
-      new_contents = ts_malloc(new_capacity * element_size);
+      self->contents = ts_malloc(new_capacity * element_size);
     }
-    *capacity = new_capacity;
+    self->capacity = new_capacity;
   }
-  return new_contents;
 }
 
 /// This is not what you're looking for, see `array_assign`.
-static inline void *_array__assign(void* self_contents, uint32_t *self_size, uint32_t *self_capacity,
-                                 const void *other_contents, uint32_t other_size, size_t element_size) {
-  void *new_contents = _array__reserve(self_contents, self_capacity, element_size, other_size);
-  *self_size = other_size;
-  memcpy(new_contents, other_contents, *self_size * element_size);
-  return new_contents;
+static inline void _array__assign(Array *self, const Array *other, size_t element_size) {
+  _array__reserve(self, element_size, other->size);
+  self->size = other->size;
+  memcpy(self->contents, other->contents, self->size * element_size);
 }
 
-struct Swap {
-  void *self_contents;
-  void *other_contents;
-};
-
 /// This is not what you're looking for, see `array_swap`.
-// static inline void _array__swap(Array *self, Array *other) {
-static inline struct Swap _array__swap(void *self_contents, uint32_t *self_size, uint32_t *self_capacity,
-                               void *other_contents, uint32_t *other_size, uint32_t *other_capacity) {
-  void *new_self_contents = other_contents;
-  uint32_t new_self_size = *other_size;
-  uint32_t new_self_capacity = *other_capacity;
-
-  void *new_other_contents = self_contents;
-  *other_size = *self_size;
-  *other_capacity = *self_capacity;
-
-  *self_size = new_self_size;
-  *self_capacity = new_self_capacity;
-
-  struct Swap out = {
-    .self_contents = new_self_contents,
-    .other_contents = new_other_contents,
-  };
-  return out;
+static inline void _array__swap(Array *self, Array *other) {
+  Array swap = *other;
+  *other = *self;
+  *self = swap;
 }
 
 /// This is not what you're looking for, see `array_push` or `array_grow_by`.
-static inline void *_array__grow(void *contents, uint32_t size, uint32_t *capacity,
-                               uint32_t count, size_t element_size) {
-  void *new_contents = contents;
-  uint32_t new_size = size + count;
-  if (new_size > *capacity) {
-    uint32_t new_capacity = *capacity * 2;
+static inline void _array__grow(Array *self, uint32_t count, size_t element_size) {
+  uint32_t new_size = self->size + count;
+  if (new_size > self->capacity) {
+    uint32_t new_capacity = self->capacity * 2;
     if (new_capacity < 8) new_capacity = 8;
     if (new_capacity < new_size) new_capacity = new_size;
-    new_contents = _array__reserve(contents, capacity, element_size, new_capacity);
+    _array__reserve(self, element_size, new_capacity);
   }
-  return new_contents;
 }
 
 /// This is not what you're looking for, see `array_splice`.
-static inline void *_array__splice(void *self_contents, uint32_t *size, uint32_t *capacity,
-                                 size_t element_size,
+static inline void _array__splice(Array *self, size_t element_size,
                                  uint32_t index, uint32_t old_count,
                                  uint32_t new_count, const void *elements) {
-  uint32_t new_size = *size + new_count - old_count;
+  uint32_t new_size = self->size + new_count - old_count;
   uint32_t old_end = index + old_count;
   uint32_t new_end = index + new_count;
-  assert(old_end <= *size);
+  assert(old_end <= self->size);
 
-  void *new_contents = _array__reserve(self_contents, capacity, element_size, new_size);
+  _array__reserve(self, element_size, new_size);
 
-  char *contents = (char *)new_contents;
-  if (*size > old_end) {
+  char *contents = (char *)self->contents;
+  if (self->size > old_end) {
     memmove(
       contents + new_end * element_size,
       contents + old_end * element_size,
-      (*size - old_end) * element_size
+      (self->size - old_end) * element_size
     );
   }
   if (new_count > 0) {
@@ -304,9 +250,7 @@ static inline void *_array__splice(void *self_contents, uint32_t *size, uint32_t
       );
     }
   }
-  *size += new_count - old_count;
-
-  return new_contents;
+  self->size += new_count - old_count;
 }
 
 /// A binary search routine, based on Rust's `std::slice::binary_search_by`.

package/tree-sitter.json

@@ -12,7 +12,7 @@
     }
   ],
   "metadata": {
-    "version": "0.3.5",
+    "version": "0.3.6",
     "license": "ISC",
     "description": "subject-oriented notation for structured data",
     "links": {