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

Rename node accessor methods

Browse source 
Instead of child() vs concrete_child(), next_sibling() vs next_concrete_sibling(), etc,
the default is switched: child() refers to the concrete syntax tree, and named_child()
refers to the AST. Because the AST is abstract through exclusion of some nodes, the
names are clearer if the qualifier goes on the AST operations
This commit is contained in:
Max Brunsfeld 2015-09-08 23:16:24 -07:00
parent 245daffbc4
commit 7ee5eaa16a
16 changed files with 475 additions and 476 deletions
Download patch file Download diff file Expand all files Collapse all files

197
spec/runtime/node_spec.cc
View file

@ -25,12 +25,12 @@ describe("Node", []() {
});
describe("child_count(), child(i)", [&]() {
it("returns the child node at the given index", [&]() {
AssertThat(ts_node_child_count(array_node), Equals<size_t>(3));
it("returns the named child node at the given index", [&]() {
AssertThat(ts_node_named_child_count(array_node), Equals<size_t>(3));
TSNode child1 = ts_node_child(array_node, 0);
TSNode child2 = ts_node_child(array_node, 1);
TSNode child3 = ts_node_child(array_node, 2);
TSNode child1 = ts_node_named_child(array_node, 0);
TSNode child2 = ts_node_named_child(array_node, 1);
TSNode child3 = ts_node_named_child(array_node, 2);
AssertThat(ts_node_name(array_node, document), Equals("array"));
AssertThat(ts_node_name(child1, document), Equals("number"));
@ -49,10 +49,10 @@ describe("Node", []() {
AssertThat(ts_node_pos(child3).bytes, Equals<size_t>(15));
AssertThat(ts_node_size(child3).bytes, Equals<size_t>(11));
AssertThat(ts_node_child_count(child3), Equals<size_t>(2));
AssertThat(ts_node_named_child_count(child3), Equals<size_t>(2));
TSNode grandchild1 = ts_node_child(child3, 0);
TSNode grandchild2 = ts_node_child(child3, 1);
TSNode grandchild1 = ts_node_named_child(child3, 0);
TSNode grandchild2 = ts_node_named_child(child3, 1);
AssertThat(ts_node_name(grandchild1, document), Equals("string"));
AssertThat(ts_node_name(grandchild2, document), Equals("null"));
@ -65,15 +65,15 @@ describe("Node", []() {
});
describe("concrete_child_count(), concrete_child(i)", [&]() {
it("returns the child node at the given index, counting anonymous token nodes", [&]() {
AssertThat(ts_node_concrete_child_count(array_node), Equals<size_t>(7));
TSNode child1 = ts_node_concrete_child(array_node, 0);
TSNode child2 = ts_node_concrete_child(array_node, 1);
TSNode child3 = ts_node_concrete_child(array_node, 2);
TSNode child4 = ts_node_concrete_child(array_node, 3);
TSNode child5 = ts_node_concrete_child(array_node, 4);
TSNode child6 = ts_node_concrete_child(array_node, 5);
TSNode child7 = ts_node_concrete_child(array_node, 6);
it("returns the child node at the given index, including anonymous nodes", [&]() {
AssertThat(ts_node_child_count(array_node), Equals<size_t>(7));
TSNode child1 = ts_node_child(array_node, 0);
TSNode child2 = ts_node_child(array_node, 1);
TSNode child3 = ts_node_child(array_node, 2);
TSNode child4 = ts_node_child(array_node, 3);
TSNode child5 = ts_node_child(array_node, 4);
TSNode child6 = ts_node_child(array_node, 5);
TSNode child7 = ts_node_child(array_node, 6);
AssertThat(ts_node_name(array_node, document), Equals("array"));
AssertThat(ts_node_name(child1, document), Equals("["));
@ -84,14 +84,14 @@ describe("Node", []() {
AssertThat(ts_node_name(child6, document), Equals("object"));
AssertThat(ts_node_name(child7, document), Equals("]"));
AssertThat(ts_node_is_concrete(array_node), IsFalse());
AssertThat(ts_node_is_concrete(child1), IsTrue());
AssertThat(ts_node_is_concrete(child2), IsFalse());
AssertThat(ts_node_is_concrete(child3), IsTrue());
AssertThat(ts_node_is_concrete(child4), IsFalse());
AssertThat(ts_node_is_concrete(child5), IsTrue());
AssertThat(ts_node_is_concrete(child6), IsFalse());
AssertThat(ts_node_is_concrete(child7), IsTrue());
AssertThat(ts_node_is_named(array_node), IsTrue());
AssertThat(ts_node_is_named(child1), IsFalse());
AssertThat(ts_node_is_named(child2), IsTrue());
AssertThat(ts_node_is_named(child3), IsFalse());
AssertThat(ts_node_is_named(child4), IsTrue());
AssertThat(ts_node_is_named(child5), IsFalse());
AssertThat(ts_node_is_named(child6), IsTrue());
AssertThat(ts_node_is_named(child7), IsFalse());
AssertThat(ts_node_pos(child1).bytes, Equals<size_t>(2));
AssertThat(ts_node_size(child1).bytes, Equals<size_t>(1));
@ -105,13 +105,13 @@ describe("Node", []() {
AssertThat(ts_node_pos(child7).bytes, Equals<size_t>(26));
AssertThat(ts_node_size(child7).bytes, Equals<size_t>(1));
AssertThat(ts_node_concrete_child_count(child6), Equals<size_t>(5))
AssertThat(ts_node_child_count(child6), Equals<size_t>(5))
TSNode grandchild1 = ts_node_concrete_child(child6, 0);
TSNode grandchild2 = ts_node_concrete_child(child6, 1);
TSNode grandchild3 = ts_node_concrete_child(child6, 2);
TSNode grandchild4 = ts_node_concrete_child(child6, 3);
TSNode grandchild5 = ts_node_concrete_child(child6, 4);
TSNode grandchild1 = ts_node_child(child6, 0);
TSNode grandchild2 = ts_node_child(child6, 1);
TSNode grandchild3 = ts_node_child(child6, 2);
TSNode grandchild4 = ts_node_child(child6, 3);
TSNode grandchild5 = ts_node_child(child6, 4);
AssertThat(ts_node_name(grandchild1, document), Equals("{"));
AssertThat(ts_node_name(grandchild2, document), Equals("string"));
@ -132,89 +132,89 @@ describe("Node", []() {
describe("next_concrete_sibling(), prev_concrete_sibling()", [&]() {
it("returns the node's next and previous sibling, including anonymous nodes", [&]() {
TSNode bracket_node1 = ts_node_concrete_child(array_node, 0);
TSNode number_node = ts_node_concrete_child(array_node, 1);
TSNode array_comma_node1 = ts_node_concrete_child(array_node, 2);
TSNode false_node = ts_node_concrete_child(array_node, 3);
TSNode array_comma_node2 = ts_node_concrete_child(array_node, 4);
TSNode object_node = ts_node_concrete_child(array_node, 5);
TSNode brace_node1 = ts_node_concrete_child(object_node, 0);
TSNode string_node = ts_node_concrete_child(object_node, 1);
TSNode colon_node = ts_node_concrete_child(object_node, 2);
TSNode null_node = ts_node_concrete_child(object_node, 3);
TSNode brace_node2 = ts_node_concrete_child(object_node, 4);
TSNode bracket_node2 = ts_node_concrete_child(array_node, 6);
TSNode bracket_node1 = ts_node_child(array_node, 0);
TSNode number_node = ts_node_child(array_node, 1);
TSNode array_comma_node1 = ts_node_child(array_node, 2);
TSNode false_node = ts_node_child(array_node, 3);
TSNode array_comma_node2 = ts_node_child(array_node, 4);
TSNode object_node = ts_node_child(array_node, 5);
TSNode brace_node1 = ts_node_child(object_node, 0);
TSNode string_node = ts_node_child(object_node, 1);
TSNode colon_node = ts_node_child(object_node, 2);
TSNode null_node = ts_node_child(object_node, 3);
TSNode brace_node2 = ts_node_child(object_node, 4);
TSNode bracket_node2 = ts_node_child(array_node, 6);
AssertThat(ts_node_next_concrete_sibling(bracket_node1), Equals(number_node));
AssertThat(ts_node_next_concrete_sibling(number_node), Equals(array_comma_node1));
AssertThat(ts_node_next_concrete_sibling(array_comma_node1), Equals(false_node));
AssertThat(ts_node_next_concrete_sibling(false_node), Equals(array_comma_node2));
AssertThat(ts_node_next_concrete_sibling(array_comma_node2), Equals(object_node));
AssertThat(ts_node_next_concrete_sibling(object_node), Equals(bracket_node2));
AssertThat(ts_node_next_concrete_sibling(bracket_node2).data, Equals<void *>(nullptr));
AssertThat(ts_node_next_sibling(bracket_node1), Equals(number_node));
AssertThat(ts_node_next_sibling(number_node), Equals(array_comma_node1));
AssertThat(ts_node_next_sibling(array_comma_node1), Equals(false_node));
AssertThat(ts_node_next_sibling(false_node), Equals(array_comma_node2));
AssertThat(ts_node_next_sibling(array_comma_node2), Equals(object_node));
AssertThat(ts_node_next_sibling(object_node), Equals(bracket_node2));
AssertThat(ts_node_next_sibling(bracket_node2).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_concrete_sibling(bracket_node1).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_concrete_sibling(number_node), Equals(bracket_node1));
AssertThat(ts_node_prev_concrete_sibling(array_comma_node1), Equals(number_node));
AssertThat(ts_node_prev_concrete_sibling(false_node), Equals(array_comma_node1));
AssertThat(ts_node_prev_concrete_sibling(array_comma_node2), Equals(false_node));
AssertThat(ts_node_prev_concrete_sibling(object_node), Equals(array_comma_node2));
AssertThat(ts_node_prev_concrete_sibling(bracket_node2), Equals(object_node));
AssertThat(ts_node_prev_sibling(bracket_node1).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_sibling(number_node), Equals(bracket_node1));
AssertThat(ts_node_prev_sibling(array_comma_node1), Equals(number_node));
AssertThat(ts_node_prev_sibling(false_node), Equals(array_comma_node1));
AssertThat(ts_node_prev_sibling(array_comma_node2), Equals(false_node));
AssertThat(ts_node_prev_sibling(object_node), Equals(array_comma_node2));
AssertThat(ts_node_prev_sibling(bracket_node2), Equals(object_node));
AssertThat(ts_node_next_concrete_sibling(brace_node1), Equals(string_node));
AssertThat(ts_node_next_concrete_sibling(string_node), Equals(colon_node));
AssertThat(ts_node_next_concrete_sibling(colon_node), Equals(null_node));
AssertThat(ts_node_next_concrete_sibling(null_node), Equals(brace_node2));
AssertThat(ts_node_next_concrete_sibling(brace_node2).data, Equals<void *>(nullptr));
AssertThat(ts_node_next_sibling(brace_node1), Equals(string_node));
AssertThat(ts_node_next_sibling(string_node), Equals(colon_node));
AssertThat(ts_node_next_sibling(colon_node), Equals(null_node));
AssertThat(ts_node_next_sibling(null_node), Equals(brace_node2));
AssertThat(ts_node_next_sibling(brace_node2).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_concrete_sibling(brace_node1).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_concrete_sibling(string_node), Equals(brace_node1));
AssertThat(ts_node_prev_concrete_sibling(colon_node), Equals(string_node));
AssertThat(ts_node_prev_concrete_sibling(null_node), Equals(colon_node));
AssertThat(ts_node_prev_concrete_sibling(brace_node2), Equals(null_node));
AssertThat(ts_node_prev_sibling(brace_node1).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_sibling(string_node), Equals(brace_node1));
AssertThat(ts_node_prev_sibling(colon_node), Equals(string_node));
AssertThat(ts_node_prev_sibling(null_node), Equals(colon_node));
AssertThat(ts_node_prev_sibling(brace_node2), Equals(null_node));
});
it("returns null when the node has no parent", [&]() {
AssertThat(ts_node_next_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_next_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_next_named_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_named_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_next_named_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_named_sibling(array_node).data, Equals<void *>(nullptr));
});
});
describe("next_concrete_sibling(), prev_concrete_sibling()", [&]() {
it("returns the node's next and previous siblings", [&]() {
TSNode number_node = ts_node_child(array_node, 0);
TSNode false_node = ts_node_child(array_node, 1);
TSNode object_node = ts_node_child(array_node, 2);
TSNode string_node = ts_node_child(object_node, 0);
TSNode null_node = ts_node_child(object_node, 1);
TSNode number_node = ts_node_named_child(array_node, 0);
TSNode false_node = ts_node_named_child(array_node, 1);
TSNode object_node = ts_node_named_child(array_node, 2);
TSNode string_node = ts_node_named_child(object_node, 0);
TSNode null_node = ts_node_named_child(object_node, 1);
AssertThat(ts_node_next_sibling(number_node), Equals(false_node));
AssertThat(ts_node_next_sibling(false_node), Equals(object_node));
AssertThat(ts_node_next_sibling(string_node), Equals(null_node));
AssertThat(ts_node_prev_sibling(object_node), Equals(false_node));
AssertThat(ts_node_prev_sibling(false_node), Equals(number_node));
AssertThat(ts_node_prev_sibling(null_node), Equals(string_node));
AssertThat(ts_node_next_named_sibling(number_node), Equals(false_node));
AssertThat(ts_node_next_named_sibling(false_node), Equals(object_node));
AssertThat(ts_node_next_named_sibling(string_node), Equals(null_node));
AssertThat(ts_node_prev_named_sibling(object_node), Equals(false_node));
AssertThat(ts_node_prev_named_sibling(false_node), Equals(number_node));
AssertThat(ts_node_prev_named_sibling(null_node), Equals(string_node));
});
it("returns null when the node has no parent", [&]() {
AssertThat(ts_node_next_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_next_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_next_named_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_named_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_next_named_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_named_sibling(array_node).data, Equals<void *>(nullptr));
});
});
describe("find_for_range(start, end)", [&]() {
describe("when there is a leaf node that spans the given range exactly", [&]() {
it("returns that leaf node", [&]() {
TSNode leaf = ts_node_find_for_range(array_node, 16, 18);
TSNode leaf = ts_node_named_descendent_for_range(array_node, 16, 18);
AssertThat(ts_node_name(leaf, document), Equals("string"));
AssertThat(ts_node_size(leaf).bytes, Equals<size_t>(3));
AssertThat(ts_node_pos(leaf).bytes, Equals<size_t>(16));
leaf = ts_node_find_for_range(array_node, 3, 5);
leaf = ts_node_named_descendent_for_range(array_node, 3, 5);
AssertThat(ts_node_name(leaf, document), Equals("number"));
AssertThat(ts_node_size(leaf).bytes, Equals<size_t>(3));
AssertThat(ts_node_pos(leaf).bytes, Equals<size_t>(3));
@ -223,12 +223,12 @@ describe("Node", []() {
describe("when there is a leaf node that extends beyond the given range", [&]() {
it("returns that leaf node", [&]() {
TSNode leaf = ts_node_find_for_range(array_node, 16, 17);
TSNode leaf = ts_node_named_descendent_for_range(array_node, 16, 17);
AssertThat(ts_node_name(leaf, document), Equals("string"));
AssertThat(ts_node_size(leaf).bytes, Equals<size_t>(3));
AssertThat(ts_node_pos(leaf).bytes, Equals<size_t>(16));
leaf = ts_node_find_for_range(array_node, 17, 18);
leaf = ts_node_named_descendent_for_range(array_node, 17, 18);
AssertThat(ts_node_name(leaf, document), Equals("string"));
AssertThat(ts_node_size(leaf).bytes, Equals<size_t>(3));
AssertThat(ts_node_pos(leaf).bytes, Equals<size_t>(16));
@ -237,14 +237,14 @@ describe("Node", []() {
describe("when there is no leaf node that spans the given range", [&]() {
it("returns the smallest node that does span the range", [&]() {
TSNode node = ts_node_find_for_range(array_node, 16, 19);
TSNode node = ts_node_named_descendent_for_range(array_node, 16, 19);
AssertThat(ts_node_name(node, document), Equals("object"));
AssertThat(ts_node_size(node).bytes, Equals<size_t>(11));
AssertThat(ts_node_pos(node).bytes, Equals<size_t>(15));
});
it("does not return invisible nodes (repeats)", [&]() {
TSNode node = ts_node_find_for_range(array_node, 6, 7);
TSNode node = ts_node_named_descendent_for_range(array_node, 6, 7);
AssertThat(ts_node_name(node, document), Equals("array"));
AssertThat(ts_node_size(node).bytes, Equals<size_t>(25));
AssertThat(ts_node_pos(node).bytes, Equals<size_t>(2));
@ -254,26 +254,17 @@ describe("Node", []() {
describe("find_concrete_for_range(start, end)", [&]() {
it("returns the smallest concrete node that spans the given range", [&]() {
TSNode node1 = ts_node_find_concrete_for_range(array_node, 19, 19);
TSNode node1 = ts_node_descendent_for_range(array_node, 19, 19);
AssertThat(ts_node_name(node1, document), Equals(":"));
AssertThat(ts_node_pos(node1).bytes, Equals<size_t>(19));
AssertThat(ts_node_size(node1).bytes, Equals<size_t>(1));
TSNode node2 = ts_node_find_concrete_for_range(array_node, 18, 20);
TSNode node2 = ts_node_descendent_for_range(array_node, 18, 20);
AssertThat(ts_node_name(node2, document), Equals("object"));
AssertThat(ts_node_pos(node2).bytes, Equals<size_t>(15));
AssertThat(ts_node_size(node2).bytes, Equals<size_t>(11));
});
});
describe("find_for_pos(position)", [&]() {
it("finds the smallest node that spans the given position", [&]() {
TSNode node = ts_node_find_for_pos(array_node, 10);
AssertThat(ts_node_name(node, document), Equals("false"));
AssertThat(ts_node_pos(node).bytes, Equals<size_t>(8));
AssertThat(ts_node_size(node).bytes, Equals<size_t>(5));
});
});
});
END_TEST