Rename type ts_symbol -> TSSymbol

include/tree_sitter/parser/lexer.h

@@ -59,7 +59,7 @@ static inline void ts_lexer_start_token(ts_lexer *lexer) {
     lexer->token_start_position = ts_lexer_position(lexer);
 }
 
-static inline TSTree * ts_lexer_build_node(ts_lexer *lexer, ts_symbol symbol) {
+static inline TSTree * ts_lexer_build_node(ts_lexer *lexer, TSSymbol symbol) {
     size_t current_position = ts_lexer_position(lexer);
     size_t size = current_position - lexer->token_start_position;
     size_t offset = lexer->token_start_position - lexer->token_end_position;

include/tree_sitter/parser/lr_parser.h

@@ -21,7 +21,7 @@ typedef struct {
     union {
         TSStateId to_state;
         struct {
-            ts_symbol symbol;
+            TSSymbol symbol;
             unsigned short child_count;
         };
     } data;

include/tree_sitter/parser/stack.h

@@ -20,7 +20,7 @@ typedef struct {
 
 ts_stack ts_stack_make();
 void ts_stack_delete(ts_stack *);
-TSTree * ts_stack_reduce(ts_stack *stack, ts_symbol symbol, size_t immediate_child_count, const int *hidden_symbol_flags, int gather_extras);
+TSTree * ts_stack_reduce(ts_stack *stack, TSSymbol symbol, size_t immediate_child_count, const int *hidden_symbol_flags, int gather_extras);
 void ts_stack_shrink(ts_stack *stack, size_t new_size);
 void ts_stack_push(ts_stack *stack, TSStateId state, TSTree *node);
 TSStateId ts_stack_top_state(const ts_stack *stack);

include/tree_sitter/runtime.h

@@ -7,15 +7,15 @@ extern "C" {
 
 #include <stdlib.h>
 
-typedef unsigned short ts_symbol;
+typedef unsigned short TSSymbol;
 #define ts_builtin_sym_error 0
 #define ts_builtin_sym_end 1
 #define ts_start_sym 2
 
 typedef struct TSTree TSTree;
-TSTree * ts_tree_make_leaf(ts_symbol symbol, size_t size, size_t offset);
-TSTree * ts_tree_make_node(ts_symbol symbol, size_t child_count, size_t immediate_child_count, TSTree **children);
-TSTree * ts_tree_make_error(char lookahead_char, size_t expected_input_count, const ts_symbol *expected_inputs, size_t size, size_t offset);
+TSTree * ts_tree_make_leaf(TSSymbol symbol, size_t size, size_t offset);
+TSTree * ts_tree_make_node(TSSymbol symbol, size_t child_count, size_t immediate_child_count, TSTree **children);
+TSTree * ts_tree_make_error(char lookahead_char, size_t expected_input_count, const TSSymbol *expected_inputs, size_t size, size_t offset);
 void ts_tree_retain(TSTree *tree);
 void ts_tree_release(TSTree *tree);
 int ts_tree_equals(const TSTree *tree1, const TSTree *tree2);
@@ -26,7 +26,7 @@ TSTree ** ts_tree_immediate_children(const TSTree *tree, size_t *count);
 size_t ts_tree_size(const TSTree *tree);
 size_t ts_tree_offset(const TSTree *tree);
 size_t ts_tree_total_size(const TSTree *tree);
-ts_symbol ts_tree_symbol(const TSTree *tree);
+TSSymbol ts_tree_symbol(const TSTree *tree);
 
 typedef struct {
     void *data;

src/runtime/lr_parser.c

@@ -16,7 +16,7 @@ void shift(ts_lr_parser *parser, TSStateId parse_state, int is_extra) {
     parser->next_lookahead = NULL;
 }
 
-void reduce(ts_lr_parser *parser, ts_symbol symbol, size_t child_count) {
+void reduce(ts_lr_parser *parser, TSSymbol symbol, size_t child_count) {
     parser->next_lookahead = parser->lookahead;
     parser->lookahead = ts_stack_reduce(&parser->stack,
                                         symbol,
@@ -58,7 +58,7 @@ static size_t breakdown_stack(ts_lr_parser *parser, ts_input_edit *edit) {
     return position;
 }
 
-ts_symbol * expected_symbols(ts_lr_parser *parser, size_t *count) {
+TSSymbol * expected_symbols(ts_lr_parser *parser, size_t *count) {
     *count = 0;
     const ts_parse_action *actions = actions_for_state(parser, ts_stack_top_state(&parser->stack));
     for (size_t i = 0; i < parser->config.symbol_count; i++)
@@ -66,8 +66,8 @@ ts_symbol * expected_symbols(ts_lr_parser *parser, size_t *count) {
             ++(*count);
 
     size_t n = 0;
-    ts_symbol *result = malloc(*count * sizeof(*result));
-    for (ts_symbol i = 0; i < parser->config.symbol_count; i++)
+    TSSymbol *result = malloc(*count * sizeof(*result));
+    for (TSSymbol i = 0; i < parser->config.symbol_count; i++)
         if (actions[i].type != ts_parse_action_type_error)
             result[n++] = i;
 
@@ -76,7 +76,7 @@ ts_symbol * expected_symbols(ts_lr_parser *parser, size_t *count) {
 
 int handle_error(ts_lr_parser *parser) {
     size_t count = 0;
-    const ts_symbol *inputs = expected_symbols(parser, &count);
+    const TSSymbol *inputs = expected_symbols(parser, &count);
     TSTree *error = ts_tree_make_error(ts_lexer_lookahead_char(&parser->lexer),
                                         count,
                                         inputs,

src/runtime/stack.c

@@ -52,7 +52,7 @@ size_t ts_stack_right_position(const ts_stack *stack) {
 }
 
 TSTree * ts_stack_reduce(ts_stack *stack,
-                          ts_symbol symbol,
+                          TSSymbol symbol,
                           size_t immediate_child_count,
                           const int *hidden_symbol_flags,
                           int gather_extra) {
@@ -69,7 +69,7 @@ TSTree * ts_stack_reduce(ts_stack *stack,
         TSTree *child = stack->entries[stack_index].node;
         size_t grandchild_count;
         TSTree **grandchildren = ts_tree_children(child, &grandchild_count);
-        ts_symbol child_symbol = ts_tree_symbol(child);
+        TSSymbol child_symbol = ts_tree_symbol(child);
 
         collapse_flags[i] = (
             hidden_symbol_flags[child_symbol] ||

src/runtime/tree.c

@@ -3,7 +3,7 @@
 #include <stdio.h>
 #include "runtime/tree.h"
 
-static TSTree * ts_tree_make(ts_symbol symbol, size_t size, size_t offset) {
+static TSTree * ts_tree_make(TSSymbol symbol, size_t size, size_t offset) {
     TSTree *result = malloc(sizeof(TSTree));
     *result = (TSTree) {
         .ref_count = 1,
@@ -14,7 +14,7 @@ static TSTree * ts_tree_make(ts_symbol symbol, size_t size, size_t offset) {
     return result;
 }
 
-TSTree * ts_tree_make_leaf(ts_symbol symbol, size_t size, size_t offset) {
+TSTree * ts_tree_make_leaf(TSSymbol symbol, size_t size, size_t offset) {
     TSTree *result = ts_tree_make(symbol, size, offset);
     result->data.children.count = 0;
     result->data.children.immediate_count = 0;
@@ -22,7 +22,7 @@ TSTree * ts_tree_make_leaf(ts_symbol symbol, size_t size, size_t offset) {
     return result;
 }
 
-TSTree * ts_tree_make_node(ts_symbol symbol, size_t child_count, size_t immediate_child_count, TSTree **children) {
+TSTree * ts_tree_make_node(TSSymbol symbol, size_t child_count, size_t immediate_child_count, TSTree **children) {
     TSTree **immediate_children = children + child_count;
     size_t size = 0, offset = 0;
     for (size_t i = 0; i < immediate_child_count; i++) {
@@ -42,7 +42,7 @@ TSTree * ts_tree_make_node(ts_symbol symbol, size_t child_count, size_t immediat
     return result;
 }
 
-TSTree * ts_tree_make_error(char lookahead_char, size_t expected_input_count, const ts_symbol *expected_inputs, size_t size, size_t offset) {
+TSTree * ts_tree_make_error(char lookahead_char, size_t expected_input_count, const TSSymbol *expected_inputs, size_t size, size_t offset) {
     TSTree *result = ts_tree_make(ts_builtin_sym_error, size, offset);
     result->data.error.lookahead_char = lookahead_char;
     result->data.error.expected_input_count = expected_input_count;
@@ -50,7 +50,7 @@ TSTree * ts_tree_make_error(char lookahead_char, size_t expected_input_count, co
     return result;
 }
 
-ts_symbol ts_tree_symbol(const TSTree *tree) {
+TSSymbol ts_tree_symbol(const TSTree *tree) {
     return tree->symbol;
 }
 

src/runtime/tree.h

@@ -4,7 +4,7 @@
 #include "tree_sitter/runtime.h"
 
 struct TSTree {
-    ts_symbol symbol;
+    TSSymbol symbol;
     size_t ref_count;
     size_t offset;
     size_t size;
@@ -18,7 +18,7 @@ struct TSTree {
         struct {
             char lookahead_char;
             size_t expected_input_count;
-            const ts_symbol *expected_inputs;
+            const TSSymbol *expected_inputs;
         } error;
     } data;
 };