Declare subtrees as const wherever possible
Co-Authored-By: Rick Winfrey <rewinfrey@github.com>
This commit is contained in:
Max Brunsfeld
parent
6bb63f549f
commit
fe53506175
17 changed files with 244 additions and 222 deletions
|
|
@ -44,6 +44,10 @@ void free_slice_array(SubtreePool *pool, StackSliceArray *slices) {
|
|||
}
|
||||
}
|
||||
|
||||
Subtree *mutate(const Subtree *subtree) {
|
||||
return (Subtree *)subtree;
|
||||
}
|
||||
|
||||
struct StackEntry {
|
||||
TSStateId state;
|
||||
size_t depth;
|
||||
|
|
@ -69,7 +73,7 @@ START_TEST
|
|||
describe("Stack", [&]() {
|
||||
Stack *stack;
|
||||
const size_t subtree_count = 11;
|
||||
Subtree *subtrees[subtree_count];
|
||||
const Subtree *subtrees[subtree_count];
|
||||
Length tree_len = {3, {0, 3}};
|
||||
SubtreePool pool;
|
||||
|
||||
|
|
@ -84,7 +88,7 @@ describe("Stack", [&]() {
|
|||
dummy_language.symbol_metadata = symbol_metadata;
|
||||
|
||||
for (size_t i = 0; i < subtree_count; i++) {
|
||||
subtrees[i] = ts_subtree_new_leaf(&pool, i, length_zero(), tree_len, &dummy_language);
|
||||
subtrees[i] = ts_subtree_new_leaf(&pool, i + 1, length_zero(), tree_len, &dummy_language);
|
||||
}
|
||||
});
|
||||
|
||||
|
|
@ -99,7 +103,7 @@ describe("Stack", [&]() {
|
|||
AssertThat(record_alloc::outstanding_allocation_indices(), IsEmpty());
|
||||
});
|
||||
|
||||
auto push = [&](StackVersion version, Subtree *tree, TSStateId state) {
|
||||
auto push = [&](StackVersion version, const Subtree *tree, TSStateId state) {
|
||||
ts_subtree_retain(tree);
|
||||
ts_stack_push(stack, version, tree, false, state);
|
||||
};
|
||||
|
|
@ -181,7 +185,7 @@ describe("Stack", [&]() {
|
|||
// . <──0── A <──1── B <────3──── D*
|
||||
// ↑
|
||||
// └───2─── C <──4── D*
|
||||
subtrees[3]->size = tree_len * 3;
|
||||
mutate(subtrees[3])->size = tree_len * 3;
|
||||
push(0, subtrees[1], stateB);
|
||||
push(1, subtrees[2], stateC);
|
||||
push(0, subtrees[3], stateD);
|
||||
|
|
@ -224,8 +228,8 @@ describe("Stack", [&]() {
|
|||
// . <──0── A <────1──── B*
|
||||
// ↑
|
||||
// └2─ A <──1── B*
|
||||
subtrees[2]->extra = true;
|
||||
subtrees[2]->size = tree_len * 0;
|
||||
mutate(subtrees[2])->extra = true;
|
||||
mutate(subtrees[2])->size = tree_len * 0;
|
||||
|
||||
push(0, subtrees[1], stateB);
|
||||
push(1, subtrees[2], stateA);
|
||||
|
|
@ -261,14 +265,14 @@ describe("Stack", [&]() {
|
|||
|
||||
StackSlice slice = pop.contents[0];
|
||||
AssertThat(slice.version, Equals<StackVersion>(1));
|
||||
AssertThat(slice.subtrees, Equals(vector<Subtree *>({ subtrees[1], subtrees[2] })));
|
||||
AssertThat(slice.subtrees, Equals(vector<const Subtree *>({ subtrees[1], subtrees[2] })));
|
||||
AssertThat(ts_stack_state(stack, 1), Equals(stateA));
|
||||
|
||||
free_slice_array(&pool,&pop);
|
||||
});
|
||||
|
||||
it("does not count 'extra' subtrees toward the given count", [&]() {
|
||||
subtrees[1]->extra = true;
|
||||
mutate(subtrees[1])->extra = true;
|
||||
|
||||
// . <──0── A <──1── B <──2── C*
|
||||
// ↑
|
||||
|
|
@ -277,7 +281,7 @@ describe("Stack", [&]() {
|
|||
AssertThat(pop.size, Equals<size_t>(1));
|
||||
|
||||
StackSlice slice = pop.contents[0];
|
||||
AssertThat(slice.subtrees, Equals(vector<Subtree *>({ subtrees[0], subtrees[1], subtrees[2] })));
|
||||
AssertThat(slice.subtrees, Equals(vector<const Subtree *>({ subtrees[0], subtrees[1], subtrees[2] })));
|
||||
AssertThat(ts_stack_state(stack, 1), Equals(1));
|
||||
|
||||
free_slice_array(&pool,&pop);
|
||||
|
|
@ -322,11 +326,11 @@ describe("Stack", [&]() {
|
|||
|
||||
StackSlice slice1 = pop.contents[0];
|
||||
AssertThat(slice1.version, Equals<StackVersion>(1));
|
||||
AssertThat(slice1.subtrees, Equals(vector<Subtree *>({ subtrees[2], subtrees[3], subtrees[10] })));
|
||||
AssertThat(slice1.subtrees, Equals(vector<const Subtree *>({ subtrees[2], subtrees[3], subtrees[10] })));
|
||||
|
||||
StackSlice slice2 = pop.contents[1];
|
||||
AssertThat(slice2.version, Equals<StackVersion>(2));
|
||||
AssertThat(slice2.subtrees, Equals(vector<Subtree *>({ subtrees[5], subtrees[6], subtrees[10] })));
|
||||
AssertThat(slice2.subtrees, Equals(vector<const Subtree *>({ subtrees[5], subtrees[6], subtrees[10] })));
|
||||
|
||||
AssertThat(ts_stack_version_count(stack), Equals<size_t>(3));
|
||||
AssertThat(get_stack_entries(stack, 0), Equals(vector<StackEntry>({
|
||||
|
|
@ -366,7 +370,7 @@ describe("Stack", [&]() {
|
|||
|
||||
StackSlice slice1 = pop.contents[0];
|
||||
AssertThat(slice1.version, Equals<StackVersion>(1));
|
||||
AssertThat(slice1.subtrees, Equals(vector<Subtree *>({ subtrees[10] })));
|
||||
AssertThat(slice1.subtrees, Equals(vector<const Subtree *>({ subtrees[10] })));
|
||||
|
||||
AssertThat(ts_stack_version_count(stack), Equals<size_t>(2));
|
||||
AssertThat(ts_stack_state(stack, 0), Equals(stateI));
|
||||
|
|
@ -388,11 +392,11 @@ describe("Stack", [&]() {
|
|||
|
||||
StackSlice slice1 = pop.contents[0];
|
||||
AssertThat(slice1.version, Equals<StackVersion>(1));
|
||||
AssertThat(slice1.subtrees, Equals(vector<Subtree *>({ subtrees[1], subtrees[2], subtrees[3], subtrees[10] })));
|
||||
AssertThat(slice1.subtrees, Equals(vector<const Subtree *>({ subtrees[1], subtrees[2], subtrees[3], subtrees[10] })));
|
||||
|
||||
StackSlice slice2 = pop.contents[1];
|
||||
AssertThat(slice2.version, Equals<StackVersion>(1));
|
||||
AssertThat(slice2.subtrees, Equals(vector<Subtree *>({ subtrees[4], subtrees[5], subtrees[6], subtrees[10] })));
|
||||
AssertThat(slice2.subtrees, Equals(vector<const Subtree *>({ subtrees[4], subtrees[5], subtrees[6], subtrees[10] })));
|
||||
|
||||
AssertThat(ts_stack_version_count(stack), Equals<size_t>(2));
|
||||
AssertThat(ts_stack_state(stack, 0), Equals(stateI));
|
||||
|
|
@ -443,15 +447,15 @@ describe("Stack", [&]() {
|
|||
|
||||
StackSlice slice1 = pop.contents[0];
|
||||
AssertThat(slice1.version, Equals<StackVersion>(1));
|
||||
AssertThat(slice1.subtrees, Equals(vector<Subtree *>({ subtrees[3], subtrees[10] })));
|
||||
AssertThat(slice1.subtrees, Equals(vector<const Subtree *>({ subtrees[3], subtrees[10] })));
|
||||
|
||||
StackSlice slice2 = pop.contents[1];
|
||||
AssertThat(slice2.version, Equals<StackVersion>(2));
|
||||
AssertThat(slice2.subtrees, Equals(vector<Subtree *>({ subtrees[6], subtrees[10] })));
|
||||
AssertThat(slice2.subtrees, Equals(vector<const Subtree *>({ subtrees[6], subtrees[10] })));
|
||||
|
||||
StackSlice slice3 = pop.contents[2];
|
||||
AssertThat(slice3.version, Equals<StackVersion>(3));
|
||||
AssertThat(slice3.subtrees, Equals(vector<Subtree *>({ subtrees[9], subtrees[10] })));
|
||||
AssertThat(slice3.subtrees, Equals(vector<const Subtree *>({ subtrees[9], subtrees[10] })));
|
||||
|
||||
AssertThat(ts_stack_version_count(stack), Equals<size_t>(4));
|
||||
AssertThat(ts_stack_state(stack, 0), Equals(stateI));
|
||||
|
|
@ -489,8 +493,8 @@ describe("Stack", [&]() {
|
|||
ts_stack_push(stack, 0, subtrees[1], true, stateB);
|
||||
ts_subtree_retain(subtrees[1]);
|
||||
|
||||
subtrees[2]->extra = true;
|
||||
subtrees[3]->extra = true;
|
||||
mutate(subtrees[2])->extra = true;
|
||||
mutate(subtrees[3])->extra = true;
|
||||
|
||||
push(0, subtrees[2], stateB);
|
||||
push(0, subtrees[3], stateB);
|
||||
|
|
@ -498,7 +502,7 @@ describe("Stack", [&]() {
|
|||
StackSliceArray pop = ts_stack_pop_pending(stack, 0);
|
||||
AssertThat(pop.size, Equals<size_t>(1));
|
||||
|
||||
AssertThat(pop.contents[0].subtrees, Equals(vector<Subtree *>({ subtrees[1], subtrees[2], subtrees[3] })));
|
||||
AssertThat(pop.contents[0].subtrees, Equals(vector<const Subtree *>({ subtrees[1], subtrees[2], subtrees[3] })));
|
||||
|
||||
AssertThat(get_stack_entries(stack, 0), Equals(vector<StackEntry>({
|
||||
{stateA, 0},
|
||||
|
|
@ -526,10 +530,10 @@ describe("Stack", [&]() {
|
|||
|
||||
describe("setting external token state", [&]() {
|
||||
before_each([&]() {
|
||||
subtrees[1]->has_external_tokens = true;
|
||||
subtrees[2]->has_external_tokens = true;
|
||||
ts_external_scanner_state_init(&subtrees[1]->external_scanner_state, NULL, 0);
|
||||
ts_external_scanner_state_init(&subtrees[2]->external_scanner_state, NULL, 0);
|
||||
mutate(subtrees[1])->has_external_tokens = true;
|
||||
mutate(subtrees[2])->has_external_tokens = true;
|
||||
ts_external_scanner_state_init(&mutate(subtrees[1])->external_scanner_state, NULL, 0);
|
||||
ts_external_scanner_state_init(&mutate(subtrees[2])->external_scanner_state, NULL, 0);
|
||||
});
|
||||
|
||||
it("allows the state to be retrieved", [&]() {
|
||||
|
|
@ -546,8 +550,8 @@ describe("Stack", [&]() {
|
|||
});
|
||||
|
||||
it("does not merge stack versions with different external token states", [&]() {
|
||||
ts_external_scanner_state_init(&subtrees[1]->external_scanner_state, "abcd", 2);
|
||||
ts_external_scanner_state_init(&subtrees[2]->external_scanner_state, "ABCD", 2);
|
||||
ts_external_scanner_state_init(&mutate(subtrees[1])->external_scanner_state, "abcd", 2);
|
||||
ts_external_scanner_state_init(&mutate(subtrees[2])->external_scanner_state, "ABCD", 2);
|
||||
|
||||
ts_stack_copy_version(stack, 0);
|
||||
push(0, subtrees[0], 5);
|
||||
|
|
@ -560,8 +564,8 @@ describe("Stack", [&]() {
|
|||
});
|
||||
|
||||
it("merges stack versions with identical external token states", [&]() {
|
||||
ts_external_scanner_state_init(&subtrees[1]->external_scanner_state, "abcd", 2);
|
||||
ts_external_scanner_state_init(&subtrees[2]->external_scanner_state, "abcd", 2);
|
||||
ts_external_scanner_state_init(&mutate(subtrees[1])->external_scanner_state, "abcd", 2);
|
||||
ts_external_scanner_state_init(&mutate(subtrees[2])->external_scanner_state, "abcd", 2);
|
||||
|
||||
ts_stack_copy_version(stack, 0);
|
||||
push(0, subtrees[0], 5);
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ void assert_consistent(const Subtree *tree) {
|
|||
|
||||
Length total_children_size = length_zero();
|
||||
for (size_t i = 0; i < tree->children.size; i++) {
|
||||
Subtree *child = tree->children.contents[i];
|
||||
const Subtree *child = tree->children.contents[i];
|
||||
assert_consistent(child);
|
||||
total_children_size = length_add(total_children_size, ts_subtree_total_size(child));
|
||||
}
|
||||
|
|
@ -50,7 +50,7 @@ describe("Subtree", []() {
|
|||
|
||||
describe("make_leaf", [&]() {
|
||||
it("does not mark the tree as fragile", [&]() {
|
||||
Subtree *tree = ts_subtree_new_leaf(&pool, symbol1, {2, {0, 1}}, {5, {0, 4}}, &language);
|
||||
const 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_new_error(
|
||||
const Subtree *error_tree = ts_subtree_new_error(
|
||||
&pool,
|
||||
length_zero(),
|
||||
length_zero(),
|
||||
|
|
@ -76,7 +76,7 @@ describe("Subtree", []() {
|
|||
});
|
||||
|
||||
describe("make_node", [&]() {
|
||||
Subtree *tree1, *tree2, *parent1;
|
||||
const Subtree *tree1, *tree2, *parent1;
|
||||
|
||||
before_each([&]() {
|
||||
tree1 = ts_subtree_new_leaf(&pool, symbol1, {2, {0, 1}}, {5, {0, 4}}, &language);
|
||||
|
|
@ -104,11 +104,12 @@ describe("Subtree", []() {
|
|||
});
|
||||
|
||||
describe("when the first node is fragile on the left side", [&]() {
|
||||
Subtree *parent;
|
||||
const Subtree *parent;
|
||||
|
||||
before_each([&]() {
|
||||
tree1->fragile_left = true;
|
||||
tree1->extra = true;
|
||||
Subtree *mutable_tree1 = (Subtree *)tree1;
|
||||
mutable_tree1->fragile_left = true;
|
||||
mutable_tree1->extra = true;
|
||||
|
||||
ts_subtree_retain(tree1);
|
||||
ts_subtree_retain(tree2);
|
||||
|
|
@ -128,11 +129,12 @@ describe("Subtree", []() {
|
|||
});
|
||||
|
||||
describe("when the last node is fragile on the right side", [&]() {
|
||||
Subtree *parent;
|
||||
const Subtree *parent;
|
||||
|
||||
before_each([&]() {
|
||||
tree2->fragile_right = true;
|
||||
tree2->extra = true;
|
||||
Subtree *mutable_tree2 = (Subtree *)tree2;
|
||||
mutable_tree2->fragile_right = true;
|
||||
mutable_tree2->extra = true;
|
||||
|
||||
ts_subtree_retain(tree1);
|
||||
ts_subtree_retain(tree2);
|
||||
|
|
@ -152,11 +154,13 @@ describe("Subtree", []() {
|
|||
});
|
||||
|
||||
describe("when the outer nodes aren't fragile on their outer side", [&]() {
|
||||
Subtree *parent;
|
||||
const Subtree *parent;
|
||||
|
||||
before_each([&]() {
|
||||
tree1->fragile_right = true;
|
||||
tree2->fragile_left = true;
|
||||
Subtree *mutable_tree1 = (Subtree *)tree1;
|
||||
Subtree *mutable_tree2 = (Subtree *)tree2;
|
||||
mutable_tree1->fragile_right = true;
|
||||
mutable_tree2->fragile_left = true;
|
||||
|
||||
ts_subtree_retain(tree1);
|
||||
ts_subtree_retain(tree2);
|
||||
|
|
@ -178,7 +182,7 @@ describe("Subtree", []() {
|
|||
});
|
||||
|
||||
describe("edit", [&]() {
|
||||
Subtree *tree;
|
||||
const Subtree *tree;
|
||||
|
||||
before_each([&]() {
|
||||
tree = ts_subtree_new_node(&pool, symbol1, tree_array({
|
||||
|
|
@ -205,7 +209,7 @@ describe("Subtree", []() {
|
|||
edit.extent_added = {0, 1};
|
||||
|
||||
ts_subtree_retain(tree);
|
||||
Subtree *new_tree = ts_subtree_edit(tree, &edit, &pool);
|
||||
const Subtree *new_tree = ts_subtree_edit(tree, &edit, &pool);
|
||||
assert_consistent(tree);
|
||||
assert_consistent(new_tree);
|
||||
|
||||
|
|
@ -352,7 +356,8 @@ describe("Subtree", []() {
|
|||
|
||||
describe("edits within a tree's range of scanned bytes", [&]() {
|
||||
it("marks preceding trees as changed", [&]() {
|
||||
tree->children.contents[0]->bytes_scanned = 7;
|
||||
Subtree *mutable_child = (Subtree *)tree->children.contents[0];
|
||||
mutable_child->bytes_scanned = 7;
|
||||
|
||||
TSInputEdit edit;
|
||||
edit.start_byte = 6;
|
||||
|
|
@ -370,7 +375,7 @@ describe("Subtree", []() {
|
|||
});
|
||||
|
||||
describe("eq", [&]() {
|
||||
Subtree *leaf;
|
||||
const Subtree *leaf;
|
||||
|
||||
before_each([&]() {
|
||||
leaf = ts_subtree_new_leaf(&pool, symbol1, {2, {0, 1}}, {5, {0, 4}}, &language);
|
||||
|
|
@ -381,17 +386,17 @@ describe("Subtree", []() {
|
|||
});
|
||||
|
||||
it("returns true for identical trees", [&]() {
|
||||
Subtree *leaf_copy = ts_subtree_new_leaf(&pool, symbol1, {2, {1, 1}}, {5, {1, 4}}, &language);
|
||||
const 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_new_node(&pool, symbol2, tree_array({
|
||||
const 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_new_node(&pool, symbol2, tree_array({
|
||||
const Subtree *parent_copy = ts_subtree_new_node(&pool, symbol2, tree_array({
|
||||
leaf,
|
||||
leaf_copy,
|
||||
}), 0, &language);
|
||||
|
|
@ -406,7 +411,7 @@ describe("Subtree", []() {
|
|||
});
|
||||
|
||||
it("returns false for trees with different symbols", [&]() {
|
||||
Subtree *different_leaf = ts_subtree_new_leaf(
|
||||
const Subtree *different_leaf = ts_subtree_new_leaf(
|
||||
&pool,
|
||||
leaf->symbol + 1,
|
||||
leaf->padding,
|
||||
|
|
@ -419,14 +424,16 @@ describe("Subtree", []() {
|
|||
});
|
||||
|
||||
it("returns false for trees with different options", [&]() {
|
||||
Subtree *different_leaf = ts_subtree_new_leaf(&pool, leaf->symbol, leaf->padding, leaf->size, &language);
|
||||
different_leaf->visible = !leaf->visible;
|
||||
const Subtree *different_leaf = ts_subtree_new_leaf(
|
||||
&pool, leaf->symbol, leaf->padding, leaf->size, &language
|
||||
);
|
||||
((Subtree *)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_new_leaf(&pool, leaf->symbol, {}, leaf->size, &language);
|
||||
const 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);
|
||||
|
||||
|
|
@ -436,16 +443,16 @@ describe("Subtree", []() {
|
|||
});
|
||||
|
||||
it("returns false for trees with different children", [&]() {
|
||||
Subtree *leaf2 = ts_subtree_new_leaf(&pool, symbol2, {1, {0, 1}}, {3, {0, 3}}, &language);
|
||||
const Subtree *leaf2 = ts_subtree_new_leaf(&pool, symbol2, {1, {0, 1}}, {3, {0, 3}}, &language);
|
||||
|
||||
Subtree *parent = ts_subtree_new_node(&pool, symbol2, tree_array({
|
||||
const 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_new_node(&pool, symbol2, tree_array({
|
||||
const Subtree *different_parent = ts_subtree_new_node(&pool, symbol2, tree_array({
|
||||
leaf2,
|
||||
leaf,
|
||||
}), 0, &language);
|
||||
|
|
@ -465,13 +472,13 @@ describe("Subtree", []() {
|
|||
Length padding = {1, {0, 1}};
|
||||
Length size = {2, {0, 2}};
|
||||
|
||||
auto make_external = [](Subtree *tree) {
|
||||
tree->has_external_tokens = true;
|
||||
auto make_external = [](const Subtree *tree) {
|
||||
((Subtree *)tree)->has_external_tokens = true;
|
||||
return tree;
|
||||
};
|
||||
|
||||
it("returns the last serialized external token state in the given tree", [&]() {
|
||||
Subtree *tree1, *tree2, *tree3, *tree4, *tree5, *tree6, *tree7, *tree8, *tree9;
|
||||
const Subtree *tree1, *tree2, *tree3, *tree4, *tree5, *tree6, *tree7, *tree8, *tree9;
|
||||
|
||||
tree1 = ts_subtree_new_node(&pool, symbol1, tree_array({
|
||||
(tree2 = ts_subtree_new_node(&pool, symbol2, tree_array({
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue