From a6a08dde31fa9d1cf39cef0fbf62555f207e165a Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Tue, 6 Sep 2016 21:43:59 -0700 Subject: [PATCH] Rename ts_node_name -> ts_node_type --- include/tree_sitter/runtime.h | 2 +- spec/runtime/node_spec.cc | 70 +++++++++++++++++------------------ spec/runtime/parser_spec.cc | 20 +++++----- src/runtime/node.c | 2 +- 4 files changed, 47 insertions(+), 47 deletions(-) diff --git a/include/tree_sitter/runtime.h b/include/tree_sitter/runtime.h index e2a1dd3f..8b9a863e 100644 --- a/include/tree_sitter/runtime.h +++ b/include/tree_sitter/runtime.h @@ -65,7 +65,7 @@ TSPoint ts_node_end_point(TSNode); TSSymbol ts_node_symbol(TSNode); TSSymbolIterator ts_node_symbols(TSNode); void ts_symbol_iterator_next(TSSymbolIterator *); -const char *ts_node_name(TSNode, const TSDocument *); +const char *ts_node_type(TSNode, const TSDocument *); char *ts_node_string(TSNode, const TSDocument *); bool ts_node_eq(TSNode, TSNode); bool ts_node_is_named(TSNode); diff --git a/spec/runtime/node_spec.cc b/spec/runtime/node_spec.cc index 33754c2d..056362a6 100644 --- a/spec/runtime/node_spec.cc +++ b/spec/runtime/node_spec.cc @@ -63,7 +63,7 @@ describe("Node", []() { describe("named_child_count(), named_child(i)", [&]() { it("returns the named child node at the given index", [&]() { - AssertThat(ts_node_name(array_node, document), Equals("array")); + AssertThat(ts_node_type(array_node, document), Equals("array")); AssertThat(ts_node_named_child_count(array_node), Equals(3)); AssertThat(ts_node_start_byte(array_node), Equals(array_index)); @@ -77,9 +77,9 @@ describe("Node", []() { TSNode false_node = ts_node_named_child(array_node, 1); TSNode object_node = ts_node_named_child(array_node, 2); - AssertThat(ts_node_name(number_node, document), Equals("number")); - AssertThat(ts_node_name(false_node, document), Equals("false")); - AssertThat(ts_node_name(object_node, document), Equals("object")); + AssertThat(ts_node_type(number_node, document), Equals("number")); + AssertThat(ts_node_type(false_node, document), Equals("false")); + AssertThat(ts_node_type(object_node, document), Equals("object")); AssertThat(ts_node_start_byte(number_node), Equals(number_index)); AssertThat(ts_node_end_byte(number_node), Equals(number_end_index)); @@ -101,7 +101,7 @@ describe("Node", []() { TSNode pair_node = ts_node_named_child(object_node, 0); - AssertThat(ts_node_name(pair_node, document), Equals("pair")); + AssertThat(ts_node_type(pair_node, document), Equals("pair")); AssertThat(ts_node_start_byte(pair_node), Equals(string_index)); AssertThat(ts_node_end_byte(pair_node), Equals(null_end_index)); AssertThat(ts_node_start_point(pair_node), Equals({ 6, 4 })); @@ -111,8 +111,8 @@ describe("Node", []() { TSNode string_node = ts_node_named_child(pair_node, 0); TSNode null_node = ts_node_named_child(pair_node, 1); - AssertThat(ts_node_name(string_node, document), Equals("string")); - AssertThat(ts_node_name(null_node, document), Equals("null")); + AssertThat(ts_node_type(string_node, document), Equals("string")); + AssertThat(ts_node_type(null_node, document), Equals("null")); AssertThat(ts_node_start_byte(string_node), Equals(string_index)); AssertThat(ts_node_end_byte(string_node), Equals(string_end_index)); @@ -182,14 +182,14 @@ describe("Node", []() { 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("[")); - AssertThat(ts_node_name(child2, document), Equals("number")); - AssertThat(ts_node_name(child3, document), Equals(",")); - AssertThat(ts_node_name(child4, document), Equals("false")); - AssertThat(ts_node_name(child5, document), Equals(",")); - AssertThat(ts_node_name(child6, document), Equals("object")); - AssertThat(ts_node_name(child7, document), Equals("]")); + AssertThat(ts_node_type(array_node, document), Equals("array")); + AssertThat(ts_node_type(child1, document), Equals("[")); + AssertThat(ts_node_type(child2, document), Equals("number")); + AssertThat(ts_node_type(child3, document), Equals(",")); + AssertThat(ts_node_type(child4, document), Equals("false")); + AssertThat(ts_node_type(child5, document), Equals(",")); + AssertThat(ts_node_type(child6, document), Equals("object")); + AssertThat(ts_node_type(child7, document), Equals("]")); AssertThat(ts_node_is_named(array_node), IsTrue()); AssertThat(ts_node_is_named(child1), IsFalse()); @@ -230,13 +230,13 @@ describe("Node", []() { TSNode grandchild3 = ts_node_child(pair, 1); TSNode grandchild4 = ts_node_child(pair, 2); - AssertThat(ts_node_name(left_brace, document), Equals("{")); - AssertThat(ts_node_name(pair, document), Equals("pair")); - AssertThat(ts_node_name(right_brace, document), Equals("}")); + AssertThat(ts_node_type(left_brace, document), Equals("{")); + AssertThat(ts_node_type(pair, document), Equals("pair")); + AssertThat(ts_node_type(right_brace, document), Equals("}")); - AssertThat(ts_node_name(grandchild2, document), Equals("string")); - AssertThat(ts_node_name(grandchild3, document), Equals(":")); - AssertThat(ts_node_name(grandchild4, document), Equals("null")); + AssertThat(ts_node_type(grandchild2, document), Equals("string")); + AssertThat(ts_node_type(grandchild3, document), Equals(":")); + AssertThat(ts_node_type(grandchild4, document), Equals("null")); AssertThat(ts_node_parent(grandchild2), Equals(pair)); AssertThat(ts_node_parent(grandchild3), Equals(pair)); @@ -337,14 +337,14 @@ describe("Node", []() { describe("when there is a leaf node that spans the given range exactly", [&]() { it("returns that leaf node", [&]() { TSNode leaf = ts_node_named_descendant_for_char_range(array_node, string_index, string_end_index - 1); - AssertThat(ts_node_name(leaf, document), Equals("string")); + AssertThat(ts_node_type(leaf, document), Equals("string")); AssertThat(ts_node_start_byte(leaf), Equals(string_index)); AssertThat(ts_node_end_byte(leaf), Equals(string_end_index)); AssertThat(ts_node_start_point(leaf), Equals({ 6, 4 })); AssertThat(ts_node_end_point(leaf), Equals({ 6, 7 })); leaf = ts_node_named_descendant_for_char_range(array_node, number_index, number_end_index - 1); - AssertThat(ts_node_name(leaf, document), Equals("number")); + AssertThat(ts_node_type(leaf, document), Equals("number")); AssertThat(ts_node_start_byte(leaf), Equals(number_index)); AssertThat(ts_node_end_byte(leaf), Equals(number_end_index)); AssertThat(ts_node_start_point(leaf), Equals({ 3, 2 })); @@ -355,14 +355,14 @@ describe("Node", []() { describe("when there is a leaf node that extends beyond the given range", [&]() { it("returns that leaf node", [&]() { TSNode leaf = ts_node_named_descendant_for_char_range(array_node, string_index, string_index + 1); - AssertThat(ts_node_name(leaf, document), Equals("string")); + AssertThat(ts_node_type(leaf, document), Equals("string")); AssertThat(ts_node_start_byte(leaf), Equals(string_index)); AssertThat(ts_node_end_byte(leaf), Equals(string_end_index)); AssertThat(ts_node_start_point(leaf), Equals({ 6, 4 })); AssertThat(ts_node_end_point(leaf), Equals({ 6, 7 })); leaf = ts_node_named_descendant_for_char_range(array_node, string_index + 1, string_index + 2); - AssertThat(ts_node_name(leaf, document), Equals("string")); + AssertThat(ts_node_type(leaf, document), Equals("string")); AssertThat(ts_node_start_byte(leaf), Equals(string_index)); AssertThat(ts_node_end_byte(leaf), Equals(string_end_index)); AssertThat(ts_node_start_point(leaf), Equals({ 6, 4 })); @@ -373,7 +373,7 @@ 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 pair_node = ts_node_named_descendant_for_char_range(array_node, string_index, string_index + 3); - AssertThat(ts_node_name(pair_node, document), Equals("pair")); + AssertThat(ts_node_type(pair_node, document), Equals("pair")); AssertThat(ts_node_start_byte(pair_node), Equals(string_index)); AssertThat(ts_node_end_byte(pair_node), Equals(null_end_index)); AssertThat(ts_node_start_point(pair_node), Equals({ 6, 4 })); @@ -382,7 +382,7 @@ describe("Node", []() { it("does not return invisible nodes (repeats)", [&]() { TSNode node = ts_node_named_descendant_for_char_range(array_node, number_end_index, number_end_index + 1); - AssertThat(ts_node_name(node, document), Equals("array")); + AssertThat(ts_node_type(node, document), Equals("array")); AssertThat(ts_node_start_byte(node), Equals(array_index)); AssertThat(ts_node_end_byte(node), Equals(array_end_index)); AssertThat(ts_node_start_point(node), Equals({ 2, 0 })); @@ -394,14 +394,14 @@ describe("Node", []() { describe("descendant_for_char_range(start, end)", [&]() { it("returns the smallest node that spans the given range", [&]() { TSNode node1 = ts_node_descendant_for_char_range(array_node, colon_index, colon_index); - AssertThat(ts_node_name(node1, document), Equals(":")); + AssertThat(ts_node_type(node1, document), Equals(":")); AssertThat(ts_node_start_byte(node1), Equals(colon_index)); AssertThat(ts_node_end_byte(node1), Equals(colon_index + 1)); AssertThat(ts_node_start_point(node1), Equals({ 6, 7 })); AssertThat(ts_node_end_point(node1), Equals({ 6, 8 })); TSNode node2 = ts_node_descendant_for_char_range(array_node, string_index + 2, string_index + 4); - AssertThat(ts_node_name(node2, document), Equals("pair")); + AssertThat(ts_node_type(node2, document), Equals("pair")); AssertThat(ts_node_start_byte(node2), Equals(string_index)); AssertThat(ts_node_end_byte(node2), Equals(null_end_index)); AssertThat(ts_node_start_point(node2), Equals({ 6, 4 })); @@ -416,26 +416,26 @@ describe("Node", []() { TSNode array_node = ts_document_root_node(document); TSNode node1 = ts_node_descendant_for_char_range(array_node, 7, 7); - AssertThat(ts_node_name(node1, document), Equals(",")); + AssertThat(ts_node_type(node1, document), Equals(",")); TSNode node2 = ts_node_descendant_for_byte_range(array_node, 6, 10); - AssertThat(ts_node_name(node2, document), Equals("string")); - AssertThat(ts_node_start_byte(node2), Equals(1)); - AssertThat(ts_node_end_byte(node2), Equals(11)); + AssertThat(ts_node_type(node2, document), Equals("string")); + AssertThat(ts_node_start_byte(node2), Equals(1)); + AssertThat(ts_node_end_byte(node2), Equals(11)); }); }); describe("descendant_for_point_range(start, end)", [&]() { it("returns the smallest concrete node that spans the given range", [&]() { TSNode node1 = ts_node_descendant_for_point_range(array_node, {6, 7}, {6, 7}); - AssertThat(ts_node_name(node1, document), Equals(":")); + AssertThat(ts_node_type(node1, document), Equals(":")); AssertThat(ts_node_start_byte(node1), Equals(colon_index)); AssertThat(ts_node_end_byte(node1), Equals(colon_index + 1)); AssertThat(ts_node_start_point(node1), Equals({ 6, 7 })); AssertThat(ts_node_end_point(node1), Equals({ 6, 8 })); TSNode node2 = ts_node_descendant_for_point_range(array_node, {6, 6}, {6, 8}); - AssertThat(ts_node_name(node2, document), Equals("pair")); + AssertThat(ts_node_type(node2, document), Equals("pair")); AssertThat(ts_node_start_byte(node2), Equals(string_index)); AssertThat(ts_node_end_byte(node2), Equals(null_end_index)); AssertThat(ts_node_start_point(node2), Equals({ 6, 4 })); diff --git a/spec/runtime/parser_spec.cc b/spec/runtime/parser_spec.cc index 5595e6c8..0f0b5fa1 100644 --- a/spec/runtime/parser_spec.cc +++ b/spec/runtime/parser_spec.cc @@ -101,7 +101,7 @@ describe("Parser", [&]() { "(array (number) (ERROR (UNEXPECTED '@')) (true))"); TSNode error = ts_node_named_child(root, 1); - AssertThat(ts_node_name(error, doc), Equals("ERROR")); + AssertThat(ts_node_type(error, doc), Equals("ERROR")); AssertThat(get_node_text(error), Equals(", @@@@@")); AssertThat(ts_node_child_count(error), Equals(2)); @@ -112,7 +112,7 @@ describe("Parser", [&]() { AssertThat(get_node_text(garbage), Equals("@@@@@")); TSNode node_after_error = ts_node_named_child(root, 2); - AssertThat(ts_node_name(node_after_error, doc), Equals("true")); + AssertThat(ts_node_type(node_after_error, doc), Equals("true")); AssertThat(get_node_text(node_after_error), Equals("true")); }); }); @@ -126,20 +126,20 @@ describe("Parser", [&]() { TSNode error = ts_node_named_child(root, 1); AssertThat(ts_node_symbol(error), Equals(ts_builtin_sym_error)); - AssertThat(ts_node_name(error, doc), Equals("ERROR")); + AssertThat(ts_node_type(error, doc), Equals("ERROR")); AssertThat(get_node_text(error), Equals(", faaaaalse")); AssertThat(ts_node_child_count(error), Equals(2)); TSNode comma = ts_node_child(error, 0); - AssertThat(ts_node_name(comma, doc), Equals(",")); + AssertThat(ts_node_type(comma, doc), Equals(",")); AssertThat(get_node_text(comma), Equals(",")); TSNode garbage = ts_node_child(error, 1); - AssertThat(ts_node_name(garbage, doc), Equals("ERROR")); + AssertThat(ts_node_type(garbage, doc), Equals("ERROR")); AssertThat(get_node_text(garbage), Equals("faaaaalse")); TSNode last = ts_node_named_child(root, 2); - AssertThat(ts_node_name(last, doc), Equals("true")); + AssertThat(ts_node_type(last, doc), Equals("true")); AssertThat(ts_node_start_byte(last), Equals(strlen(" [123, faaaaalse, "))); }); }); @@ -152,12 +152,12 @@ describe("Parser", [&]() { "(array (number) (true) (ERROR (false)) (true))"); TSNode error = ts_node_named_child(root, 2); - AssertThat(ts_node_name(error, doc), Equals("ERROR")); + AssertThat(ts_node_type(error, doc), Equals("ERROR")); AssertThat(get_node_text(error), Equals("false")); AssertThat(ts_node_child_count(error), Equals(1)); TSNode last = ts_node_named_child(root, 1); - AssertThat(ts_node_name(last, doc), Equals("true")); + AssertThat(ts_node_type(last, doc), Equals("true")); AssertThat(get_node_text(last), Equals("true")); }); }); @@ -309,7 +309,7 @@ describe("Parser", [&]() { "(program (expression_statement (math_op (identifier) (number))))"); TSNode node = ts_node_named_descendant_for_char_range(root, 1, 1); - AssertThat(ts_node_name(node, doc), Equals("identifier")); + AssertThat(ts_node_type(node, doc), Equals("identifier")); AssertThat(ts_node_end_byte(node), Equals(strlen("abXYZc"))); }); }); @@ -327,7 +327,7 @@ describe("Parser", [&]() { "(program (expression_statement (math_op (identifier) (number))))"); TSNode node = ts_node_named_descendant_for_char_range(root, 1, 1); - AssertThat(ts_node_name(node, doc), Equals("identifier")); + AssertThat(ts_node_type(node, doc), Equals("identifier")); AssertThat(ts_node_end_byte(node), Equals(strlen("abcXYZ"))); }); }); diff --git a/src/runtime/node.c b/src/runtime/node.c index e28a646b..787fc649 100644 --- a/src/runtime/node.c +++ b/src/runtime/node.c @@ -281,7 +281,7 @@ void ts_symbol_iterator_next(TSSymbolIterator *self) { self->done = true; } -const char *ts_node_name(TSNode self, const TSDocument *document) { +const char *ts_node_type(TSNode self, const TSDocument *document) { TSSymbol symbol = ts_node__tree(self)->symbol; return ts_language_symbol_name(document->parser.language, symbol); }