From 7ee5eaa16a50010d3294efe3eeeb053095e732dd Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Tue, 8 Sep 2015 23:16:24 -0700 Subject: [PATCH] Rename node accessor methods 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 --- include/tree_sitter/parser.h | 4 +- include/tree_sitter/runtime.h | 28 ++-- spec/fixtures/parsers/arithmetic.c | 36 ++--- spec/fixtures/parsers/c.c | 102 +++++++------- spec/fixtures/parsers/golang.c | 130 +++++++++--------- spec/fixtures/parsers/javascript.c | 190 +++++++++++++------------- spec/fixtures/parsers/json.c | 28 ++-- spec/runtime/node_spec.cc | 197 +++++++++++++-------------- spec/runtime/parse_stack_spec.cc | 2 +- spec/runtime/parser_spec.cc | 24 ++-- spec/runtime/stack_spec.cc | 2 +- spec/runtime/tree_spec.cc | 24 ++-- src/compiler/generate_code/c_code.cc | 4 +- src/runtime/document.c | 2 +- src/runtime/node.c | 170 ++++++++++++----------- src/runtime/tree.c | 8 +- 16 files changed, 475 insertions(+), 476 deletions(-) diff --git a/include/tree_sitter/parser.h b/include/tree_sitter/parser.h index f1ffee89..bb29a627 100644 --- a/include/tree_sitter/parser.h +++ b/include/tree_sitter/parser.h @@ -18,8 +18,8 @@ typedef unsigned short TSStateId; typedef enum { TSNodeTypeHidden, - TSNodeTypeConcrete, - TSNodeTypeNormal, + TSNodeTypeAnonymous, + TSNodeTypeNamed, } TSNodeType; typedef struct TSLexer { diff --git a/include/tree_sitter/runtime.h b/include/tree_sitter/runtime.h index 20cdd515..5c49676c 100644 --- a/include/tree_sitter/runtime.h +++ b/include/tree_sitter/runtime.h @@ -48,24 +48,22 @@ typedef struct TSDocument TSDocument; TSLength ts_node_pos(TSNode); TSLength ts_node_size(TSNode); -TSSymbol ts_node_sym(TSNode); -TSNode ts_node_child(TSNode, size_t); -size_t ts_node_child_count(TSNode); -TSNode ts_node_concrete_child(TSNode, size_t); -size_t ts_node_concrete_child_count(TSNode); -TSNode ts_node_find_for_pos(TSNode, size_t); -TSNode ts_node_find_for_range(TSNode, size_t, size_t); -TSNode ts_node_find_concrete_for_pos(TSNode, size_t); -TSNode ts_node_find_concrete_for_range(TSNode, size_t, size_t); -TSNode ts_node_parent(TSNode); -TSNode ts_node_next_sibling(TSNode); -TSNode ts_node_prev_sibling(TSNode); -TSNode ts_node_next_concrete_sibling(TSNode); -TSNode ts_node_prev_concrete_sibling(TSNode); +TSSymbol ts_node_symbol(TSNode); const char *ts_node_name(TSNode, const TSDocument *); const char *ts_node_string(TSNode, const TSDocument *); bool ts_node_eq(TSNode, TSNode); -bool ts_node_is_concrete(TSNode); +bool ts_node_is_named(TSNode); +TSNode ts_node_parent(TSNode); +TSNode ts_node_child(TSNode, size_t); +TSNode ts_node_named_child(TSNode, size_t); +size_t ts_node_child_count(TSNode); +size_t ts_node_named_child_count(TSNode); +TSNode ts_node_next_sibling(TSNode); +TSNode ts_node_next_named_sibling(TSNode); +TSNode ts_node_prev_sibling(TSNode); +TSNode ts_node_prev_named_sibling(TSNode); +TSNode ts_node_descendent_for_range(TSNode, size_t, size_t); +TSNode ts_node_named_descendent_for_range(TSNode, size_t, size_t); TSDocument *ts_document_make(); void ts_document_free(TSDocument *); diff --git a/spec/fixtures/parsers/arithmetic.c b/spec/fixtures/parsers/arithmetic.c index ed8c57fb..64295658 100644 --- a/spec/fixtures/parsers/arithmetic.c +++ b/spec/fixtures/parsers/arithmetic.c @@ -48,26 +48,26 @@ static const char *ts_symbol_names[] = { }; static const TSNodeType ts_node_types[SYMBOL_COUNT] = { - [sym_program] = TSNodeTypeNormal, + [sym_program] = TSNodeTypeNamed, [sym__expression] = TSNodeTypeHidden, - [sym_sum] = TSNodeTypeNormal, - [sym_difference] = TSNodeTypeNormal, - [sym_product] = TSNodeTypeNormal, - [sym_quotient] = TSNodeTypeNormal, - [sym_exponent] = TSNodeTypeNormal, - [sym_group] = TSNodeTypeNormal, - [ts_builtin_sym_error] = TSNodeTypeNormal, + [sym_sum] = TSNodeTypeNamed, + [sym_difference] = TSNodeTypeNamed, + [sym_product] = TSNodeTypeNamed, + [sym_quotient] = TSNodeTypeNamed, + [sym_exponent] = TSNodeTypeNamed, + [sym_group] = TSNodeTypeNamed, + [ts_builtin_sym_error] = TSNodeTypeNamed, [ts_builtin_sym_end] = TSNodeTypeHidden, - [anon_sym_PLUS] = TSNodeTypeConcrete, - [anon_sym_DASH] = TSNodeTypeConcrete, - [anon_sym_STAR] = TSNodeTypeConcrete, - [anon_sym_SLASH] = TSNodeTypeConcrete, - [anon_sym_CARET] = TSNodeTypeConcrete, - [anon_sym_LPAREN] = TSNodeTypeConcrete, - [anon_sym_RPAREN] = TSNodeTypeConcrete, - [sym_number] = TSNodeTypeNormal, - [sym_variable] = TSNodeTypeNormal, - [sym_comment] = TSNodeTypeNormal, + [anon_sym_PLUS] = TSNodeTypeAnonymous, + [anon_sym_DASH] = TSNodeTypeAnonymous, + [anon_sym_STAR] = TSNodeTypeAnonymous, + [anon_sym_SLASH] = TSNodeTypeAnonymous, + [anon_sym_CARET] = TSNodeTypeAnonymous, + [anon_sym_LPAREN] = TSNodeTypeAnonymous, + [anon_sym_RPAREN] = TSNodeTypeAnonymous, + [sym_number] = TSNodeTypeNamed, + [sym_variable] = TSNodeTypeNamed, + [sym_comment] = TSNodeTypeNamed, }; static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) { diff --git a/spec/fixtures/parsers/c.c b/spec/fixtures/parsers/c.c index f1e4a83f..4a35c31e 100644 --- a/spec/fixtures/parsers/c.c +++ b/spec/fixtures/parsers/c.c @@ -138,30 +138,30 @@ static const char *ts_symbol_names[] = { }; static const TSNodeType ts_node_types[SYMBOL_COUNT] = { - [sym_program] = TSNodeTypeNormal, - [sym_function_definition] = TSNodeTypeNormal, - [sym_declaration_specifiers] = TSNodeTypeNormal, - [sym_storage_class_specifier] = TSNodeTypeNormal, + [sym_program] = TSNodeTypeNamed, + [sym_function_definition] = TSNodeTypeNamed, + [sym_declaration_specifiers] = TSNodeTypeNamed, + [sym_storage_class_specifier] = TSNodeTypeNamed, [sym__type_specifier] = TSNodeTypeHidden, - [sym_type_name] = TSNodeTypeNormal, - [sym_struct_specifier] = TSNodeTypeNormal, - [sym_struct_declaration] = TSNodeTypeNormal, - [sym_parameter_declaration] = TSNodeTypeNormal, - [sym_declaration] = TSNodeTypeNormal, + [sym_type_name] = TSNodeTypeNamed, + [sym_struct_specifier] = TSNodeTypeNamed, + [sym_struct_declaration] = TSNodeTypeNamed, + [sym_parameter_declaration] = TSNodeTypeNamed, + [sym_declaration] = TSNodeTypeNamed, [sym__init_declarator] = TSNodeTypeHidden, - [sym_initializer] = TSNodeTypeNormal, - [sym_initializer_list] = TSNodeTypeNormal, - [sym_designation] = TSNodeTypeNormal, - [sym_declarator] = TSNodeTypeNormal, + [sym_initializer] = TSNodeTypeNamed, + [sym_initializer_list] = TSNodeTypeNamed, + [sym_designation] = TSNodeTypeNamed, + [sym_declarator] = TSNodeTypeNamed, [sym__direct_declarator] = TSNodeTypeHidden, - [sym_type_qualifier] = TSNodeTypeNormal, - [sym_pointer] = TSNodeTypeNormal, - [sym_compound_statement] = TSNodeTypeNormal, - [sym_expression] = TSNodeTypeNormal, - [sym_math_expression] = TSNodeTypeNormal, - [sym_call_expression] = TSNodeTypeNormal, - [sym_statement] = TSNodeTypeNormal, - [sym_expression_statement] = TSNodeTypeNormal, + [sym_type_qualifier] = TSNodeTypeNamed, + [sym_pointer] = TSNodeTypeNamed, + [sym_compound_statement] = TSNodeTypeNamed, + [sym_expression] = TSNodeTypeNamed, + [sym_math_expression] = TSNodeTypeNamed, + [sym_call_expression] = TSNodeTypeNamed, + [sym_statement] = TSNodeTypeNamed, + [sym_expression_statement] = TSNodeTypeNamed, [aux_sym_function_definition_repeat1] = TSNodeTypeHidden, [aux_sym_declaration_specifiers_repeat1] = TSNodeTypeHidden, [aux_sym_type_name_repeat1] = TSNodeTypeHidden, @@ -172,37 +172,37 @@ static const TSNodeType ts_node_types[SYMBOL_COUNT] = { [aux_sym__direct_declarator_repeat1] = TSNodeTypeHidden, [aux_sym_compound_statement_repeat1] = TSNodeTypeHidden, [aux_sym_call_expression_repeat1] = TSNodeTypeHidden, - [ts_builtin_sym_error] = TSNodeTypeNormal, + [ts_builtin_sym_error] = TSNodeTypeNamed, [ts_builtin_sym_end] = TSNodeTypeHidden, - [anon_sym_typedef] = TSNodeTypeConcrete, - [anon_sym_extern] = TSNodeTypeConcrete, - [anon_sym_static] = TSNodeTypeConcrete, - [anon_sym_auto] = TSNodeTypeConcrete, - [anon_sym_register] = TSNodeTypeConcrete, - [anon_sym_signed] = TSNodeTypeConcrete, - [anon_sym_unsigned] = TSNodeTypeConcrete, - [anon_sym_long] = TSNodeTypeConcrete, - [anon_sym_short] = TSNodeTypeConcrete, - [anon_sym_struct] = TSNodeTypeConcrete, - [anon_sym_LBRACE] = TSNodeTypeConcrete, - [anon_sym_RBRACE] = TSNodeTypeConcrete, - [anon_sym_COMMA] = TSNodeTypeConcrete, - [anon_sym_SEMI] = TSNodeTypeConcrete, - [anon_sym_EQ] = TSNodeTypeConcrete, - [anon_sym_LBRACK] = TSNodeTypeConcrete, - [anon_sym_RBRACK] = TSNodeTypeConcrete, - [anon_sym_DOT] = TSNodeTypeConcrete, - [anon_sym_LPAREN] = TSNodeTypeConcrete, - [anon_sym_RPAREN] = TSNodeTypeConcrete, - [anon_sym_const] = TSNodeTypeConcrete, - [anon_sym_restrict] = TSNodeTypeConcrete, - [anon_sym_volatile] = TSNodeTypeConcrete, - [anon_sym_STAR] = TSNodeTypeConcrete, - [anon_sym_PLUS] = TSNodeTypeConcrete, - [sym_string] = TSNodeTypeNormal, - [sym_identifier] = TSNodeTypeNormal, - [sym_number] = TSNodeTypeNormal, - [sym_comment] = TSNodeTypeNormal, + [anon_sym_typedef] = TSNodeTypeAnonymous, + [anon_sym_extern] = TSNodeTypeAnonymous, + [anon_sym_static] = TSNodeTypeAnonymous, + [anon_sym_auto] = TSNodeTypeAnonymous, + [anon_sym_register] = TSNodeTypeAnonymous, + [anon_sym_signed] = TSNodeTypeAnonymous, + [anon_sym_unsigned] = TSNodeTypeAnonymous, + [anon_sym_long] = TSNodeTypeAnonymous, + [anon_sym_short] = TSNodeTypeAnonymous, + [anon_sym_struct] = TSNodeTypeAnonymous, + [anon_sym_LBRACE] = TSNodeTypeAnonymous, + [anon_sym_RBRACE] = TSNodeTypeAnonymous, + [anon_sym_COMMA] = TSNodeTypeAnonymous, + [anon_sym_SEMI] = TSNodeTypeAnonymous, + [anon_sym_EQ] = TSNodeTypeAnonymous, + [anon_sym_LBRACK] = TSNodeTypeAnonymous, + [anon_sym_RBRACK] = TSNodeTypeAnonymous, + [anon_sym_DOT] = TSNodeTypeAnonymous, + [anon_sym_LPAREN] = TSNodeTypeAnonymous, + [anon_sym_RPAREN] = TSNodeTypeAnonymous, + [anon_sym_const] = TSNodeTypeAnonymous, + [anon_sym_restrict] = TSNodeTypeAnonymous, + [anon_sym_volatile] = TSNodeTypeAnonymous, + [anon_sym_STAR] = TSNodeTypeAnonymous, + [anon_sym_PLUS] = TSNodeTypeAnonymous, + [sym_string] = TSNodeTypeNamed, + [sym_identifier] = TSNodeTypeNamed, + [sym_number] = TSNodeTypeNamed, + [sym_comment] = TSNodeTypeNamed, }; static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) { diff --git a/spec/fixtures/parsers/golang.c b/spec/fixtures/parsers/golang.c index 135f017f..6069d17e 100644 --- a/spec/fixtures/parsers/golang.c +++ b/spec/fixtures/parsers/golang.c @@ -176,36 +176,36 @@ static const char *ts_symbol_names[] = { }; static const TSNodeType ts_node_types[SYMBOL_COUNT] = { - [sym_program] = TSNodeTypeNormal, - [sym_package_directive] = TSNodeTypeNormal, - [sym_imports_block] = TSNodeTypeNormal, - [sym_package_import] = TSNodeTypeNormal, + [sym_program] = TSNodeTypeNamed, + [sym_package_directive] = TSNodeTypeNamed, + [sym_imports_block] = TSNodeTypeNamed, + [sym_package_import] = TSNodeTypeNamed, [sym__declaration] = TSNodeTypeHidden, - [sym_type_declaration] = TSNodeTypeNormal, - [sym_var_declaration] = TSNodeTypeNormal, - [sym_func_declaration] = TSNodeTypeNormal, - [sym_block_statement] = TSNodeTypeNormal, + [sym_type_declaration] = TSNodeTypeNamed, + [sym_var_declaration] = TSNodeTypeNamed, + [sym_func_declaration] = TSNodeTypeNamed, + [sym_block_statement] = TSNodeTypeNamed, [sym__type_expression] = TSNodeTypeHidden, - [sym_pointer_type] = TSNodeTypeNormal, - [sym_map_type] = TSNodeTypeNormal, - [sym_slice_type] = TSNodeTypeNormal, - [sym_struct_type] = TSNodeTypeNormal, - [sym_interface_type] = TSNodeTypeNormal, + [sym_pointer_type] = TSNodeTypeNamed, + [sym_map_type] = TSNodeTypeNamed, + [sym_slice_type] = TSNodeTypeNamed, + [sym_struct_type] = TSNodeTypeNamed, + [sym_interface_type] = TSNodeTypeNamed, [sym__statement] = TSNodeTypeHidden, - [sym_return_statement] = TSNodeTypeNormal, - [sym_short_var_declaration] = TSNodeTypeNormal, - [sym_range_statement] = TSNodeTypeNormal, - [sym_if_statement] = TSNodeTypeNormal, - [sym_expression_statement] = TSNodeTypeNormal, + [sym_return_statement] = TSNodeTypeNamed, + [sym_short_var_declaration] = TSNodeTypeNamed, + [sym_range_statement] = TSNodeTypeNamed, + [sym_if_statement] = TSNodeTypeNamed, + [sym_expression_statement] = TSNodeTypeNamed, [sym__expression] = TSNodeTypeHidden, - [sym_call_expression] = TSNodeTypeNormal, - [sym_selector_expression] = TSNodeTypeNormal, - [sym_math_op] = TSNodeTypeNormal, - [sym_bool_op] = TSNodeTypeNormal, + [sym_call_expression] = TSNodeTypeNamed, + [sym_selector_expression] = TSNodeTypeNamed, + [sym_math_op] = TSNodeTypeNamed, + [sym_bool_op] = TSNodeTypeNamed, [sym__func_signature] = TSNodeTypeHidden, - [sym_package_name] = TSNodeTypeNormal, - [sym_var_name] = TSNodeTypeNormal, - [sym_type_name] = TSNodeTypeNormal, + [sym_package_name] = TSNodeTypeNamed, + [sym_var_name] = TSNodeTypeNamed, + [sym_type_name] = TSNodeTypeNamed, [aux_sym_program_repeat1] = TSNodeTypeHidden, [aux_sym_program_repeat2] = TSNodeTypeHidden, [aux_sym_imports_block_repeat1] = TSNodeTypeHidden, @@ -217,49 +217,49 @@ static const TSNodeType ts_node_types[SYMBOL_COUNT] = { [aux_sym__func_signature_repeat1] = TSNodeTypeHidden, [aux_sym__func_signature_repeat2] = TSNodeTypeHidden, [aux_sym__func_signature_repeat3] = TSNodeTypeHidden, - [ts_builtin_sym_error] = TSNodeTypeNormal, + [ts_builtin_sym_error] = TSNodeTypeNamed, [ts_builtin_sym_end] = TSNodeTypeHidden, - [anon_sym_package] = TSNodeTypeConcrete, - [anon_sym_import] = TSNodeTypeConcrete, - [anon_sym_LPAREN] = TSNodeTypeConcrete, - [anon_sym_RPAREN] = TSNodeTypeConcrete, - [anon_sym_type] = TSNodeTypeConcrete, - [anon_sym_SEMI] = TSNodeTypeConcrete, - [anon_sym_var] = TSNodeTypeConcrete, - [anon_sym_EQ] = TSNodeTypeConcrete, - [anon_sym_func] = TSNodeTypeConcrete, - [anon_sym_LBRACE] = TSNodeTypeConcrete, - [anon_sym_RBRACE] = TSNodeTypeConcrete, - [anon_sym_STAR] = TSNodeTypeConcrete, - [anon_sym_map] = TSNodeTypeConcrete, - [anon_sym_LBRACK] = TSNodeTypeConcrete, - [anon_sym_RBRACK] = TSNodeTypeConcrete, - [anon_sym_struct] = TSNodeTypeConcrete, - [anon_sym_interface] = TSNodeTypeConcrete, - [anon_sym_return] = TSNodeTypeConcrete, - [anon_sym_COMMA] = TSNodeTypeConcrete, - [anon_sym_COLON_EQ] = TSNodeTypeConcrete, - [anon_sym_for] = TSNodeTypeConcrete, - [anon_sym_range] = TSNodeTypeConcrete, - [anon_sym_if] = TSNodeTypeConcrete, - [anon_sym_else] = TSNodeTypeConcrete, - [anon_sym_DOT] = TSNodeTypeConcrete, - [anon_sym_SLASH] = TSNodeTypeConcrete, - [anon_sym_PLUS] = TSNodeTypeConcrete, - [anon_sym_DASH] = TSNodeTypeConcrete, - [anon_sym_PIPE_PIPE] = TSNodeTypeConcrete, - [anon_sym_AMP_AMP] = TSNodeTypeConcrete, - [anon_sym_EQ_EQ] = TSNodeTypeConcrete, - [anon_sym_LT_EQ] = TSNodeTypeConcrete, - [anon_sym_LT] = TSNodeTypeConcrete, - [anon_sym_GT_EQ] = TSNodeTypeConcrete, - [anon_sym_GT] = TSNodeTypeConcrete, - [anon_sym_BANG] = TSNodeTypeConcrete, + [anon_sym_package] = TSNodeTypeAnonymous, + [anon_sym_import] = TSNodeTypeAnonymous, + [anon_sym_LPAREN] = TSNodeTypeAnonymous, + [anon_sym_RPAREN] = TSNodeTypeAnonymous, + [anon_sym_type] = TSNodeTypeAnonymous, + [anon_sym_SEMI] = TSNodeTypeAnonymous, + [anon_sym_var] = TSNodeTypeAnonymous, + [anon_sym_EQ] = TSNodeTypeAnonymous, + [anon_sym_func] = TSNodeTypeAnonymous, + [anon_sym_LBRACE] = TSNodeTypeAnonymous, + [anon_sym_RBRACE] = TSNodeTypeAnonymous, + [anon_sym_STAR] = TSNodeTypeAnonymous, + [anon_sym_map] = TSNodeTypeAnonymous, + [anon_sym_LBRACK] = TSNodeTypeAnonymous, + [anon_sym_RBRACK] = TSNodeTypeAnonymous, + [anon_sym_struct] = TSNodeTypeAnonymous, + [anon_sym_interface] = TSNodeTypeAnonymous, + [anon_sym_return] = TSNodeTypeAnonymous, + [anon_sym_COMMA] = TSNodeTypeAnonymous, + [anon_sym_COLON_EQ] = TSNodeTypeAnonymous, + [anon_sym_for] = TSNodeTypeAnonymous, + [anon_sym_range] = TSNodeTypeAnonymous, + [anon_sym_if] = TSNodeTypeAnonymous, + [anon_sym_else] = TSNodeTypeAnonymous, + [anon_sym_DOT] = TSNodeTypeAnonymous, + [anon_sym_SLASH] = TSNodeTypeAnonymous, + [anon_sym_PLUS] = TSNodeTypeAnonymous, + [anon_sym_DASH] = TSNodeTypeAnonymous, + [anon_sym_PIPE_PIPE] = TSNodeTypeAnonymous, + [anon_sym_AMP_AMP] = TSNodeTypeAnonymous, + [anon_sym_EQ_EQ] = TSNodeTypeAnonymous, + [anon_sym_LT_EQ] = TSNodeTypeAnonymous, + [anon_sym_LT] = TSNodeTypeAnonymous, + [anon_sym_GT_EQ] = TSNodeTypeAnonymous, + [anon_sym_GT] = TSNodeTypeAnonymous, + [anon_sym_BANG] = TSNodeTypeAnonymous, [sym__line_break] = TSNodeTypeHidden, - [sym_string] = TSNodeTypeNormal, + [sym_string] = TSNodeTypeNamed, [sym__identifier] = TSNodeTypeHidden, - [sym_number] = TSNodeTypeNormal, - [sym_comment] = TSNodeTypeNormal, + [sym_number] = TSNodeTypeNamed, + [sym_comment] = TSNodeTypeNamed, }; static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) { diff --git a/spec/fixtures/parsers/javascript.c b/spec/fixtures/parsers/javascript.c index a2de3fa3..8f0a67b1 100644 --- a/spec/fixtures/parsers/javascript.c +++ b/spec/fixtures/parsers/javascript.c @@ -220,111 +220,111 @@ static const char *ts_symbol_names[] = { }; static const TSNodeType ts_node_types[SYMBOL_COUNT] = { - [sym_program] = TSNodeTypeNormal, + [sym_program] = TSNodeTypeNamed, [sym__statement] = TSNodeTypeHidden, - [sym_expression_statement] = TSNodeTypeNormal, - [sym_var_declaration] = TSNodeTypeNormal, - [sym_statement_block] = TSNodeTypeNormal, - [sym_if_statement] = TSNodeTypeNormal, - [sym_switch_statement] = TSNodeTypeNormal, - [sym_for_statement] = TSNodeTypeNormal, - [sym_for_in_statement] = TSNodeTypeNormal, - [sym_while_statement] = TSNodeTypeNormal, - [sym_try_statement] = TSNodeTypeNormal, - [sym_return_statement] = TSNodeTypeNormal, - [sym_throw_statement] = TSNodeTypeNormal, - [sym_break_statement] = TSNodeTypeNormal, - [sym_delete_statement] = TSNodeTypeNormal, - [sym_case] = TSNodeTypeNormal, - [sym_default] = TSNodeTypeNormal, - [sym_catch] = TSNodeTypeNormal, - [sym_finally] = TSNodeTypeNormal, - [sym_var_assignment] = TSNodeTypeNormal, + [sym_expression_statement] = TSNodeTypeNamed, + [sym_var_declaration] = TSNodeTypeNamed, + [sym_statement_block] = TSNodeTypeNamed, + [sym_if_statement] = TSNodeTypeNamed, + [sym_switch_statement] = TSNodeTypeNamed, + [sym_for_statement] = TSNodeTypeNamed, + [sym_for_in_statement] = TSNodeTypeNamed, + [sym_while_statement] = TSNodeTypeNamed, + [sym_try_statement] = TSNodeTypeNamed, + [sym_return_statement] = TSNodeTypeNamed, + [sym_throw_statement] = TSNodeTypeNamed, + [sym_break_statement] = TSNodeTypeNamed, + [sym_delete_statement] = TSNodeTypeNamed, + [sym_case] = TSNodeTypeNamed, + [sym_default] = TSNodeTypeNamed, + [sym_catch] = TSNodeTypeNamed, + [sym_finally] = TSNodeTypeNamed, + [sym_var_assignment] = TSNodeTypeNamed, [sym__paren_expression] = TSNodeTypeHidden, [sym__expression] = TSNodeTypeHidden, - [sym_object] = TSNodeTypeNormal, - [sym_array] = TSNodeTypeNormal, - [sym_function_expression] = TSNodeTypeNormal, - [sym_function_call] = TSNodeTypeNormal, - [sym_constructor_call] = TSNodeTypeNormal, - [sym_member_access] = TSNodeTypeNormal, - [sym_subscript_access] = TSNodeTypeNormal, - [sym_assignment] = TSNodeTypeNormal, - [sym_math_assignment] = TSNodeTypeNormal, - [sym_ternary] = TSNodeTypeNormal, - [sym_bool_op] = TSNodeTypeNormal, - [sym_math_op] = TSNodeTypeNormal, - [sym_rel_op] = TSNodeTypeNormal, - [sym_type_op] = TSNodeTypeNormal, - [sym_formal_parameters] = TSNodeTypeNormal, - [sym_arguments] = TSNodeTypeNormal, - [sym_pair] = TSNodeTypeNormal, + [sym_object] = TSNodeTypeNamed, + [sym_array] = TSNodeTypeNamed, + [sym_function_expression] = TSNodeTypeNamed, + [sym_function_call] = TSNodeTypeNamed, + [sym_constructor_call] = TSNodeTypeNamed, + [sym_member_access] = TSNodeTypeNamed, + [sym_subscript_access] = TSNodeTypeNamed, + [sym_assignment] = TSNodeTypeNamed, + [sym_math_assignment] = TSNodeTypeNamed, + [sym_ternary] = TSNodeTypeNamed, + [sym_bool_op] = TSNodeTypeNamed, + [sym_math_op] = TSNodeTypeNamed, + [sym_rel_op] = TSNodeTypeNamed, + [sym_type_op] = TSNodeTypeNamed, + [sym_formal_parameters] = TSNodeTypeNamed, + [sym_arguments] = TSNodeTypeNamed, + [sym_pair] = TSNodeTypeNamed, [aux_sym_program_repeat1] = TSNodeTypeHidden, [aux_sym_var_declaration_repeat1] = TSNodeTypeHidden, [aux_sym_switch_statement_repeat1] = TSNodeTypeHidden, [aux_sym_object_repeat1] = TSNodeTypeHidden, [aux_sym_array_repeat1] = TSNodeTypeHidden, [aux_sym_formal_parameters_repeat1] = TSNodeTypeHidden, - [ts_builtin_sym_error] = TSNodeTypeNormal, + [ts_builtin_sym_error] = TSNodeTypeNamed, [ts_builtin_sym_end] = TSNodeTypeHidden, - [anon_sym_SEMI] = TSNodeTypeConcrete, - [anon_sym_var] = TSNodeTypeConcrete, - [anon_sym_COMMA] = TSNodeTypeConcrete, - [anon_sym_LBRACE] = TSNodeTypeConcrete, - [anon_sym_RBRACE] = TSNodeTypeConcrete, - [anon_sym_if] = TSNodeTypeConcrete, - [anon_sym_else] = TSNodeTypeConcrete, - [anon_sym_switch] = TSNodeTypeConcrete, - [anon_sym_for] = TSNodeTypeConcrete, - [anon_sym_LPAREN] = TSNodeTypeConcrete, - [anon_sym_RPAREN] = TSNodeTypeConcrete, - [anon_sym_in] = TSNodeTypeConcrete, - [anon_sym_while] = TSNodeTypeConcrete, - [anon_sym_try] = TSNodeTypeConcrete, - [anon_sym_return] = TSNodeTypeConcrete, - [anon_sym_throw] = TSNodeTypeConcrete, - [anon_sym_break] = TSNodeTypeConcrete, - [anon_sym_delete] = TSNodeTypeConcrete, - [anon_sym_case] = TSNodeTypeConcrete, - [anon_sym_COLON] = TSNodeTypeConcrete, - [anon_sym_default] = TSNodeTypeConcrete, - [anon_sym_catch] = TSNodeTypeConcrete, - [anon_sym_finally] = TSNodeTypeConcrete, - [anon_sym_EQ] = TSNodeTypeConcrete, - [anon_sym_LBRACK] = TSNodeTypeConcrete, - [anon_sym_RBRACK] = TSNodeTypeConcrete, - [anon_sym_function] = TSNodeTypeConcrete, - [anon_sym_new] = TSNodeTypeConcrete, - [anon_sym_DOT] = TSNodeTypeConcrete, - [anon_sym_PLUS_EQ] = TSNodeTypeConcrete, - [anon_sym_DASH_EQ] = TSNodeTypeConcrete, - [anon_sym_STAR_EQ] = TSNodeTypeConcrete, - [anon_sym_SLASH_EQ] = TSNodeTypeConcrete, - [anon_sym_QMARK] = TSNodeTypeConcrete, - [anon_sym_PIPE_PIPE] = TSNodeTypeConcrete, - [anon_sym_AMP_AMP] = TSNodeTypeConcrete, - [anon_sym_BANG] = TSNodeTypeConcrete, - [anon_sym_PLUS_PLUS] = TSNodeTypeConcrete, - [anon_sym_DASH_DASH] = TSNodeTypeConcrete, - [anon_sym_STAR] = TSNodeTypeConcrete, - [anon_sym_SLASH] = TSNodeTypeConcrete, - [anon_sym_PLUS] = TSNodeTypeConcrete, - [anon_sym_DASH] = TSNodeTypeConcrete, - [anon_sym_EQ_EQ_EQ] = TSNodeTypeConcrete, - [anon_sym_BANG_EQ_EQ] = TSNodeTypeConcrete, - [anon_sym_LT] = TSNodeTypeConcrete, - [anon_sym_GT] = TSNodeTypeConcrete, - [anon_sym_instanceof] = TSNodeTypeConcrete, - [anon_sym_typeof] = TSNodeTypeConcrete, - [sym_comment] = TSNodeTypeNormal, - [sym_string] = TSNodeTypeNormal, - [sym_regex] = TSNodeTypeNormal, - [sym_number] = TSNodeTypeNormal, - [sym_identifier] = TSNodeTypeNormal, - [sym_null] = TSNodeTypeNormal, - [sym_undefined] = TSNodeTypeNormal, - [sym_true] = TSNodeTypeNormal, - [sym_false] = TSNodeTypeNormal, + [anon_sym_SEMI] = TSNodeTypeAnonymous, + [anon_sym_var] = TSNodeTypeAnonymous, + [anon_sym_COMMA] = TSNodeTypeAnonymous, + [anon_sym_LBRACE] = TSNodeTypeAnonymous, + [anon_sym_RBRACE] = TSNodeTypeAnonymous, + [anon_sym_if] = TSNodeTypeAnonymous, + [anon_sym_else] = TSNodeTypeAnonymous, + [anon_sym_switch] = TSNodeTypeAnonymous, + [anon_sym_for] = TSNodeTypeAnonymous, + [anon_sym_LPAREN] = TSNodeTypeAnonymous, + [anon_sym_RPAREN] = TSNodeTypeAnonymous, + [anon_sym_in] = TSNodeTypeAnonymous, + [anon_sym_while] = TSNodeTypeAnonymous, + [anon_sym_try] = TSNodeTypeAnonymous, + [anon_sym_return] = TSNodeTypeAnonymous, + [anon_sym_throw] = TSNodeTypeAnonymous, + [anon_sym_break] = TSNodeTypeAnonymous, + [anon_sym_delete] = TSNodeTypeAnonymous, + [anon_sym_case] = TSNodeTypeAnonymous, + [anon_sym_COLON] = TSNodeTypeAnonymous, + [anon_sym_default] = TSNodeTypeAnonymous, + [anon_sym_catch] = TSNodeTypeAnonymous, + [anon_sym_finally] = TSNodeTypeAnonymous, + [anon_sym_EQ] = TSNodeTypeAnonymous, + [anon_sym_LBRACK] = TSNodeTypeAnonymous, + [anon_sym_RBRACK] = TSNodeTypeAnonymous, + [anon_sym_function] = TSNodeTypeAnonymous, + [anon_sym_new] = TSNodeTypeAnonymous, + [anon_sym_DOT] = TSNodeTypeAnonymous, + [anon_sym_PLUS_EQ] = TSNodeTypeAnonymous, + [anon_sym_DASH_EQ] = TSNodeTypeAnonymous, + [anon_sym_STAR_EQ] = TSNodeTypeAnonymous, + [anon_sym_SLASH_EQ] = TSNodeTypeAnonymous, + [anon_sym_QMARK] = TSNodeTypeAnonymous, + [anon_sym_PIPE_PIPE] = TSNodeTypeAnonymous, + [anon_sym_AMP_AMP] = TSNodeTypeAnonymous, + [anon_sym_BANG] = TSNodeTypeAnonymous, + [anon_sym_PLUS_PLUS] = TSNodeTypeAnonymous, + [anon_sym_DASH_DASH] = TSNodeTypeAnonymous, + [anon_sym_STAR] = TSNodeTypeAnonymous, + [anon_sym_SLASH] = TSNodeTypeAnonymous, + [anon_sym_PLUS] = TSNodeTypeAnonymous, + [anon_sym_DASH] = TSNodeTypeAnonymous, + [anon_sym_EQ_EQ_EQ] = TSNodeTypeAnonymous, + [anon_sym_BANG_EQ_EQ] = TSNodeTypeAnonymous, + [anon_sym_LT] = TSNodeTypeAnonymous, + [anon_sym_GT] = TSNodeTypeAnonymous, + [anon_sym_instanceof] = TSNodeTypeAnonymous, + [anon_sym_typeof] = TSNodeTypeAnonymous, + [sym_comment] = TSNodeTypeNamed, + [sym_string] = TSNodeTypeNamed, + [sym_regex] = TSNodeTypeNamed, + [sym_number] = TSNodeTypeNamed, + [sym_identifier] = TSNodeTypeNamed, + [sym_null] = TSNodeTypeNamed, + [sym_undefined] = TSNodeTypeNamed, + [sym_true] = TSNodeTypeNamed, + [sym_false] = TSNodeTypeNamed, [sym__line_break] = TSNodeTypeHidden, }; diff --git a/spec/fixtures/parsers/json.c b/spec/fixtures/parsers/json.c index 98293f01..842f4cbc 100644 --- a/spec/fixtures/parsers/json.c +++ b/spec/fixtures/parsers/json.c @@ -45,23 +45,23 @@ static const char *ts_symbol_names[] = { static const TSNodeType ts_node_types[SYMBOL_COUNT] = { [sym__value] = TSNodeTypeHidden, - [sym_object] = TSNodeTypeNormal, - [sym_array] = TSNodeTypeNormal, + [sym_object] = TSNodeTypeNamed, + [sym_array] = TSNodeTypeNamed, [aux_sym_object_repeat1] = TSNodeTypeHidden, [aux_sym_array_repeat1] = TSNodeTypeHidden, - [ts_builtin_sym_error] = TSNodeTypeNormal, + [ts_builtin_sym_error] = TSNodeTypeNamed, [ts_builtin_sym_end] = TSNodeTypeHidden, - [anon_sym_LBRACE] = TSNodeTypeConcrete, - [anon_sym_COLON] = TSNodeTypeConcrete, - [anon_sym_COMMA] = TSNodeTypeConcrete, - [anon_sym_RBRACE] = TSNodeTypeConcrete, - [anon_sym_LBRACK] = TSNodeTypeConcrete, - [anon_sym_RBRACK] = TSNodeTypeConcrete, - [sym_string] = TSNodeTypeNormal, - [sym_number] = TSNodeTypeNormal, - [sym_null] = TSNodeTypeNormal, - [sym_true] = TSNodeTypeNormal, - [sym_false] = TSNodeTypeNormal, + [anon_sym_LBRACE] = TSNodeTypeAnonymous, + [anon_sym_COLON] = TSNodeTypeAnonymous, + [anon_sym_COMMA] = TSNodeTypeAnonymous, + [anon_sym_RBRACE] = TSNodeTypeAnonymous, + [anon_sym_LBRACK] = TSNodeTypeAnonymous, + [anon_sym_RBRACK] = TSNodeTypeAnonymous, + [sym_string] = TSNodeTypeNamed, + [sym_number] = TSNodeTypeNamed, + [sym_null] = TSNodeTypeNamed, + [sym_true] = TSNodeTypeNamed, + [sym_false] = TSNodeTypeNamed, }; static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) { diff --git a/spec/runtime/node_spec.cc b/spec/runtime/node_spec.cc index aed37058..cf58c761 100644 --- a/spec/runtime/node_spec.cc +++ b/spec/runtime/node_spec.cc @@ -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(3)); + it("returns the named child node at the given index", [&]() { + AssertThat(ts_node_named_child_count(array_node), Equals(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(15)); AssertThat(ts_node_size(child3).bytes, Equals(11)); - AssertThat(ts_node_child_count(child3), Equals(2)); + AssertThat(ts_node_named_child_count(child3), Equals(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(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(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(2)); AssertThat(ts_node_size(child1).bytes, Equals(1)); @@ -105,13 +105,13 @@ describe("Node", []() { AssertThat(ts_node_pos(child7).bytes, Equals(26)); AssertThat(ts_node_size(child7).bytes, Equals(1)); - AssertThat(ts_node_concrete_child_count(child6), Equals(5)) + AssertThat(ts_node_child_count(child6), Equals(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(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(nullptr)); - AssertThat(ts_node_prev_concrete_sibling(bracket_node1).data, Equals(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(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(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(nullptr)); - AssertThat(ts_node_prev_concrete_sibling(brace_node1).data, Equals(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(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(nullptr)); - AssertThat(ts_node_prev_sibling(array_node).data, Equals(nullptr)); - AssertThat(ts_node_next_sibling(array_node).data, Equals(nullptr)); - AssertThat(ts_node_prev_sibling(array_node).data, Equals(nullptr)); + AssertThat(ts_node_next_named_sibling(array_node).data, Equals(nullptr)); + AssertThat(ts_node_prev_named_sibling(array_node).data, Equals(nullptr)); + AssertThat(ts_node_next_named_sibling(array_node).data, Equals(nullptr)); + AssertThat(ts_node_prev_named_sibling(array_node).data, Equals(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(nullptr)); - AssertThat(ts_node_prev_sibling(array_node).data, Equals(nullptr)); - AssertThat(ts_node_next_sibling(array_node).data, Equals(nullptr)); - AssertThat(ts_node_prev_sibling(array_node).data, Equals(nullptr)); + AssertThat(ts_node_next_named_sibling(array_node).data, Equals(nullptr)); + AssertThat(ts_node_prev_named_sibling(array_node).data, Equals(nullptr)); + AssertThat(ts_node_next_named_sibling(array_node).data, Equals(nullptr)); + AssertThat(ts_node_prev_named_sibling(array_node).data, Equals(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(3)); AssertThat(ts_node_pos(leaf).bytes, Equals(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(3)); AssertThat(ts_node_pos(leaf).bytes, Equals(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(3)); AssertThat(ts_node_pos(leaf).bytes, Equals(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(3)); AssertThat(ts_node_pos(leaf).bytes, Equals(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(11)); AssertThat(ts_node_pos(node).bytes, Equals(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(25)); AssertThat(ts_node_pos(node).bytes, Equals(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(19)); AssertThat(ts_node_size(node1).bytes, Equals(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(15)); AssertThat(ts_node_size(node2).bytes, Equals(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(8)); - AssertThat(ts_node_size(node).bytes, Equals(5)); - }); - }); }); END_TEST diff --git a/spec/runtime/parse_stack_spec.cc b/spec/runtime/parse_stack_spec.cc index 2ed527ec..be6f9626 100644 --- a/spec/runtime/parse_stack_spec.cc +++ b/spec/runtime/parse_stack_spec.cc @@ -43,7 +43,7 @@ describe("ParseStack", [&]() { TSLength len = ts_length_make(2, 2); for (size_t i = 0; i < tree_count; i++) - trees[i] = ts_tree_make_leaf(ts_builtin_sym_start + i, len, len, TSNodeTypeNormal); + trees[i] = ts_tree_make_leaf(ts_builtin_sym_start + i, len, len, TSNodeTypeNamed); }); after_each([&]() { diff --git a/spec/runtime/parser_spec.cc b/spec/runtime/parser_spec.cc index a190acc3..f015545a 100644 --- a/spec/runtime/parser_spec.cc +++ b/spec/runtime/parser_spec.cc @@ -78,8 +78,8 @@ describe("Parser", [&]() { AssertThat(ts_node_string(root, doc), Equals( "(array (number) (ERROR (UNEXPECTED '@')) (true))")); - TSNode error = ts_node_child(root, 1); - TSNode last = ts_node_child(root, 2); + TSNode error = ts_node_named_child(root, 1); + TSNode last = ts_node_named_child(root, 2); AssertThat(ts_node_name(error, doc), Equals("ERROR")); AssertThat(ts_node_pos(error).bytes, Equals(strlen(" [123, "))) @@ -97,8 +97,10 @@ describe("Parser", [&]() { AssertThat(ts_node_string(root, doc), Equals( "(array (number) (ERROR (UNEXPECTED 'a')) (true))")); - TSNode error = ts_node_child(root, 1); - TSNode last = ts_node_child(root, 2); + TSNode error = ts_node_named_child(root, 1); + TSNode last = ts_node_named_child(root, 2); + + AssertThat(ts_node_symbol(error), Equals(ts_builtin_sym_error)); AssertThat(ts_node_name(error, doc), Equals("ERROR")); AssertThat(ts_node_pos(error).bytes, Equals(strlen(" [123, "))) @@ -116,8 +118,8 @@ describe("Parser", [&]() { AssertThat(ts_node_string(root, doc), Equals( "(array (number) (ERROR (true) (UNEXPECTED 'f') (false)) (true))")); - TSNode error = ts_node_child(root, 1); - TSNode last = ts_node_child(root, 2); + TSNode error = ts_node_named_child(root, 1); + TSNode last = ts_node_named_child(root, 2); AssertThat(ts_node_name(error, doc), Equals("ERROR")); AssertThat(ts_node_pos(error).bytes, Equals(strlen(" [123, "))); @@ -135,8 +137,8 @@ describe("Parser", [&]() { AssertThat(ts_node_string(root, doc), Equals( "(array (number) (ERROR (UNEXPECTED ',')) (true))")); - TSNode error = ts_node_child(root, 1); - TSNode last = ts_node_child(root, 2); + TSNode error = ts_node_named_child(root, 1); + TSNode last = ts_node_named_child(root, 2); AssertThat(ts_node_name(error, doc), Equals("ERROR")); AssertThat(ts_node_pos(error).bytes, Equals(strlen(" [123, "))); @@ -290,7 +292,7 @@ describe("Parser", [&]() { AssertThat(ts_node_string(root, doc), Equals( "(program (product (variable) (number)))")); - TSNode node = ts_node_find_for_pos(root, 1); + TSNode node = ts_node_named_descendent_for_range(root, 1, 1); AssertThat(ts_node_name(node, doc), Equals("variable")); AssertThat(ts_node_size(node).bytes, Equals(strlen("abXYZc"))); }); @@ -310,7 +312,7 @@ describe("Parser", [&]() { AssertThat(ts_node_string(root, doc), Equals( "(program (product (variable) (number)))")); - TSNode node = ts_node_find_for_pos(root, 1); + TSNode node = ts_node_named_descendent_for_range(root, 1, 1); AssertThat(ts_node_name(node, doc), Equals("variable")); AssertThat(ts_node_size(node).bytes, Equals(strlen("abcXYZ"))); }); @@ -406,7 +408,7 @@ describe("Parser", [&]() { AssertThat(ts_node_string(root, doc), Equals( "(program (variable) (comment))")); - TSNode comment = ts_node_child(root, 1); + TSNode comment = ts_node_named_child(root, 1); AssertThat(ts_node_size(comment).bytes, Equals(strlen("# this is a comment"))); }); diff --git a/spec/runtime/stack_spec.cc b/spec/runtime/stack_spec.cc index 0b8380fc..1b35423a 100644 --- a/spec/runtime/stack_spec.cc +++ b/spec/runtime/stack_spec.cc @@ -32,7 +32,7 @@ describe("stacks", [&]() { sym1, ts_length_make(0, 0), ts_length_make(1, 1), - TSNodeTypeNormal); + TSNodeTypeNamed); ts_stack_push(&stack, 5, node1); }); diff --git a/spec/runtime/tree_spec.cc b/spec/runtime/tree_spec.cc index 8c8ec79c..c1133f57 100644 --- a/spec/runtime/tree_spec.cc +++ b/spec/runtime/tree_spec.cc @@ -26,19 +26,19 @@ describe("Tree", []() { cat, ts_length_make(5, 4), ts_length_make(2, 1), - TSNodeTypeNormal); + TSNodeTypeNamed); tree2 = ts_tree_make_leaf( cat, ts_length_make(3, 3), ts_length_make(1, 1), - TSNodeTypeNormal); + TSNodeTypeNamed); parent1 = ts_tree_make_node( dog, 2, tree_array({ tree1, tree2, }), - TSNodeTypeNormal); + TSNodeTypeNamed); }); after_each([&]() { @@ -88,7 +88,7 @@ describe("Tree", []() { parent = ts_tree_make_node(pig, 2, tree_array({ tree1, tree2, - }), TSNodeTypeNormal); + }), TSNodeTypeNamed); }); after_each([&]() { @@ -109,7 +109,7 @@ describe("Tree", []() { parent = ts_tree_make_node(pig, 2, tree_array({ tree1, tree2, - }), TSNodeTypeNormal); + }), TSNodeTypeNamed); }); after_each([&]() { @@ -130,7 +130,7 @@ describe("Tree", []() { parent = ts_tree_make_node(pig, 2, tree_array({ tree1, tree2, - }), TSNodeTypeNormal); + }), TSNodeTypeNamed); }); after_each([&]() { @@ -150,7 +150,7 @@ describe("Tree", []() { cat, ts_length_make(5, 4), ts_length_make(2, 1), - TSNodeTypeNormal); + TSNodeTypeNamed); AssertThat(ts_tree_eq(tree1, tree1_copy), IsTrue()); @@ -158,13 +158,13 @@ describe("Tree", []() { cat, ts_length_make(3, 3), ts_length_make(1, 1), - TSNodeTypeNormal); + TSNodeTypeNamed); AssertThat(ts_tree_eq(tree2, tree2_copy), IsTrue()); TSTree *parent2 = ts_tree_make_node(dog, 2, tree_array({ tree1_copy, tree2_copy, - }), TSNodeTypeNormal); + }), TSNodeTypeNamed); AssertThat(ts_tree_eq(parent1, parent2), IsTrue()); @@ -178,7 +178,7 @@ describe("Tree", []() { tree1->symbol + 1, tree1->size, tree1->padding, - TSNodeTypeNormal); + TSNodeTypeNamed); AssertThat(ts_tree_eq(tree1, different_tree), IsFalse()); ts_tree_release(different_tree); @@ -189,11 +189,11 @@ describe("Tree", []() { tree1->symbol + 1, tree1->size, tree1->padding, - TSNodeTypeNormal); + TSNodeTypeNamed); TSTree *different_parent = ts_tree_make_node(dog, 2, tree_array({ different_tree, different_tree, - }), TSNodeTypeNormal); + }), TSNodeTypeNamed); AssertThat(ts_tree_eq(different_parent, parent1), IsFalse()); AssertThat(ts_tree_eq(parent1, different_parent), IsFalse()); diff --git a/src/compiler/generate_code/c_code.cc b/src/compiler/generate_code/c_code.cc index 2d86222c..5c7a7690 100644 --- a/src/compiler/generate_code/c_code.cc +++ b/src/compiler/generate_code/c_code.cc @@ -151,10 +151,10 @@ class CCodeGenerator { switch (entry_for_symbol(symbol).type) { case RuleEntryTypeNamed: - add("TSNodeTypeNormal,"); + add("TSNodeTypeNamed,"); break; case RuleEntryTypeAnonymous: - add("TSNodeTypeConcrete,"); + add("TSNodeTypeAnonymous,"); break; case RuleEntryTypeHidden: case RuleEntryTypeAuxiliary: diff --git a/src/runtime/document.c b/src/runtime/document.c index 618f19bf..ecbaf3c2 100644 --- a/src/runtime/document.c +++ b/src/runtime/document.c @@ -65,6 +65,6 @@ void ts_document_set_input_string(TSDocument *document, const char *text) { TSNode ts_document_root_node(const TSDocument *document) { TSNode result = ts_node_make(document->tree, ts_length_zero()); while (result.data && !ts_tree_is_visible(result.data)) - result = ts_node_child(result, 0); + result = ts_node_named_child(result, 0); return result; } diff --git a/src/runtime/node.c b/src/runtime/node.c index fd81fc70..e3f64787 100644 --- a/src/runtime/node.c +++ b/src/runtime/node.c @@ -8,6 +8,14 @@ TSNode ts_node_make(const TSTree *tree, TSLength offset) { return (TSNode){.data = tree, .offset = offset }; } +/* + * Private + */ + +static inline TSNode ts_node__null() { + return ts_node_make(NULL, ts_length_zero()); +} + static inline const TSTree *ts_node__tree(TSNode this) { return this.data; } @@ -16,54 +24,8 @@ static inline TSLength ts_node__offset(TSNode this) { return this.offset; } -static inline TSNode ts_node__null() { - return ts_node_make(NULL, ts_length_zero()); -} - -TSLength ts_node_pos(TSNode this) { - return ts_length_add(ts_node__offset(this), ts_node__tree(this)->padding); -} - -TSLength ts_node_size(TSNode this) { - return ts_node__tree(this)->size; -} - -bool ts_node_eq(TSNode this, TSNode other) { - return ts_tree_eq(ts_node__tree(this), ts_node__tree(other)) && - ts_length_eq(ts_node__offset(this), ts_node__offset(other)); -} - -const char *ts_node_name(TSNode this, const TSDocument *document) { - return document->parser.language->symbol_names[ts_node__tree(this)->symbol]; -} - -const char *ts_node_string(TSNode this, const TSDocument *document) { - return ts_tree_string(ts_node__tree(this), - document->parser.language->symbol_names); -} - -TSNode ts_node_parent(TSNode this) { - const TSTree *tree = ts_node__tree(this); - TSLength position = ts_node__offset(this); - - do { - TSTree *parent = tree->context.parent; - if (!parent) - return ts_node__null(); - - for (size_t i = 0; i < tree->context.index; i++) { - TSTree *child = parent->children[i]; - position = ts_length_sub(position, ts_tree_total_size(child)); - } - - tree = parent; - } while (!ts_tree_is_visible(tree)); - - return ts_node_make(tree, position); -} - -static TSNode ts_node__child_with_type(TSNode this, size_t child_index, - TSNodeType type) { +static inline TSNode ts_node__child(TSNode this, size_t child_index, + TSNodeType type) { const TSTree *tree = ts_node__tree(this); TSLength position = ts_node__offset(this); @@ -80,7 +42,7 @@ static TSNode ts_node__child_with_type(TSNode this, size_t child_index, index++; } else { size_t grandchild_index = child_index - index; - size_t grandchild_count = (type == TSNodeTypeNormal) + size_t grandchild_count = (type == TSNodeTypeNamed) ? child->named_child_count : child->visible_child_count; if (grandchild_index < grandchild_count) { @@ -98,7 +60,7 @@ static TSNode ts_node__child_with_type(TSNode this, size_t child_index, return ts_node__null(); } -static TSNode ts_node__prev_sibling_with_type(TSNode this, TSNodeType type) { +static inline TSNode ts_node__prev_sibling(TSNode this, TSNodeType type) { const TSTree *tree = ts_node__tree(this); TSLength position = ts_node__offset(this); @@ -114,19 +76,19 @@ static TSNode ts_node__prev_sibling_with_type(TSNode this, TSNodeType type) { TSLength child_position = ts_length_add(position, child->context.offset); if (child->options.type >= type) return ts_node_make(child, child_position); - size_t grandchild_count = (type == TSNodeTypeNormal) + size_t grandchild_count = (type == TSNodeTypeNamed) ? child->named_child_count : child->visible_child_count; if (grandchild_count > 0) - return ts_node__child_with_type(ts_node_make(child, child_position), - grandchild_count - 1, type); + return ts_node__child(ts_node_make(child, child_position), + grandchild_count - 1, type); } } while (!ts_tree_is_visible(tree)); return ts_node__null(); } -static TSNode ts_node__next_sibling_with_type(TSNode this, TSNodeType type) { +static inline TSNode ts_node__next_sibling(TSNode this, TSNodeType type) { const TSTree *tree = ts_node__tree(this); TSLength position = ts_node__offset(this); @@ -142,19 +104,19 @@ static TSNode ts_node__next_sibling_with_type(TSNode this, TSNodeType type) { TSLength child_position = ts_length_add(position, child->context.offset); if (child->options.type >= type) return ts_node_make(child, child_position); - size_t grandchild_count = (type == TSNodeTypeNormal) + size_t grandchild_count = (type == TSNodeTypeNamed) ? child->named_child_count : child->visible_child_count; if (grandchild_count > 0) - return ts_node__child_with_type(ts_node_make(child, child_position), 0, - type); + return ts_node__child(ts_node_make(child, child_position), 0, type); } } while (!ts_tree_is_visible(tree)); return ts_node__null(); } -static TSNode ts_node__find_for_range_with_type(TSNode this, size_t min, size_t max, TSNodeType type) { +static inline TSNode ts_node__descendent_for_range(TSNode this, size_t min, + size_t max, TSNodeType type) { const TSTree *tree = ts_node__tree(this), *last_visible_tree = tree; TSLength position = ts_node__offset(this), last_visible_position = position; @@ -182,50 +144,96 @@ static TSNode ts_node__find_for_range_with_type(TSNode this, size_t min, size_t return ts_node_make(last_visible_tree, last_visible_position); } -TSNode ts_node_next_sibling(TSNode this) { - return ts_node__next_sibling_with_type(this, TSNodeTypeNormal); +/* + * Public + */ + +TSLength ts_node_pos(TSNode this) { + return ts_length_add(ts_node__offset(this), ts_node__tree(this)->padding); } -TSNode ts_node_prev_sibling(TSNode this) { - return ts_node__prev_sibling_with_type(this, TSNodeTypeNormal); +TSLength ts_node_size(TSNode this) { + return ts_node__tree(this)->size; } -TSNode ts_node_next_concrete_sibling(TSNode this) { - return ts_node__next_sibling_with_type(this, TSNodeTypeConcrete); +TSSymbol ts_node_symbol(TSNode this) { + return ts_node__tree(this)->symbol; } -TSNode ts_node_prev_concrete_sibling(TSNode this) { - return ts_node__prev_sibling_with_type(this, TSNodeTypeConcrete); +const char *ts_node_name(TSNode this, const TSDocument *document) { + return document->parser.language->symbol_names[ts_node__tree(this)->symbol]; } -size_t ts_node_concrete_child_count(TSNode this) { - return ts_node__tree(this)->visible_child_count; +const char *ts_node_string(TSNode this, const TSDocument *document) { + return ts_tree_string(ts_node__tree(this), + document->parser.language->symbol_names); } -bool ts_node_is_concrete(TSNode this) { - return ts_node__tree(this)->options.type == TSNodeTypeConcrete; +bool ts_node_eq(TSNode this, TSNode other) { + return ts_tree_eq(ts_node__tree(this), ts_node__tree(other)) && + ts_length_eq(ts_node__offset(this), ts_node__offset(other)); } -size_t ts_node_child_count(TSNode this) { - return ts_node__tree(this)->named_child_count; +bool ts_node_is_named(TSNode this) { + return ts_node__tree(this)->options.type == TSNodeTypeNamed; +} + +TSNode ts_node_parent(TSNode this) { + const TSTree *tree = ts_node__tree(this); + TSLength position = ts_node__offset(this); + + do { + TSTree *parent = tree->context.parent; + if (!parent) + return ts_node__null(); + + for (size_t i = 0; i < tree->context.index; i++) { + TSTree *child = parent->children[i]; + position = ts_length_sub(position, ts_tree_total_size(child)); + } + + tree = parent; + } while (!ts_tree_is_visible(tree)); + + return ts_node_make(tree, position); } TSNode ts_node_child(TSNode this, size_t child_index) { - return ts_node__child_with_type(this, child_index, TSNodeTypeNormal); + return ts_node__child(this, child_index, TSNodeTypeAnonymous); } -TSNode ts_node_concrete_child(TSNode this, size_t child_index) { - return ts_node__child_with_type(this, child_index, TSNodeTypeConcrete); +TSNode ts_node_named_child(TSNode this, size_t child_index) { + return ts_node__child(this, child_index, TSNodeTypeNamed); } -TSNode ts_node_find_for_range(TSNode this, size_t min, size_t max) { - return ts_node__find_for_range_with_type(this, min, max, TSNodeTypeNormal); +size_t ts_node_child_count(TSNode this) { + return ts_node__tree(this)->visible_child_count; } -TSNode ts_node_find_concrete_for_range(TSNode this, size_t min, size_t max) { - return ts_node__find_for_range_with_type(this, min, max, TSNodeTypeConcrete); +size_t ts_node_named_child_count(TSNode this) { + return ts_node__tree(this)->named_child_count; } -TSNode ts_node_find_for_pos(TSNode this, size_t position) { - return ts_node_find_for_range(this, position, position); +TSNode ts_node_next_sibling(TSNode this) { + return ts_node__next_sibling(this, TSNodeTypeAnonymous); +} + +TSNode ts_node_next_named_sibling(TSNode this) { + return ts_node__next_sibling(this, TSNodeTypeNamed); +} + +TSNode ts_node_prev_sibling(TSNode this) { + return ts_node__prev_sibling(this, TSNodeTypeAnonymous); +} + +TSNode ts_node_prev_named_sibling(TSNode this) { + return ts_node__prev_sibling(this, TSNodeTypeNamed); +} + +TSNode ts_node_descendent_for_range(TSNode this, size_t min, size_t max) { + return ts_node__descendent_for_range(this, min, max, TSNodeTypeAnonymous); +} + +TSNode ts_node_named_descendent_for_range(TSNode this, size_t min, size_t max) { + return ts_node__descendent_for_range(this, min, max, TSNodeTypeNamed); } diff --git a/src/runtime/tree.c b/src/runtime/tree.c index 62e51d89..7e82a67b 100644 --- a/src/runtime/tree.c +++ b/src/runtime/tree.c @@ -31,7 +31,7 @@ TSTree *ts_tree_make_leaf(TSSymbol sym, TSLength size, TSLength padding, TSTree *ts_tree_make_error(TSLength size, TSLength padding, char lookahead_char) { TSTree *result = - ts_tree_make_leaf(ts_builtin_sym_error, size, padding, TSNodeTypeNormal); + ts_tree_make_leaf(ts_builtin_sym_error, size, padding, TSNodeTypeNamed); result->lookahead_char = lookahead_char; return result; } @@ -56,11 +56,11 @@ static void ts_tree__set_children(TSTree *this, TSTree **children, } switch (child->options.type) { - case TSNodeTypeNormal: + case TSNodeTypeNamed: this->visible_child_count++; this->named_child_count++; break; - case TSNodeTypeConcrete: + case TSNodeTypeAnonymous: this->visible_child_count++; break; case TSNodeTypeHidden: @@ -149,7 +149,7 @@ static size_t ts_tree__write_to_string(const TSTree *tree, char *cursor = string; char **writer = (limit > 0) ? &cursor : &string; - int visible = tree->options.type == TSNodeTypeNormal || is_root; + int visible = tree->options.type == TSNodeTypeNamed || is_root; if (visible && !is_root) cursor += snprintf(*writer, limit, " ");