@gram-data/tree-sitter-gram 0.3.7 → 0.3.9

package/editors/zed/extension.toml

@@ -1,6 +1,6 @@
 id = "gram"
 name = "Gram Language Support"
-version = "0.3.7"
+version = "0.3.9"
 schema_version = 1
 authors = ["Gram Data Contributors"]
 description = "Support for Gram notation - composable data patterns"
@@ -12,5 +12,5 @@ capabilities = [
 
 # path = "grammars/tree-sitter-gram"
 [grammars.gram]
-repository = "https://github.com/gram-data/tree-sitter-gram"
-rev = "746afa9e990c3deca83dc2a2638877aef4bef4fa"
+repository = "file:///Users/akollegger/Developer/gram-data/tree-sitter-gram"
+rev = "v0.3.9"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gram-data/tree-sitter-gram",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "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 = 7,
+      .patch_version = 9,
     },
   };
   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.7",
+    "version": "0.3.9",
     "license": "ISC",
     "description": "subject-oriented notation for structured data",
     "links": {

package/editors/zed/languages/gram/highlights.scm

@@ -1,111 +0,0 @@
-; Strings
-(string_literal) @string
-(string_content) @string
-
-; Numbers
-(integer) @number
-(decimal) @number
-(hexadecimal) @number
-(octal) @number
-(measurement) @number
-
-; Boolean literals
-(boolean_literal) @boolean
-
-; Comment (FR-003)
-(comment) @comment
-
-; Tagged-string tag distinct from content (FR-002)
-(tagged_string tag: (symbol) @attribute)
-
-; Reference identifier: pattern_reference (FR-001)
-(pattern_reference identifier: (_) @variable)
-
-; Symbols and identifiers (generic; definition/reference/tag captured above)
-(symbol) @variable
-
-; Definition-like identifiers and labels (FR-001): @type
-; These must come AFTER generic symbol rule to take priority
-
-; Labels (symbols and quoted names in labels nodes)
-(labels (symbol) @type)
-(labels (quoted_name) @type)
-
-; Annotation identifiers and labels
-(identified_annotation identifier: (_) @type)
-(identified_annotation labels: (labels (symbol) @type))
-(identified_annotation labels: (labels (quoted_name) @type))
-
-; Subject, node, and relationship pattern definitions (FR-001): @type
-; subject/node subject is _subject (use wildcard _ as it may be hidden in some runtimes)
-(subject_pattern subject: (_ identifier: (_) @type))
-(subject_pattern subject: (_ labels: (labels (symbol) @type)))
-(subject_pattern subject: (_ labels: (labels (quoted_name) @type)))
-(node_pattern subject: (_ identifier: (_) @type))
-(node_pattern subject: (_ labels: (labels (symbol) @type)))
-(node_pattern subject: (_ labels: (labels (quoted_name) @type)))
-(relationship_pattern left: (node_pattern subject: (_ identifier: (_) @type)))
-(relationship_pattern left: (node_pattern subject: (_ labels: (labels (symbol) @type))))
-(relationship_pattern left: (node_pattern subject: (_ labels: (labels (quoted_name) @type))))
-(relationship_pattern right: (node_pattern subject: (_ identifier: (_) @type)))
-(relationship_pattern right: (node_pattern subject: (_ labels: (labels (symbol) @type))))
-(relationship_pattern right: (node_pattern subject: (_ labels: (labels (quoted_name) @type))))
-; Arrow kind: subject is inside optional brackets on the arrow
-(relationship_pattern kind: (right_arrow subject: (_ identifier: (_) @type)))
-(relationship_pattern kind: (right_arrow subject: (_ labels: (labels (symbol) @type))))
-(relationship_pattern kind: (right_arrow subject: (_ labels: (labels (quoted_name) @type))))
-(relationship_pattern kind: (left_arrow subject: (_ identifier: (_) @type)))
-(relationship_pattern kind: (left_arrow subject: (_ labels: (labels (symbol) @type))))
-(relationship_pattern kind: (left_arrow subject: (_ labels: (labels (quoted_name) @type))))
-(relationship_pattern kind: (undirected_arrow subject: (_ identifier: (_) @type)))
-(relationship_pattern kind: (undirected_arrow subject: (_ labels: (labels (symbol) @type))))
-(relationship_pattern kind: (undirected_arrow subject: (_ labels: (labels (quoted_name) @type))))
-(relationship_pattern kind: (bidirectional_arrow subject: (_ identifier: (_) @type)))
-(relationship_pattern kind: (bidirectional_arrow subject: (_ labels: (labels (symbol) @type))))
-(relationship_pattern kind: (bidirectional_arrow subject: (_ labels: (labels (quoted_name) @type))))
-
-; Keywords and operators
-[
-    "@"
-    "|"
-    ":"
-    "::"
-] @operator
-
-; Subject Patterns and delimiters
-[
-    "["
-    "]"
-    "("
-    ")"
-    "{"
-    "}"
-] @punctuation.bracket
-
-; Comma separator
-[
-    ","
-] @punctuation.delimiter
-
-; Field names in records and maps
-(record_property key: (symbol) @property)
-(record_property key: (quoted_name) @property)
-(record_property key: (double_quoted_name) @property)
-(map_entry key: (symbol) @property)
-(map_entry key: (quoted_name) @property)
-(map_entry key: (double_quoted_name) @property)
-
-; Annotation keys (property-style) and headers (identified/label-style)
-(property_annotation key: (symbol) @attribute)
-
-; Relationship arrows (special highlighting for graph syntax)
-(relationship_pattern) @keyword
-
-; Arrow operators in relationships
-(right_arrow) @operator
-(left_arrow) @operator
-(undirected_arrow) @operator
-(bidirectional_arrow) @operator
-
-; Error highlighting
-(ERROR) @error

package/editors/zed/languages/gram/indents.scm

@@ -1,14 +0,0 @@
-; Indentation: 2 spaces per level for brackets and multi-line structures
-; FR-007 — specs/004-editor-improvements/contracts/indents.md
-
-; Record {}
-"{" @indent
-"}" @indent.end
-
-; Subject pattern []
-"[" @indent
-"]" @indent.end
-
-; Node pattern ()
-"(" @indent
-")" @indent.end

package/editors/zed/languages/gram/injections.scm

@@ -1,29 +0,0 @@
-; Language injection for tagged strings: tag`content` and ```tag\ncontent\n```
-;
-; The tag symbol is used as the injection language so that downstream and editors
-; can support arbitrary tags without changing the grammar. Well-known tags (md, ts,
-; date, datetime, time, sql, json, html, etc.) are documented in docs/tagged-strings-and-injections.md.
-;
-; Overrides below map tags that do not match common parser names. The final
-; rule uses the tag's text as the language name for all other tags (e.g. "sql",
-; "json", "html" often match parser names).
-
-; md -> markdown
-(tagged_string
-  tag: (symbol) @_tag
-  content: (string_content) @injection.content)
-(#eq? @_tag "md")
-(#set! injection.language "markdown")
-
-; ts -> typescript
-(tagged_string
-  tag: (symbol) @_tag
-  content: (string_content) @injection.content)
-(#eq? @_tag "ts")
-(#set! injection.language "typescript")
-
-; Dynamic: use tag text as language name for all other tags (sql, json, html, etc.)
-; Editors may map additional tags (e.g. date, datetime, time) to parsers or leave as plain.
-(tagged_string
-  tag: (symbol) @injection.language
-  content: (string_content) @injection.content)

package/editors/zed/languages/gram/locals.scm

@@ -1,37 +0,0 @@
-; Locals: go to definition and highlight references (file scope)
-; FR-005, FR-006 — specs/004-editor-improvements/contracts/locals.md
-
-; File scope: all definitions and references in one scope
-(gram_pattern) @local.scope
-
-; Definitions: identifiers that define a pattern or annotation
-(subject_pattern subject: (_ identifier: (_) @local.definition))
-(subject_pattern subject: (_ labels: (labels (symbol) @local.definition)))
-(subject_pattern subject: (_ labels: (labels (quoted_name) @local.definition)))
-(node_pattern subject: (_ identifier: (_) @local.definition))
-(node_pattern subject: (_ labels: (labels (symbol) @local.definition)))
-(node_pattern subject: (_ labels: (labels (quoted_name) @local.definition)))
-(relationship_pattern left: (node_pattern subject: (_ identifier: (_) @local.definition)))
-(relationship_pattern left: (node_pattern subject: (_ labels: (labels (symbol) @local.definition))))
-(relationship_pattern left: (node_pattern subject: (_ labels: (labels (quoted_name) @local.definition))))
-(relationship_pattern right: (node_pattern subject: (_ identifier: (_) @local.definition)))
-(relationship_pattern right: (node_pattern subject: (_ labels: (labels (symbol) @local.definition))))
-(relationship_pattern right: (node_pattern subject: (_ labels: (labels (quoted_name) @local.definition))))
-(relationship_pattern kind: (right_arrow subject: (_ identifier: (_) @local.definition)))
-(relationship_pattern kind: (right_arrow subject: (_ labels: (labels (symbol) @local.definition))))
-(relationship_pattern kind: (right_arrow subject: (_ labels: (labels (quoted_name) @local.definition))))
-(relationship_pattern kind: (left_arrow subject: (_ identifier: (_) @local.definition)))
-(relationship_pattern kind: (left_arrow subject: (_ labels: (labels (symbol) @local.definition))))
-(relationship_pattern kind: (left_arrow subject: (_ labels: (labels (quoted_name) @local.definition))))
-(relationship_pattern kind: (undirected_arrow subject: (_ identifier: (_) @local.definition)))
-(relationship_pattern kind: (undirected_arrow subject: (_ labels: (labels (symbol) @local.definition))))
-(relationship_pattern kind: (undirected_arrow subject: (_ labels: (labels (quoted_name) @local.definition))))
-(relationship_pattern kind: (bidirectional_arrow subject: (_ identifier: (_) @local.definition)))
-(relationship_pattern kind: (bidirectional_arrow subject: (_ labels: (labels (symbol) @local.definition))))
-(relationship_pattern kind: (bidirectional_arrow subject: (_ labels: (labels (quoted_name) @local.definition))))
-(identified_annotation identifier: (_) @local.definition)
-(identified_annotation labels: (labels (symbol) @local.definition))
-(identified_annotation labels: (labels (quoted_name) @local.definition))
-
-; References: pattern_reference identifier
-(pattern_reference identifier: (_) @local.reference)