traxys/tree-sitter
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename ts_subtree_make_* -> ts_subtree_new_*

Browse source
This commit is contained in:
Max Brunsfeld 2018-05-11 13:02:12 -07:00
parent bf1bb1604f
commit 20c183b7cd
5 changed files with 66 additions and 70 deletions
Download patch file Download diff file Expand all files Collapse all files

26
src/runtime/parser.c
View file

@ -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,

28
src/runtime/subtree.c
View file

@ -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) {

16
src/runtime/subtree.h
View file

@ -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);
}

2
test/runtime/stack_test.cc
View file

@ -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);
}
});

64
test/runtime/subtree_test.cc
View file

@ -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<Length>({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);