Make tree struct private

src/runtime/document.c

@@ -38,7 +38,7 @@ void ts_document_edit(ts_document *document, ts_input_edit edit) {
 }
 
 const char * ts_document_symbol_name(const ts_document *document, const ts_tree *tree) {
-    return document->parser.symbol_names[tree->symbol];
+    return document->parser.symbol_names[ts_tree_symbol(tree)];
 }
 
 typedef struct {

src/runtime/stack.c

@@ -53,7 +53,7 @@ size_t ts_stack_right_position(const ts_stack *stack) {
     size_t result = 0;
     for (size_t i = 0; i < stack->size; i++) {
         ts_tree *node = stack->entries[i].node;
-        result += node->offset + node->size;
+        result += ts_tree_total_size(node);
     }
     return result;
 }
@@ -65,12 +65,12 @@ ts_tree * ts_stack_reduce(ts_stack *stack, ts_symbol symbol, int child_count, co
     ts_tree **children = malloc(child_count * sizeof(ts_tree *));
     for (int i = 0; i < child_count; i++) {
         ts_tree *child = stack->entries[new_stack_size + i].node;
-        child->is_hidden = collapse_flags[i];
+        ts_tree_hide(child, collapse_flags[i]);
         if (i == 0) {
-            offset = child->offset;
-            size = child->size;
+            offset = ts_tree_offset(child);
+            size = ts_tree_size(child);
         } else {
-            size += child->offset + child->size;
+            size += ts_tree_total_size(child);
         }
 
         children[i] = child;

src/runtime/tree.c

@@ -2,10 +2,31 @@
 #include <string.h>
 #include <stdio.h>
 
+struct ts_tree {
+    ts_symbol symbol;
+    size_t ref_count;
+    size_t offset;
+    size_t size;
+    int is_hidden;
+    union {
+        struct {
+            size_t count;
+            size_t immediate_count;
+            struct ts_tree **contents;
+        } children;
+        struct {
+            char lookahead_char;
+            size_t expected_input_count;
+            const ts_symbol *expected_inputs;
+        } error;
+    } data;
+};
+
 static ts_tree * ts_tree_make(ts_symbol symbol, size_t size, size_t offset) {
     ts_tree *result = malloc(sizeof(ts_tree));
     *result = (ts_tree) {
         .ref_count = 1,
+        .is_hidden = 0,
         .symbol = symbol,
         .size = size,
         .offset = offset,
@@ -37,10 +58,30 @@ ts_tree * ts_tree_make_error(char lookahead_char, size_t expected_input_count, c
     return result;
 }
 
+ts_symbol ts_tree_symbol(const ts_tree *tree) {
+    return tree->symbol;
+}
+
 void ts_tree_retain(ts_tree *tree) {
     tree->ref_count++;
 }
 
+size_t ts_tree_offset(const ts_tree *tree) {
+    return tree->offset;
+}
+
+size_t ts_tree_size(const ts_tree *tree) {
+    return tree->size;
+}
+
+size_t ts_tree_total_size(const ts_tree *tree) {
+    return ts_tree_offset(tree) + ts_tree_size(tree);
+}
+
+void ts_tree_hide(ts_tree *tree, int hide) {
+    tree->is_hidden = hide;
+}
+
 void ts_tree_release(ts_tree *tree) {
     tree->ref_count--;
     if (tree->ref_count == 0) {