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

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