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

4
include/tree_sitter/parser.h
View file

@ -18,8 +18,8 @@ typedef unsigned short TSStateId;
typedef enum {
TSNodeTypeHidden,
TSNodeTypeConcrete,
TSNodeTypeNormal,
TSNodeTypeAnonymous,
TSNodeTypeNamed,
} TSNodeType;
typedef struct TSLexer {

28
include/tree_sitter/runtime.h
View file

@ -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 *);

36
spec/fixtures/parsers/arithmetic.c vendored
View file

@ -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) {

102
spec/fixtures/parsers/c.c vendored
View file

@ -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) {

130
spec/fixtures/parsers/golang.c vendored
View file

@ -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) {

190
spec/fixtures/parsers/javascript.c vendored
View file

@ -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,
};

28
spec/fixtures/parsers/json.c vendored
View file

@ -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) {

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

2
spec/runtime/parse_stack_spec.cc
View file

@ -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([&]() {

24
spec/runtime/parser_spec.cc
View file

@ -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")));
});

2
spec/runtime/stack_spec.cc
View file

@ -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);
});

24
spec/runtime/tree_spec.cc
View file

@ -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());

4
src/compiler/generate_code/c_code.cc
View file

@ -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:

2
src/runtime/document.c
View file

@ -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;
}

170
src/runtime/node.c
View file

@ -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);
}

8
src/runtime/tree.c
View file

@ -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, " ");