From 20c183b7cd7f33a61923b647ddd238f8721db748 Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Fri, 11 May 2018 13:02:12 -0700 Subject: [PATCH] Rename ts_subtree_make_* -> ts_subtree_new_* --- src/runtime/parser.c | 26 +++++++-------- src/runtime/subtree.c | 28 ++++++++-------- src/runtime/subtree.h | 16 ++++----- test/runtime/stack_test.cc | 2 +- test/runtime/subtree_test.cc | 64 ++++++++++++++++++------------------ 5 files changed, 66 insertions(+), 70 deletions(-) diff --git a/src/runtime/parser.c b/src/runtime/parser.c index 2115435e..8332501b 100644 --- a/src/runtime/parser.c +++ b/src/runtime/parser.c @@ -358,7 +358,7 @@ static Subtree *ts_parser__lex(TSParser *self, StackVersion version, TSStateId p if (skipped_error) { Length padding = length_sub(error_start_position, start_position); Length size = length_sub(error_end_position, error_start_position); - result = ts_subtree_make_error(&self->tree_pool, size, padding, first_error_character, self->language); + result = ts_subtree_new_error(&self->tree_pool, size, padding, first_error_character, self->language); } else { if (self->lexer.token_end_position.bytes < self->lexer.token_start_position.bytes) { self->lexer.token_start_position = self->lexer.token_end_position; @@ -383,7 +383,7 @@ static Subtree *ts_parser__lex(TSParser *self, StackVersion version, TSStateId p } } - result = ts_subtree_make_leaf(&self->tree_pool, symbol, padding, size, self->language); + result = ts_subtree_new_leaf(&self->tree_pool, symbol, padding, size, self->language); if (found_external_token) { result->has_external_tokens = true; @@ -577,7 +577,7 @@ static void ts_parser__shift(TSParser *self, StackVersion version, TSStateId sta Subtree *lookahead, bool extra) { if (extra != lookahead->extra) { if (ts_stack_version_count(self->stack) > 1) { - lookahead = ts_subtree_make_copy(&self->tree_pool, lookahead); + lookahead = ts_subtree_new_copy(&self->tree_pool, lookahead); } else { ts_subtree_retain(lookahead); } @@ -625,7 +625,7 @@ static StackSliceArray ts_parser__reduce(TSParser *self, StackVersion version, T children.size--; } - Subtree *parent = ts_subtree_make_node(&self->tree_pool, + Subtree *parent = ts_subtree_new_node(&self->tree_pool, symbol, &children, alias_sequence_id, self->language ); @@ -735,7 +735,7 @@ static void ts_parser__accept(TSParser *self, StackVersion version, Subtree *loo ts_subtree_retain(child->children.contents[k]); } array_splice(&trees, j, 1, &child->children); - root = ts_subtree_make_node( + root = ts_subtree_new_node( &self->tree_pool, child->symbol, &trees, child->alias_sequence_id, self->language ); @@ -875,7 +875,7 @@ static void ts_parser__handle_error(TSParser *self, StackVersion version, lookahead_symbol )) { StackVersion version_with_missing_tree = ts_stack_copy_version(self->stack, v); - Subtree *missing_tree = ts_subtree_make_missing_leaf(&self->tree_pool, missing_symbol, self->language); + Subtree *missing_tree = ts_subtree_new_missing_leaf(&self->tree_pool, missing_symbol, self->language); ts_stack_push( self->stack, version_with_missing_tree, missing_tree, false, @@ -920,15 +920,15 @@ static void ts_parser__halt_parse(TSParser *self) { ts_stack_position(self->stack, 0) ); - Subtree *filler_node = ts_subtree_make_error(&self->tree_pool, remaining_length, length_zero(), 0, self->language); + Subtree *filler_node = ts_subtree_new_error(&self->tree_pool, remaining_length, length_zero(), 0, self->language); filler_node->visible = false; ts_stack_push(self->stack, 0, filler_node, false, 0); SubtreeArray children = array_new(); - Subtree *root_error = ts_subtree_make_error_node(&self->tree_pool, &children, self->language); + Subtree *root_error = ts_subtree_new_error_node(&self->tree_pool, &children, self->language); ts_stack_push(self->stack, 0, root_error, false, 0); - Subtree *eof = ts_subtree_make_leaf(&self->tree_pool, ts_builtin_sym_end, length_zero(), length_zero(), self->language); + Subtree *eof = ts_subtree_new_leaf(&self->tree_pool, ts_builtin_sym_end, length_zero(), length_zero(), self->language); ts_parser__accept(self, 0, eof); ts_subtree_release(&self->tree_pool, eof); } @@ -967,7 +967,7 @@ static bool ts_parser__recover_to_state(TSParser *self, StackVersion version, un SubtreeArray trailing_extras = ts_subtree_array_remove_trailing_extras(&slice.subtrees); if (slice.subtrees.size > 0) { - Subtree *error = ts_subtree_make_error_node(&self->tree_pool, &slice.subtrees, self->language); + Subtree *error = ts_subtree_new_error_node(&self->tree_pool, &slice.subtrees, self->language); error->extra = true; ts_stack_push(self->stack, slice.version, error, false, goal_state); } else { @@ -1048,7 +1048,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree *lo if (lookahead->symbol == ts_builtin_sym_end) { LOG("recover_eof"); SubtreeArray children = array_new(); - Subtree *parent = ts_subtree_make_error_node(&self->tree_pool, &children, self->language); + Subtree *parent = ts_subtree_new_error_node(&self->tree_pool, &children, self->language); ts_stack_push(self->stack, version, parent, false, 1); ts_parser__accept(self, version, lookahead); return; @@ -1075,7 +1075,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree *lo SubtreeArray children = array_new(); array_reserve(&children, 1); array_push(&children, lookahead); - Subtree *error_repeat = ts_subtree_make_node( + Subtree *error_repeat = ts_subtree_new_node( &self->tree_pool, ts_builtin_sym_error_repeat, &children, @@ -1089,7 +1089,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree *lo assert(pop.contents[0].subtrees.size == 1); ts_stack_renumber_version(self->stack, pop.contents[0].version, version); array_push(&pop.contents[0].subtrees, error_repeat); - error_repeat = ts_subtree_make_node( + error_repeat = ts_subtree_new_node( &self->tree_pool, ts_builtin_sym_error_repeat, &pop.contents[0].subtrees, diff --git a/src/runtime/subtree.c b/src/runtime/subtree.c index c3da95c5..0cd125bf 100644 --- a/src/runtime/subtree.c +++ b/src/runtime/subtree.c @@ -141,7 +141,7 @@ void ts_subtree_pool_free(SubtreePool *self, Subtree *tree) { // Subtree -Subtree *ts_subtree_make_leaf(SubtreePool *pool, TSSymbol symbol, Length padding, Length size, +Subtree *ts_subtree_new_leaf(SubtreePool *pool, TSSymbol symbol, Length padding, Length size, const TSLanguage *language) { TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol); Subtree *result = ts_subtree_pool_allocate(pool); @@ -166,16 +166,16 @@ Subtree *ts_subtree_make_leaf(SubtreePool *pool, TSSymbol symbol, Length padding return result; } -Subtree *ts_subtree_make_error(SubtreePool *pool, Length size, Length padding, +Subtree *ts_subtree_new_error(SubtreePool *pool, Length size, Length padding, int32_t lookahead_char, const TSLanguage *language) { - Subtree *result = ts_subtree_make_leaf(pool, ts_builtin_sym_error, padding, size, language); + Subtree *result = ts_subtree_new_leaf(pool, ts_builtin_sym_error, padding, size, language); result->fragile_left = true; result->fragile_right = true; result->lookahead_char = lookahead_char; return result; } -Subtree *ts_subtree_make_copy(SubtreePool *pool, Subtree *self) { +Subtree *ts_subtree_new_copy(SubtreePool *pool, Subtree *self) { Subtree *result = ts_subtree_pool_allocate(pool); *result = *self; if (result->children.size > 0) { @@ -185,11 +185,11 @@ Subtree *ts_subtree_make_copy(SubtreePool *pool, Subtree *self) { return result; } -static Subtree *ts_subtree_make_mut(SubtreePool *pool, Subtree *self) { +static Subtree *ts_subtree_new_mut(SubtreePool *pool, Subtree *self) { if (self->ref_count == 1) { return self; } else { - Subtree *result = ts_subtree_make_copy(pool, self); + Subtree *result = ts_subtree_new_copy(pool, self); ts_subtree_release(pool, self); return result; } @@ -360,9 +360,9 @@ void ts_subtree_set_children(Subtree *self, SubtreeArray *children, const TSLang } } -Subtree *ts_subtree_make_node(SubtreePool *pool, TSSymbol symbol, SubtreeArray *children, +Subtree *ts_subtree_new_node(SubtreePool *pool, TSSymbol symbol, SubtreeArray *children, unsigned alias_sequence_id, const TSLanguage *language) { - Subtree *result = ts_subtree_make_leaf(pool, symbol, length_zero(), length_zero(), language); + Subtree *result = ts_subtree_new_leaf(pool, symbol, length_zero(), length_zero(), language); result->alias_sequence_id = alias_sequence_id; if (symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat) { result->fragile_left = true; @@ -372,14 +372,14 @@ Subtree *ts_subtree_make_node(SubtreePool *pool, TSSymbol symbol, SubtreeArray * return result; } -Subtree *ts_subtree_make_error_node(SubtreePool *pool, SubtreeArray *children, +Subtree *ts_subtree_new_error_node(SubtreePool *pool, SubtreeArray *children, const TSLanguage *language) { - return ts_subtree_make_node(pool, ts_builtin_sym_error, children, 0, language); + return ts_subtree_new_node(pool, ts_builtin_sym_error, children, 0, language); } -Subtree *ts_subtree_make_missing_leaf(SubtreePool *pool, TSSymbol symbol, +Subtree *ts_subtree_new_missing_leaf(SubtreePool *pool, TSSymbol symbol, const TSLanguage *language) { - Subtree *result = ts_subtree_make_leaf(pool, symbol, length_zero(), length_zero(), language); + Subtree *result = ts_subtree_new_leaf(pool, symbol, length_zero(), length_zero(), language); result->is_missing = true; result->error_cost = ERROR_COST_PER_MISSING_TREE + ERROR_COST_PER_RECOVERY; return result; @@ -464,7 +464,7 @@ Subtree *ts_subtree_invalidate_lookahead(Subtree *self, uint32_t edit_byte_offse SubtreePool *pool) { if (edit_byte_offset >= self->bytes_scanned) return self; - Subtree *result = ts_subtree_make_mut(pool, self); + Subtree *result = ts_subtree_new_mut(pool, self); result->has_changes = true; if (result->children.size > 0) { @@ -484,7 +484,7 @@ Subtree *ts_subtree__edit(Subtree *self, Edit edit, SubtreePool *pool) { Length new_end = length_add(edit.start, edit.added); Length old_end = length_add(edit.start, edit.removed); - Subtree *result = ts_subtree_make_mut(pool, self); + Subtree *result = ts_subtree_new_mut(pool, self); result->has_changes = true; if (old_end.bytes <= result->padding.bytes) { diff --git a/src/runtime/subtree.h b/src/runtime/subtree.h index 2f7d60b0..da69383d 100644 --- a/src/runtime/subtree.h +++ b/src/runtime/subtree.h @@ -88,12 +88,12 @@ void ts_subtree_pool_delete(SubtreePool *); Subtree *ts_subtree_pool_allocate(SubtreePool *); void ts_subtree_pool_free(SubtreePool *, Subtree *); -Subtree *ts_subtree_make_leaf(SubtreePool *, TSSymbol, Length, Length, const TSLanguage *); -Subtree *ts_subtree_make_node(SubtreePool *, TSSymbol, SubtreeArray *, unsigned, const TSLanguage *); -Subtree *ts_subtree_make_copy(SubtreePool *, Subtree *child); -Subtree *ts_subtree_make_error_node(SubtreePool *, SubtreeArray *, const TSLanguage *); -Subtree *ts_subtree_make_error(SubtreePool *, Length, Length, int32_t, const TSLanguage *); -Subtree *ts_subtree_make_missing_leaf(SubtreePool *, TSSymbol, const TSLanguage *); +Subtree *ts_subtree_new_leaf(SubtreePool *, TSSymbol, Length, Length, const TSLanguage *); +Subtree *ts_subtree_new_node(SubtreePool *, TSSymbol, SubtreeArray *, unsigned, const TSLanguage *); +Subtree *ts_subtree_new_copy(SubtreePool *, Subtree *child); +Subtree *ts_subtree_new_error_node(SubtreePool *, SubtreeArray *, const TSLanguage *); +Subtree *ts_subtree_new_error(SubtreePool *, Length, Length, int32_t, const TSLanguage *); +Subtree *ts_subtree_new_missing_leaf(SubtreePool *, TSSymbol, const TSLanguage *); void ts_subtree_retain(Subtree *tree); void ts_subtree_release(SubtreePool *, Subtree *tree); bool ts_subtree_eq(const Subtree *tree1, const Subtree *tree2); @@ -110,10 +110,6 @@ static inline uint32_t ts_subtree_total_bytes(const Subtree *self) { return self->padding.bytes + self->size.bytes; } -static inline uint32_t ts_subtree_total_rows(const Subtree *self) { - return self->padding.extent.row + self->size.extent.row; -} - static inline Length ts_subtree_total_size(const Subtree *self) { return length_add(self->padding, self->size); } diff --git a/test/runtime/stack_test.cc b/test/runtime/stack_test.cc index a6ec09c4..67812a07 100644 --- a/test/runtime/stack_test.cc +++ b/test/runtime/stack_test.cc @@ -84,7 +84,7 @@ describe("Stack", [&]() { dummy_language.symbol_metadata = symbol_metadata; for (size_t i = 0; i < subtree_count; i++) { - subtrees[i] = ts_subtree_make_leaf(&pool, i, length_zero(), tree_len, &dummy_language); + subtrees[i] = ts_subtree_new_leaf(&pool, i, length_zero(), tree_len, &dummy_language); } }); diff --git a/test/runtime/subtree_test.cc b/test/runtime/subtree_test.cc index 093e68db..4d32ec32 100644 --- a/test/runtime/subtree_test.cc +++ b/test/runtime/subtree_test.cc @@ -50,7 +50,7 @@ describe("Subtree", []() { describe("make_leaf", [&]() { it("does not mark the tree as fragile", [&]() { - Subtree *tree = ts_subtree_make_leaf(&pool, symbol1, {2, {0, 1}}, {5, {0, 4}}, &language); + Subtree *tree = ts_subtree_new_leaf(&pool, symbol1, {2, {0, 1}}, {5, {0, 4}}, &language); AssertThat(tree->fragile_left, IsFalse()); AssertThat(tree->fragile_right, IsFalse()); @@ -60,7 +60,7 @@ describe("Subtree", []() { describe("make_error", [&]() { it("marks the tree as fragile", [&]() { - Subtree *error_tree = ts_subtree_make_error( + Subtree *error_tree = ts_subtree_new_error( &pool, length_zero(), length_zero(), @@ -79,12 +79,12 @@ describe("Subtree", []() { Subtree *tree1, *tree2, *parent1; before_each([&]() { - tree1 = ts_subtree_make_leaf(&pool, symbol1, {2, {0, 1}}, {5, {0, 4}}, &language); - tree2 = ts_subtree_make_leaf(&pool, symbol2, {1, {0, 1}}, {3, {0, 3}}, &language); + tree1 = ts_subtree_new_leaf(&pool, symbol1, {2, {0, 1}}, {5, {0, 4}}, &language); + tree2 = ts_subtree_new_leaf(&pool, symbol2, {1, {0, 1}}, {3, {0, 3}}, &language); ts_subtree_retain(tree1); ts_subtree_retain(tree2); - parent1 = ts_subtree_make_node(&pool, symbol3, tree_array({ + parent1 = ts_subtree_new_node(&pool, symbol3, tree_array({ tree1, tree2, }), 0, &language); @@ -112,7 +112,7 @@ describe("Subtree", []() { ts_subtree_retain(tree1); ts_subtree_retain(tree2); - parent = ts_subtree_make_node(&pool, symbol3, tree_array({ + parent = ts_subtree_new_node(&pool, symbol3, tree_array({ tree1, tree2, }), 0, &language); @@ -136,7 +136,7 @@ describe("Subtree", []() { ts_subtree_retain(tree1); ts_subtree_retain(tree2); - parent = ts_subtree_make_node(&pool, symbol3, tree_array({ + parent = ts_subtree_new_node(&pool, symbol3, tree_array({ tree1, tree2, }), 0, &language); @@ -160,7 +160,7 @@ describe("Subtree", []() { ts_subtree_retain(tree1); ts_subtree_retain(tree2); - parent = ts_subtree_make_node(&pool, symbol3, tree_array({ + parent = ts_subtree_new_node(&pool, symbol3, tree_array({ tree1, tree2, }), 0, &language); @@ -181,10 +181,10 @@ describe("Subtree", []() { Subtree *tree; before_each([&]() { - tree = ts_subtree_make_node(&pool, symbol1, tree_array({ - ts_subtree_make_leaf(&pool, symbol2, {2, {0, 2}}, {3, {0, 3}}, &language), - ts_subtree_make_leaf(&pool, symbol3, {2, {0, 2}}, {3, {0, 3}}, &language), - ts_subtree_make_leaf(&pool, symbol4, {2, {0, 2}}, {3, {0, 3}}, &language), + tree = ts_subtree_new_node(&pool, symbol1, tree_array({ + ts_subtree_new_leaf(&pool, symbol2, {2, {0, 2}}, {3, {0, 3}}, &language), + ts_subtree_new_leaf(&pool, symbol3, {2, {0, 2}}, {3, {0, 3}}, &language), + ts_subtree_new_leaf(&pool, symbol4, {2, {0, 2}}, {3, {0, 3}}, &language), }), 0, &language); AssertThat(tree->padding, Equals({2, {0, 2}})); @@ -373,7 +373,7 @@ describe("Subtree", []() { Subtree *leaf; before_each([&]() { - leaf = ts_subtree_make_leaf(&pool, symbol1, {2, {0, 1}}, {5, {0, 4}}, &language); + leaf = ts_subtree_new_leaf(&pool, symbol1, {2, {0, 1}}, {5, {0, 4}}, &language); }); after_each([&]() { @@ -381,17 +381,17 @@ describe("Subtree", []() { }); it("returns true for identical trees", [&]() { - Subtree *leaf_copy = ts_subtree_make_leaf(&pool, symbol1, {2, {1, 1}}, {5, {1, 4}}, &language); + Subtree *leaf_copy = ts_subtree_new_leaf(&pool, symbol1, {2, {1, 1}}, {5, {1, 4}}, &language); AssertThat(ts_subtree_eq(leaf, leaf_copy), IsTrue()); - Subtree *parent = ts_subtree_make_node(&pool, symbol2, tree_array({ + Subtree *parent = ts_subtree_new_node(&pool, symbol2, tree_array({ leaf, leaf_copy, }), 0, &language); ts_subtree_retain(leaf); ts_subtree_retain(leaf_copy); - Subtree *parent_copy = ts_subtree_make_node(&pool, symbol2, tree_array({ + Subtree *parent_copy = ts_subtree_new_node(&pool, symbol2, tree_array({ leaf, leaf_copy, }), 0, &language); @@ -406,7 +406,7 @@ describe("Subtree", []() { }); it("returns false for trees with different symbols", [&]() { - Subtree *different_leaf = ts_subtree_make_leaf( + Subtree *different_leaf = ts_subtree_new_leaf( &pool, leaf->symbol + 1, leaf->padding, @@ -419,33 +419,33 @@ describe("Subtree", []() { }); it("returns false for trees with different options", [&]() { - Subtree *different_leaf = ts_subtree_make_leaf(&pool, leaf->symbol, leaf->padding, leaf->size, &language); + Subtree *different_leaf = ts_subtree_new_leaf(&pool, leaf->symbol, leaf->padding, leaf->size, &language); different_leaf->visible = !leaf->visible; AssertThat(ts_subtree_eq(leaf, different_leaf), IsFalse()); ts_subtree_release(&pool, different_leaf); }); it("returns false for trees with different paddings or sizes", [&]() { - Subtree *different_leaf = ts_subtree_make_leaf(&pool, leaf->symbol, {}, leaf->size, &language); + Subtree *different_leaf = ts_subtree_new_leaf(&pool, leaf->symbol, {}, leaf->size, &language); AssertThat(ts_subtree_eq(leaf, different_leaf), IsFalse()); ts_subtree_release(&pool, different_leaf); - different_leaf = ts_subtree_make_leaf(&pool, symbol1, leaf->padding, {}, &language); + different_leaf = ts_subtree_new_leaf(&pool, symbol1, leaf->padding, {}, &language); AssertThat(ts_subtree_eq(leaf, different_leaf), IsFalse()); ts_subtree_release(&pool, different_leaf); }); it("returns false for trees with different children", [&]() { - Subtree *leaf2 = ts_subtree_make_leaf(&pool, symbol2, {1, {0, 1}}, {3, {0, 3}}, &language); + Subtree *leaf2 = ts_subtree_new_leaf(&pool, symbol2, {1, {0, 1}}, {3, {0, 3}}, &language); - Subtree *parent = ts_subtree_make_node(&pool, symbol2, tree_array({ + Subtree *parent = ts_subtree_new_node(&pool, symbol2, tree_array({ leaf, leaf2, }), 0, &language); ts_subtree_retain(leaf); ts_subtree_retain(leaf2); - Subtree *different_parent = ts_subtree_make_node(&pool, symbol2, tree_array({ + Subtree *different_parent = ts_subtree_new_node(&pool, symbol2, tree_array({ leaf2, leaf, }), 0, &language); @@ -473,17 +473,17 @@ describe("Subtree", []() { it("returns the last serialized external token state in the given tree", [&]() { Subtree *tree1, *tree2, *tree3, *tree4, *tree5, *tree6, *tree7, *tree8, *tree9; - tree1 = ts_subtree_make_node(&pool, symbol1, tree_array({ - (tree2 = ts_subtree_make_node(&pool, symbol2, tree_array({ - (tree3 = make_external(ts_subtree_make_leaf(&pool, symbol3, padding, size, &language))), - (tree4 = ts_subtree_make_leaf(&pool, symbol4, padding, size, &language)), - (tree5 = ts_subtree_make_leaf(&pool, symbol5, padding, size, &language)), + tree1 = ts_subtree_new_node(&pool, symbol1, tree_array({ + (tree2 = ts_subtree_new_node(&pool, symbol2, tree_array({ + (tree3 = make_external(ts_subtree_new_leaf(&pool, symbol3, padding, size, &language))), + (tree4 = ts_subtree_new_leaf(&pool, symbol4, padding, size, &language)), + (tree5 = ts_subtree_new_leaf(&pool, symbol5, padding, size, &language)), }), 0, &language)), - (tree6 = ts_subtree_make_node(&pool, symbol6, tree_array({ - (tree7 = ts_subtree_make_node(&pool, symbol7, tree_array({ - (tree8 = ts_subtree_make_leaf(&pool, symbol8, padding, size, &language)), + (tree6 = ts_subtree_new_node(&pool, symbol6, tree_array({ + (tree7 = ts_subtree_new_node(&pool, symbol7, tree_array({ + (tree8 = ts_subtree_new_leaf(&pool, symbol8, padding, size, &language)), }), 0, &language)), - (tree9 = ts_subtree_make_leaf(&pool, symbol9, padding, size, &language)), + (tree9 = ts_subtree_new_leaf(&pool, symbol9, padding, size, &language)), }), 0, &language)), }), 0, &language);