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

Rename Tree -> Subtree

Browse source
This commit is contained in:
Max Brunsfeld 2018-05-10 15:11:14 -07:00
parent 61327b627a
commit 35510a612d
25 changed files with 724 additions and 719 deletions
Download patch file Download diff file Expand all files Collapse all files

216
test/runtime/stack_test.cc
View file

@ -4,7 +4,7 @@
#include "helpers/record_alloc.h"
#include "helpers/stream_methods.h"
#include "runtime/stack.h"
#include "runtime/tree.h"
#include "runtime/subtree.h"
#include "runtime/length.h"
#include "runtime/alloc.h"
@ -23,23 +23,23 @@ Length operator*(const Length &length, uint32_t factor) {
return {length.bytes * factor, {0, length.extent.column * factor}};
}
void free_slice_array(TreePool *pool, StackSliceArray *slices) {
void free_slice_array(SubtreePool *pool, StackSliceArray *slices) {
for (size_t i = 0; i < slices->size; i++) {
StackSlice slice = slices->contents[i];
bool matches_prior_trees = false;
for (size_t j = 0; j < i; j++) {
StackSlice prior_slice = slices->contents[j];
if (slice.trees.contents == prior_slice.trees.contents) {
if (slice.subtrees.contents == prior_slice.subtrees.contents) {
matches_prior_trees = true;
break;
}
}
if (!matches_prior_trees) {
for (size_t j = 0; j < slice.trees.size; j++)
ts_tree_release(pool, slice.trees.contents[j]);
array_delete(&slice.trees);
for (size_t j = 0; j < slice.subtrees.size; j++)
ts_subtree_release(pool, slice.subtrees.contents[j]);
array_delete(&slice.subtrees);
}
}
}
@ -54,9 +54,9 @@ vector<StackEntry> get_stack_entries(Stack *stack, StackVersion version) {
ts_stack_iterate(
stack,
version,
[](void *payload, TSStateId state, uint32_t tree_count) {
[](void *payload, TSStateId state, uint32_t subtree_count) {
auto entries = static_cast<vector<StackEntry> *>(payload);
StackEntry entry = {state, tree_count};
StackEntry entry = {state, subtree_count};
if (find(entries->begin(), entries->end(), entry) == entries->end()) {
entries->push_back(entry);
}
@ -68,39 +68,39 @@ START_TEST
describe("Stack", [&]() {
Stack *stack;
const size_t tree_count = 11;
Tree *trees[tree_count];
const size_t subtree_count = 11;
Subtree *subtrees[subtree_count];
Length tree_len = {3, {0, 3}};
TreePool pool;
SubtreePool pool;
before_each([&]() {
record_alloc::start();
ts_tree_pool_init(&pool);
ts_subtree_pool_init(&pool);
stack = ts_stack_new(&pool);
TSLanguage dummy_language;
TSSymbolMetadata symbol_metadata[50] = {};
dummy_language.symbol_metadata = symbol_metadata;
for (size_t i = 0; i < tree_count; i++) {
trees[i] = ts_tree_make_leaf(&pool, i, length_zero(), tree_len, &dummy_language);
for (size_t i = 0; i < subtree_count; i++) {
subtrees[i] = ts_subtree_make_leaf(&pool, i, length_zero(), tree_len, &dummy_language);
}
});
after_each([&]() {
ts_stack_delete(stack);
for (size_t i = 0; i < tree_count; i++) {
ts_tree_release(&pool, trees[i]);
for (size_t i = 0; i < subtree_count; i++) {
ts_subtree_release(&pool, subtrees[i]);
}
ts_tree_pool_delete(&pool);
ts_subtree_pool_delete(&pool);
record_alloc::stop();
AssertThat(record_alloc::outstanding_allocation_indices(), IsEmpty());
});
auto push = [&](StackVersion version, Tree *tree, TSStateId state) {
ts_tree_retain(tree);
auto push = [&](StackVersion version, Subtree *tree, TSStateId state) {
ts_subtree_retain(tree);
ts_stack_push(stack, version, tree, false, state);
};
@ -111,17 +111,17 @@ describe("Stack", [&]() {
AssertThat(ts_stack_position(stack, 0), Equals(length_zero()));
// . <──0── A*
push(0, trees[0], stateA);
push(0, subtrees[0], stateA);
AssertThat(ts_stack_state(stack, 0), Equals(stateA));
AssertThat(ts_stack_position(stack, 0), Equals(tree_len));
// . <──0── A <──1── B*
push(0, trees[1], stateB);
push(0, subtrees[1], stateB);
AssertThat(ts_stack_state(stack, 0), Equals(stateB));
AssertThat(ts_stack_position(stack, 0), Equals(tree_len * 2));
// . <──0── A <──1── B <──2── C*
push(0, trees[2], stateC);
push(0, subtrees[2], stateC);
AssertThat(ts_stack_state(stack, 0), Equals(stateC));
AssertThat(ts_stack_position(stack, 0), Equals(tree_len * 3));
@ -139,7 +139,7 @@ describe("Stack", [&]() {
// . <──0── A <─*
// ↑
// └───*
push(0, trees[0], stateA);
push(0, subtrees[0], stateA);
ts_stack_copy_version(stack, 0);
});
@ -147,10 +147,10 @@ describe("Stack", [&]() {
// . <──0── A <──1── B <──3── D*
// ↑
// └───2─── C <──4── D*
push(0, trees[1], stateB);
push(1, trees[2], stateC);
push(0, trees[3], stateD);
push(1, trees[4], stateD);
push(0, subtrees[1], stateB);
push(1, subtrees[2], stateC);
push(0, subtrees[3], stateD);
push(1, subtrees[4], stateD);
// . <──0── A <──1── B <──3── D*
// ↑ |
@ -170,8 +170,8 @@ describe("Stack", [&]() {
// . <──0── A <──1── B*
// ↑
// └───2─── C*
push(0, trees[1], stateB);
push(1, trees[2], stateC);
push(0, subtrees[1], stateB);
push(1, subtrees[2], stateC);
AssertThat(ts_stack_merge(stack, 0, 1), IsFalse());
AssertThat(ts_stack_version_count(stack), Equals<size_t>(2));
@ -181,11 +181,11 @@ describe("Stack", [&]() {
// . <──0── A <──1── B <────3──── D*
// ↑
// └───2─── C <──4── D*
trees[3]->size = tree_len * 3;
push(0, trees[1], stateB);
push(1, trees[2], stateC);
push(0, trees[3], stateD);
push(1, trees[4], stateD);
subtrees[3]->size = tree_len * 3;
push(0, subtrees[1], stateB);
push(1, subtrees[2], stateC);
push(0, subtrees[3], stateD);
push(1, subtrees[4], stateD);
AssertThat(ts_stack_merge(stack, 0, 1), IsFalse());
AssertThat(ts_stack_version_count(stack), Equals<size_t>(2));
@ -196,12 +196,12 @@ describe("Stack", [&]() {
// . <──0── A <──1── B <──3── D <──5── E*
// ↑
// └───2─── C <──4── D <──5── E*
push(0, trees[1], stateB);
push(1, trees[2], stateC);
push(0, trees[3], stateD);
push(1, trees[4], stateD);
push(0, trees[5], stateE);
push(1, trees[5], stateE);
push(0, subtrees[1], stateB);
push(1, subtrees[2], stateC);
push(0, subtrees[3], stateD);
push(1, subtrees[4], stateD);
push(0, subtrees[5], stateE);
push(1, subtrees[5], stateE);
// . <──0── A <──1── B <──3── D <──5── E*
// ↑ |
@ -224,12 +224,12 @@ describe("Stack", [&]() {
// . <──0── A <────1──── B*
// ↑
// └2─ A <──1── B*
trees[2]->extra = true;
trees[2]->size = tree_len * 0;
subtrees[2]->extra = true;
subtrees[2]->size = tree_len * 0;
push(0, trees[1], stateB);
push(1, trees[2], stateA);
push(1, trees[1], stateB);
push(0, subtrees[1], stateB);
push(1, subtrees[2], stateA);
push(1, subtrees[1], stateB);
// . <──0── A <──1── B*
AssertThat(ts_stack_merge(stack, 0, 1), IsTrue());
@ -246,9 +246,9 @@ describe("Stack", [&]() {
describe("pop_count(version, count)", [&]() {
before_each([&]() {
// . <──0── A <──1── B <──2── C*
push(0, trees[0], stateA);
push(0, trees[1], stateB);
push(0, trees[2], stateC);
push(0, subtrees[0], stateA);
push(0, subtrees[1], stateB);
push(0, subtrees[2], stateC);
});
it("creates a new version with the given number of entries removed", [&]() {
@ -261,14 +261,14 @@ describe("Stack", [&]() {
StackSlice slice = pop.contents[0];
AssertThat(slice.version, Equals<StackVersion>(1));
AssertThat(slice.trees, Equals(vector<Tree *>({ trees[1], trees[2] })));
AssertThat(slice.subtrees, Equals(vector<Subtree *>({ subtrees[1], subtrees[2] })));
AssertThat(ts_stack_state(stack, 1), Equals(stateA));
free_slice_array(&pool,&pop);
});
it("does not count 'extra' trees toward the given count", [&]() {
trees[1]->extra = true;
it("does not count 'extra' subtrees toward the given count", [&]() {
subtrees[1]->extra = true;
// . <──0── A <──1── B <──2── C*
// ↑
@ -277,7 +277,7 @@ describe("Stack", [&]() {
AssertThat(pop.size, Equals<size_t>(1));
StackSlice slice = pop.contents[0];
AssertThat(slice.trees, Equals(vector<Tree *>({ trees[0], trees[1], trees[2] })));
AssertThat(slice.subtrees, Equals(vector<Subtree *>({ subtrees[0], subtrees[1], subtrees[2] })));
AssertThat(ts_stack_state(stack, 1), Equals(1));
free_slice_array(&pool,&pop);
@ -288,14 +288,14 @@ describe("Stack", [&]() {
// . <──0── A <──1── B <──2── C <──3── D <──10── I*
// ↑ |
// └───4─── E <──5── F <──6───┘
push(0, trees[3], stateD);
push(0, subtrees[3], stateD);
StackSliceArray pop = ts_stack_pop_count(stack, 0, 3);
free_slice_array(&pool,&pop);
push(1, trees[4], stateE);
push(1, trees[5], stateF);
push(1, trees[6], stateD);
push(1, subtrees[4], stateE);
push(1, subtrees[5], stateF);
push(1, subtrees[6], stateD);
ts_stack_merge(stack, 0, 1);
push(0, trees[10], stateI);
push(0, subtrees[10], stateI);
AssertThat(ts_stack_version_count(stack), Equals<size_t>(1));
AssertThat(get_stack_entries(stack, 0), Equals(vector<StackEntry>({
@ -322,11 +322,11 @@ describe("Stack", [&]() {
StackSlice slice1 = pop.contents[0];
AssertThat(slice1.version, Equals<StackVersion>(1));
AssertThat(slice1.trees, Equals(vector<Tree *>({ trees[2], trees[3], trees[10] })));
AssertThat(slice1.subtrees, Equals(vector<Subtree *>({ subtrees[2], subtrees[3], subtrees[10] })));
StackSlice slice2 = pop.contents[1];
AssertThat(slice2.version, Equals<StackVersion>(2));
AssertThat(slice2.trees, Equals(vector<Tree *>({ trees[5], trees[6], trees[10] })));
AssertThat(slice2.subtrees, Equals(vector<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 +366,7 @@ describe("Stack", [&]() {
StackSlice slice1 = pop.contents[0];
AssertThat(slice1.version, Equals<StackVersion>(1));
AssertThat(slice1.trees, Equals(vector<Tree *>({ trees[10] })));
AssertThat(slice1.subtrees, Equals(vector<Subtree *>({ subtrees[10] })));
AssertThat(ts_stack_version_count(stack), Equals<size_t>(2));
AssertThat(ts_stack_state(stack, 0), Equals(stateI));
@ -388,11 +388,11 @@ describe("Stack", [&]() {
StackSlice slice1 = pop.contents[0];
AssertThat(slice1.version, Equals<StackVersion>(1));
AssertThat(slice1.trees, Equals(vector<Tree *>({ trees[1], trees[2], trees[3], trees[10] })));
AssertThat(slice1.subtrees, Equals(vector<Subtree *>({ subtrees[1], subtrees[2], subtrees[3], subtrees[10] })));
StackSlice slice2 = pop.contents[1];
AssertThat(slice2.version, Equals<StackVersion>(1));
AssertThat(slice2.trees, Equals(vector<Tree *>({ trees[4], trees[5], trees[6], trees[10] })));
AssertThat(slice2.subtrees, Equals(vector<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));
@ -403,7 +403,7 @@ describe("Stack", [&]() {
});
describe("when there are three paths that lead to three different versions", [&]() {
it("returns three entries with different arrays of trees", [&]() {
it("returns three entries with different arrays of subtrees", [&]() {
// . <──0── A <──1── B <──2── C <──3── D <──10── I*
// ↑ |
// ├───4─── E <──5── F <──6───┘
@ -411,10 +411,10 @@ describe("Stack", [&]() {
// └───7─── G <──8── H <──9───┘
StackSliceArray pop = ts_stack_pop_count(stack, 0, 4);
free_slice_array(&pool,&pop);
push(1, trees[7], stateG);
push(1, trees[8], stateH);
push(1, trees[9], stateD);
push(1, trees[10], stateI);
push(1, subtrees[7], stateG);
push(1, subtrees[8], stateH);
push(1, subtrees[9], stateD);
push(1, subtrees[10], stateI);
ts_stack_merge(stack, 0, 1);
AssertThat(ts_stack_version_count(stack), Equals<size_t>(1));
@ -443,15 +443,15 @@ describe("Stack", [&]() {
StackSlice slice1 = pop.contents[0];
AssertThat(slice1.version, Equals<StackVersion>(1));
AssertThat(slice1.trees, Equals(vector<Tree *>({ trees[3], trees[10] })));
AssertThat(slice1.subtrees, Equals(vector<Subtree *>({ subtrees[3], subtrees[10] })));
StackSlice slice2 = pop.contents[1];
AssertThat(slice2.version, Equals<StackVersion>(2));
AssertThat(slice2.trees, Equals(vector<Tree *>({ trees[6], trees[10] })));
AssertThat(slice2.subtrees, Equals(vector<Subtree *>({ subtrees[6], subtrees[10] })));
StackSlice slice3 = pop.contents[2];
AssertThat(slice3.version, Equals<StackVersion>(3));
AssertThat(slice3.trees, Equals(vector<Tree *>({ trees[9], trees[10] })));
AssertThat(slice3.subtrees, Equals(vector<Subtree *>({ subtrees[9], subtrees[10] })));
AssertThat(ts_stack_version_count(stack), Equals<size_t>(4));
AssertThat(ts_stack_state(stack, 0), Equals(stateI));
@ -467,12 +467,12 @@ describe("Stack", [&]() {
describe("pop_pending(version)", [&]() {
before_each([&]() {
push(0, trees[0], stateA);
push(0, subtrees[0], stateA);
});
it("removes the top node from the stack if it was pushed in pending mode", [&]() {
ts_stack_push(stack, 0, trees[1], true, stateB);
ts_tree_retain(trees[1]);
ts_stack_push(stack, 0, subtrees[1], true, stateB);
ts_subtree_retain(subtrees[1]);
StackSliceArray pop = ts_stack_pop_pending(stack, 0);
AssertThat(pop.size, Equals<size_t>(1));
@ -485,20 +485,20 @@ describe("Stack", [&]() {
free_slice_array(&pool,&pop);
});
it("skips entries whose trees are extra", [&]() {
ts_stack_push(stack, 0, trees[1], true, stateB);
ts_tree_retain(trees[1]);
it("skips entries whose subtrees are extra", [&]() {
ts_stack_push(stack, 0, subtrees[1], true, stateB);
ts_subtree_retain(subtrees[1]);
trees[2]->extra = true;
trees[3]->extra = true;
subtrees[2]->extra = true;
subtrees[3]->extra = true;
push(0, trees[2], stateB);
push(0, trees[3], stateB);
push(0, subtrees[2], stateB);
push(0, subtrees[3], stateB);
StackSliceArray pop = ts_stack_pop_pending(stack, 0);
AssertThat(pop.size, Equals<size_t>(1));
AssertThat(pop.contents[0].trees, Equals(vector<Tree *>({ trees[1], trees[2], trees[3] })));
AssertThat(pop.contents[0].subtrees, Equals(vector<Subtree *>({ subtrees[1], subtrees[2], subtrees[3] })));
AssertThat(get_stack_entries(stack, 0), Equals(vector<StackEntry>({
{stateA, 0},
@ -509,7 +509,7 @@ describe("Stack", [&]() {
});
it("does nothing if the top node was not pushed in pending mode", [&]() {
push(0, trees[1], stateB);
push(0, subtrees[1], stateB);
StackSliceArray pop = ts_stack_pop_pending(stack, 0);
AssertThat(pop.size, Equals<size_t>(0));
@ -526,59 +526,59 @@ describe("Stack", [&]() {
describe("setting external token state", [&]() {
before_each([&]() {
trees[1]->has_external_tokens = true;
trees[2]->has_external_tokens = true;
ts_external_token_state_init(&trees[1]->external_token_state, NULL, 0);
ts_external_token_state_init(&trees[2]->external_token_state, NULL, 0);
subtrees[1]->has_external_tokens = true;
subtrees[2]->has_external_tokens = true;
ts_external_token_state_init(&subtrees[1]->external_token_state, NULL, 0);
ts_external_token_state_init(&subtrees[2]->external_token_state, NULL, 0);
});
it("allows the state to be retrieved", [&]() {
AssertThat(ts_stack_last_external_token(stack, 0), Equals<Tree *>(nullptr));
AssertThat(ts_stack_last_external_token(stack, 0), Equals<Subtree *>(nullptr));
ts_stack_set_last_external_token(stack, 0, trees[1]);
AssertThat(ts_stack_last_external_token(stack, 0), Equals(trees[1]));
ts_stack_set_last_external_token(stack, 0, subtrees[1]);
AssertThat(ts_stack_last_external_token(stack, 0), Equals(subtrees[1]));
ts_stack_copy_version(stack, 0);
AssertThat(ts_stack_last_external_token(stack, 1), Equals(trees[1]));
AssertThat(ts_stack_last_external_token(stack, 1), Equals(subtrees[1]));
ts_stack_set_last_external_token(stack, 0, trees[2]);
AssertThat(ts_stack_last_external_token(stack, 0), Equals(trees[2]));
ts_stack_set_last_external_token(stack, 0, subtrees[2]);
AssertThat(ts_stack_last_external_token(stack, 0), Equals(subtrees[2]));
});
it("does not merge stack versions with different external token states", [&]() {
ts_external_token_state_init(&trees[1]->external_token_state, "abcd", 2);
ts_external_token_state_init(&trees[2]->external_token_state, "ABCD", 2);
ts_external_token_state_init(&subtrees[1]->external_token_state, "abcd", 2);
ts_external_token_state_init(&subtrees[2]->external_token_state, "ABCD", 2);
ts_stack_copy_version(stack, 0);
push(0, trees[0], 5);
push(1, trees[0], 5);
push(0, subtrees[0], 5);
push(1, subtrees[0], 5);
ts_stack_set_last_external_token(stack, 0, trees[1]);
ts_stack_set_last_external_token(stack, 1, trees[2]);
ts_stack_set_last_external_token(stack, 0, subtrees[1]);
ts_stack_set_last_external_token(stack, 1, subtrees[2]);
AssertThat(ts_stack_merge(stack, 0, 1), IsFalse());
});
it("merges stack versions with identical external token states", [&]() {
ts_external_token_state_init(&trees[1]->external_token_state, "abcd", 2);
ts_external_token_state_init(&trees[2]->external_token_state, "abcd", 2);
ts_external_token_state_init(&subtrees[1]->external_token_state, "abcd", 2);
ts_external_token_state_init(&subtrees[2]->external_token_state, "abcd", 2);
ts_stack_copy_version(stack, 0);
push(0, trees[0], 5);
push(1, trees[0], 5);
push(0, subtrees[0], 5);
push(1, subtrees[0], 5);
ts_stack_set_last_external_token(stack, 0, trees[1]);
ts_stack_set_last_external_token(stack, 1, trees[2]);
ts_stack_set_last_external_token(stack, 0, subtrees[1]);
ts_stack_set_last_external_token(stack, 1, subtrees[2]);
AssertThat(ts_stack_merge(stack, 0, 1), IsTrue());
});
it("does not distinguish between an *empty* external token state and *no* external token state", [&]() {
ts_stack_copy_version(stack, 0);
push(0, trees[0], 5);
push(1, trees[0], 5);
push(0, subtrees[0], 5);
push(1, subtrees[0], 5);
ts_stack_set_last_external_token(stack, 0, trees[1]);
ts_stack_set_last_external_token(stack, 0, subtrees[1]);
AssertThat(ts_stack_merge(stack, 0, 1), IsTrue());
});
@ -595,7 +595,7 @@ std::ostream &operator<<(std::ostream &stream, const StackEntry &entry) {
return stream << "{" << entry.state << ", " << entry.depth << "}";
}
std::ostream &operator<<(std::ostream &stream, const TreeArray &array) {
std::ostream &operator<<(std::ostream &stream, const SubtreeArray &array) {
stream << "[";
bool first = true;
for (size_t i = 0; i < array.size; i++) {