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

Don't automatically hide singleton nodes

Browse source
This commit is contained in:
Max Brunsfeld 2015-09-02 16:36:29 -07:00
parent acf9280eda
commit 53926c467e
21 changed files with 4284 additions and 4221 deletions
Download patch file Download diff file Expand all files Collapse all files

15
spec/fixtures/grammars/arithmetic.cc vendored
View file

@ -7,7 +7,8 @@ using tree_sitter::Grammar;
using namespace tree_sitter::rules;
extern const Grammar arithmetic = Grammar({
{ "expression", choice({
{ "program", sym("_expression") },
{ "_expression", choice({
sym("sum"),
sym("difference"),
sym("product"),
@ -17,12 +18,12 @@ extern const Grammar arithmetic = Grammar({
sym("number"),
sym("variable") }) },
{ "sum", infix_op("+", "expression", 1) },
{ "difference", infix_op("-", "expression", 1) },
{ "product", infix_op("*", "expression", 2) },
{ "quotient", infix_op("/", "expression", 2) },
{ "exponent", infix_op("^", "expression", 3) },
{ "group", in_parens(err(sym("expression"))) },
{ "sum", infix_op("+", "_expression", 1) },
{ "difference", infix_op("-", "_expression", 1) },
{ "product", infix_op("*", "_expression", 2) },
{ "quotient", infix_op("/", "_expression", 2) },
{ "exponent", infix_op("^", "_expression", 3) },
{ "group", in_parens(err(sym("_expression"))) },
{ "number", pattern("\\d+") },

40
spec/fixtures/grammars/c.cc vendored
View file

@ -15,7 +15,7 @@ extern const Grammar c = Grammar({
{ "function_definition", seq({
optional(sym("declaration_specifiers")),
sym("type_specifier"),
sym("_type_specifier"),
sym("declarator"),
repeat(sym("declaration")),
sym("compound_statement") }) },
@ -31,15 +31,17 @@ extern const Grammar c = Grammar({
str("auto"),
str("register") }) },
{ "type_specifier", choice({
{ "_type_specifier", choice({
sym("struct_specifier"),
seq({
repeat(choice({
str("signed"),
str("unsigned"),
str("long"),
str("short") })),
sym("identifier") }) }) },
sym("type_name") }) },
{ "type_name", seq({
repeat(choice({
str("signed"),
str("unsigned"),
str("long"),
str("short") })),
sym("identifier") }) },
{ "struct_specifier", seq({
str("struct"),
@ -50,21 +52,21 @@ extern const Grammar c = Grammar({
str("}") }) }) },
{ "struct_declaration", seq({
sym("type_specifier"),
sym("_type_specifier"),
sym("declarator") }) },
{ "parameter_declaration", seq({
optional(sym("declaration_specifiers")),
sym("type_specifier"),
sym("_type_specifier"),
sym("declarator") }) },
{ "declaration", seq({
optional(sym("declaration_specifiers")),
sym("type_specifier"),
comma_sep1(sym("init_declarator")),
sym("_type_specifier"),
comma_sep1(sym("_init_declarator")),
str(";") }) },
{ "init_declarator", choice({
{ "_init_declarator", choice({
sym("declarator"),
seq({ sym("declarator"), str("="), sym("initializer") }) }) },
@ -99,21 +101,21 @@ extern const Grammar c = Grammar({
{ "declarator", seq({
repeat(sym("pointer")),
sym("direct_declarator") }) },
sym("_direct_declarator") }) },
{ "direct_declarator", choice({
{ "_direct_declarator", choice({
sym("identifier"),
seq({
str("("),
sym("declarator"),
str(")") }),
seq({
sym("direct_declarator"),
sym("_direct_declarator"),
str("["),
optional(sym("expression")),
str("]") }),
seq({
sym("direct_declarator"),
sym("_direct_declarator"),
str("("),
comma_sep(sym("parameter_declaration")),
str(")") }) }) },
@ -165,7 +167,7 @@ extern const Grammar c = Grammar({
sym("comment"),
pattern("[ \t\r\n]"),
}).expected_conflicts({
{ "type_specifier", "expression" },
{ "type_name", "expression" },
});
} // namespace tree_sitter_examples

83
spec/fixtures/grammars/golang.cc vendored
View file

@ -16,7 +16,7 @@ extern const Grammar golang = Grammar({
{ "program", seq({
sym("package_directive"),
repeat(sym("imports_block")),
repeat(sym("declaration")) }) },
repeat(sym("_declaration")) }) },
{ "package_directive", seq({
str("package"),
sym("package_name") }) },
@ -26,7 +26,7 @@ extern const Grammar golang = Grammar({
in_parens(err(repeat(sym("package_import")))),
sym("package_import") }) }) },
{ "package_import", sym("string") },
{ "declaration", choice({
{ "_declaration", choice({
sym("type_declaration"),
sym("var_declaration"),
sym("func_declaration") }) },
@ -35,23 +35,23 @@ extern const Grammar golang = Grammar({
{ "type_declaration", terminated(seq({
str("type"),
sym("type_name"),
sym("type_expression") })) },
sym("_type_expression") })) },
{ "var_declaration", terminated(seq({
str("var"),
sym("var_name"),
choice({
seq({
optional(sym("type_expression")),
optional(sym("_type_expression")),
str("="),
sym("expression") }),
sym("type_expression") }) })) },
sym("_expression") }),
sym("_type_expression") }) })) },
{ "func_declaration", terminated(seq({
str("func"),
sym("var_name"),
sym("_func_signature"),
sym("block_statement") })) },
{ "block_statement", in_braces(err(repeat(sym("statement")))) },
{ "type_expression", choice({
{ "block_statement", in_braces(err(repeat(sym("_statement")))) },
{ "_type_expression", choice({
sym("pointer_type"),
sym("slice_type"),
sym("map_type"),
@ -62,19 +62,19 @@ extern const Grammar golang = Grammar({
// Type expressions
{ "pointer_type", seq({
str("*"),
sym("type_expression") }) },
sym("_type_expression") }) },
{ "map_type", seq({
str("map"),
in_brackets(sym("type_expression")),
sym("type_expression") }) },
in_brackets(sym("_type_expression")),
sym("_type_expression") }) },
{ "slice_type", seq({
in_brackets(blank()),
sym("type_expression") }) },
sym("_type_expression") }) },
{ "struct_type", seq({
str("struct"),
in_braces(repeat(seq({
sym("var_name"),
sym("type_expression") }))) }) },
sym("_type_expression") }))) }) },
{ "interface_type", seq({
str("interface"),
in_braces(repeat(seq({
@ -82,42 +82,41 @@ extern const Grammar golang = Grammar({
sym("_func_signature") }))) }) },
// Statements
{ "statement", choice({
{ "_statement", choice({
sym("expression_statement"),
sym("return_statement"),
sym("declaration_statement"),
sym("var_declaration"),
sym("short_var_declaration"),
sym("range_statement"),
sym("if_statement") }) },
{ "return_statement", terminated(seq({
str("return"),
comma_sep(sym("expression")) })) },
{ "declaration_statement", choice({
sym("var_declaration"),
terminated(seq({
comma_sep(sym("var_name")),
str(":="),
sym("expression") })) }) },
comma_sep(sym("_expression")) })) },
{ "short_var_declaration", terminated(seq({
comma_sep(sym("var_name")),
str(":="),
sym("_expression") })) },
{ "range_statement", seq({
str("for"),
sym("var_name"),
optional(seq({ str(","), sym("var_name") })),
str(":="),
str("range"),
sym("expression"),
sym("_expression"),
sym("block_statement") }) },
{ "if_statement", seq({
str("if"),
sym("expression"),
sym("_expression"),
sym("block_statement"),
optional(seq({
str("else"),
choice({
sym("if_statement"),
sym("block_statement") }) })) }) },
{ "expression_statement", terminated(sym("expression")) },
{ "expression_statement", terminated(sym("_expression")) },
// Value expressions
{ "expression", choice({
{ "_expression", choice({
sym("call_expression"),
sym("selector_expression"),
sym("math_op"),
@ -126,30 +125,30 @@ extern const Grammar golang = Grammar({
sym("string"),
sym("var_name") }) },
{ "call_expression", seq({
sym("expression"),
in_parens(comma_sep(sym("expression"))) }) },
sym("_expression"),
in_parens(comma_sep(sym("_expression"))) }) },
{ "selector_expression", seq({
sym("expression"),
sym("_expression"),
str("."),
sym("var_name") }) },
{ "math_op", choice({
infix_op("*", "expression", 2),
infix_op("/", "expression", 2),
infix_op("+", "expression", 1),
infix_op("-", "expression", 1) }) },
infix_op("*", "_expression", 2),
infix_op("/", "_expression", 2),
infix_op("+", "_expression", 1),
infix_op("-", "_expression", 1) }) },
{ "bool_op", choice({
infix_op("||", "expression", 1),
infix_op("&&", "expression", 2),
infix_op("==", "expression", 3),
infix_op("<=", "expression", 3),
infix_op("<", "expression", 3),
infix_op(">=", "expression", 3),
infix_op(">", "expression", 3),
prefix_op("!", "expression", 4) }) },
infix_op("||", "_expression", 1),
infix_op("&&", "_expression", 2),
infix_op("==", "_expression", 3),
infix_op("<=", "_expression", 3),
infix_op("<", "_expression", 3),
infix_op(">=", "_expression", 3),
infix_op(">", "_expression", 3),
prefix_op("!", "_expression", 4) }) },
{ "_func_signature", prec(10, seq({
in_parens(comma_sep(seq({
comma_sep1(sym("var_name")),
sym("type_expression") }))),
sym("_type_expression") }))),
choice({
in_parens(choice({
comma_sep1(seq({ sym("var_name"), sym("type_name") })),

6
spec/fixtures/grammars/json.cc vendored
View file

@ -7,7 +7,7 @@ using tree_sitter::Grammar;
using namespace tree_sitter::rules;
extern const Grammar json = Grammar({
{ "value", choice({
{ "_value", choice({
sym("object"),
sym("array"),
sym("string"),
@ -18,8 +18,8 @@ extern const Grammar json = Grammar({
{ "object", in_braces(comma_sep(err(seq({
sym("string"),
str(":"),
sym("value") })))) },
{ "array", in_brackets(comma_sep(err(sym("value")))) },
sym("_value") })))) },
{ "array", in_brackets(comma_sep(err(sym("_value")))) },
{ "string", pattern("\"([^\"]|\\\\\")*\"") },
{ "number", pattern("\\d+(\\.\\d+)?") },
{ "null", str("null") },

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

@ -1,10 +1,11 @@
#include "tree_sitter/parser.h"
#define STATE_COUNT 32
#define SYMBOL_COUNT 19
#define STATE_COUNT 33
#define SYMBOL_COUNT 20
enum {
sym_expression = ts_builtin_sym_start,
sym_program = ts_builtin_sym_start,
sym__expression,
sym_sum,
sym_difference,
sym_product,
@ -24,7 +25,8 @@ enum {
};
static const char *ts_symbol_names[] = {
[sym_expression] = "expression",
[sym_program] = "program",
[sym__expression] = "_expression",
[sym_sum] = "sum",
[sym_difference] = "difference",
[sym_product] = "product",
@ -46,6 +48,7 @@ static const char *ts_symbol_names[] = {
};
static const int ts_hidden_symbol_flags[SYMBOL_COUNT] = {
[sym__expression] = 1,
[aux_sym_STR_PLUS] = 1,
[aux_sym_STR_DASH] = 1,
[aux_sym_STR_STAR] = 1,
@ -110,69 +113,67 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
ADVANCE(7);
if (lookahead == '#')
ADVANCE(2);
if (lookahead == '*')
ADVANCE(9);
if (lookahead == '+')
ADVANCE(10);
if (lookahead == '-')
ADVANCE(11);
if (lookahead == '/')
ADVANCE(12);
if (lookahead == '^')
ADVANCE(13);
LEX_ERROR();
case 8:
ACCEPT_TOKEN(ts_builtin_sym_end);
case 9:
ACCEPT_TOKEN(aux_sym_STR_STAR);
case 10:
ACCEPT_TOKEN(aux_sym_STR_PLUS);
case 11:
ACCEPT_TOKEN(aux_sym_STR_DASH);
case 12:
ACCEPT_TOKEN(aux_sym_STR_SLASH);
case 13:
ACCEPT_TOKEN(aux_sym_STR_CARET);
case 14:
START_TOKEN();
if ((lookahead == '\t') ||
(lookahead == '\n') ||
(lookahead == '\r') ||
(lookahead == ' '))
ADVANCE(14);
if (lookahead == '#')
ADVANCE(2);
if (lookahead == ')')
ADVANCE(15);
if (lookahead == '*')
ADVANCE(9);
if (lookahead == '+')
ADVANCE(10);
if (lookahead == '-')
ADVANCE(11);
if (lookahead == '/')
ADVANCE(12);
if (lookahead == '^')
ADVANCE(13);
LEX_ERROR();
case 15:
ACCEPT_TOKEN(aux_sym_STR_RPAREN);
case 16:
START_TOKEN();
if ((lookahead == '\t') ||
(lookahead == '\n') ||
(lookahead == '\r') ||
(lookahead == ' '))
ADVANCE(16);
if (lookahead == '#')
ADVANCE(2);
if (lookahead == ')')
ADVANCE(15);
LEX_ERROR();
case 17:
START_TOKEN();
if (lookahead == 0)
ADVANCE(8);
if ((lookahead == '\t') ||
(lookahead == '\n') ||
(lookahead == '\r') ||
(lookahead == ' '))
ADVANCE(9);
if (lookahead == '#')
ADVANCE(2);
if (lookahead == '*')
ADVANCE(10);
if (lookahead == '+')
ADVANCE(11);
if (lookahead == '-')
ADVANCE(12);
if (lookahead == '/')
ADVANCE(13);
if (lookahead == '^')
ADVANCE(14);
LEX_ERROR();
case 10:
ACCEPT_TOKEN(aux_sym_STR_STAR);
case 11:
ACCEPT_TOKEN(aux_sym_STR_PLUS);
case 12:
ACCEPT_TOKEN(aux_sym_STR_DASH);
case 13:
ACCEPT_TOKEN(aux_sym_STR_SLASH);
case 14:
ACCEPT_TOKEN(aux_sym_STR_CARET);
case 15:
START_TOKEN();
if ((lookahead == '\t') ||
(lookahead == '\n') ||
(lookahead == '\r') ||
(lookahead == ' '))
ADVANCE(15);
if (lookahead == '#')
ADVANCE(2);
if (lookahead == ')')
ADVANCE(16);
if (lookahead == '*')
ADVANCE(10);
if (lookahead == '+')
ADVANCE(11);
if (lookahead == '-')
ADVANCE(12);
if (lookahead == '/')
ADVANCE(13);
if (lookahead == '^')
ADVANCE(14);
LEX_ERROR();
case 16:
ACCEPT_TOKEN(aux_sym_STR_RPAREN);
case 17:
START_TOKEN();
if ((lookahead == '\t') ||
(lookahead == '\n') ||
(lookahead == '\r') ||
@ -180,18 +181,32 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
ADVANCE(17);
if (lookahead == '#')
ADVANCE(2);
if (lookahead == ')')
ADVANCE(16);
LEX_ERROR();
case 18:
START_TOKEN();
if (lookahead == 0)
ADVANCE(8);
if ((lookahead == '\t') ||
(lookahead == '\n') ||
(lookahead == '\r') ||
(lookahead == ' '))
ADVANCE(18);
if (lookahead == '#')
ADVANCE(2);
if (lookahead == '(')
ADVANCE(3);
if (lookahead == ')')
ADVANCE(15);
ADVANCE(16);
if (lookahead == '*')
ADVANCE(9);
if (lookahead == '+')
ADVANCE(10);
if (lookahead == '-')
if (lookahead == '+')
ADVANCE(11);
if (lookahead == '/')
if (lookahead == '-')
ADVANCE(12);
if (lookahead == '/')
ADVANCE(13);
if ('0' <= lookahead && lookahead <= '9')
ADVANCE(4);
if (('A' <= lookahead && lookahead <= 'Z') ||
@ -199,7 +214,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
(945 <= lookahead && lookahead <= 969))
ADVANCE(5);
if (lookahead == '^')
ADVANCE(13);
ADVANCE(14);
LEX_ERROR();
case ts_lex_state_error:
START_TOKEN();
@ -209,21 +224,21 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
(lookahead == '\n') ||
(lookahead == '\r') ||
(lookahead == ' '))
ADVANCE(17);
ADVANCE(18);
if (lookahead == '#')
ADVANCE(2);
if (lookahead == '(')
ADVANCE(3);
if (lookahead == ')')
ADVANCE(15);
ADVANCE(16);
if (lookahead == '*')
ADVANCE(9);
if (lookahead == '+')
ADVANCE(10);
if (lookahead == '-')
if (lookahead == '+')
ADVANCE(11);
if (lookahead == '/')
if (lookahead == '-')
ADVANCE(12);
if (lookahead == '/')
ADVANCE(13);
if ('0' <= lookahead && lookahead <= '9')
ADVANCE(4);
if (('A' <= lookahead && lookahead <= 'Z') ||
@ -231,7 +246,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
(945 <= lookahead && lookahead <= 969))
ADVANCE(5);
if (lookahead == '^')
ADVANCE(13);
ADVANCE(14);
LEX_ERROR();
default:
LEX_ERROR();
@ -241,36 +256,37 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
static TSStateId ts_lex_states[STATE_COUNT] = {
[0] = 1,
[1] = 7,
[2] = 7,
[3] = 1,
[4] = 14,
[5] = 14,
[6] = 16,
[7] = 1,
[8] = 14,
[9] = 16,
[10] = 14,
[11] = 1,
[2] = 9,
[3] = 9,
[4] = 1,
[5] = 15,
[6] = 15,
[7] = 17,
[8] = 1,
[9] = 15,
[10] = 17,
[11] = 15,
[12] = 1,
[13] = 1,
[14] = 1,
[15] = 1,
[16] = 14,
[17] = 14,
[18] = 14,
[19] = 14,
[20] = 14,
[21] = 7,
[22] = 1,
[16] = 1,
[17] = 15,
[18] = 15,
[19] = 15,
[20] = 15,
[21] = 15,
[22] = 9,
[23] = 1,
[24] = 1,
[25] = 1,
[26] = 1,
[27] = 7,
[28] = 7,
[29] = 7,
[30] = 7,
[31] = 7,
[27] = 1,
[28] = 9,
[29] = 9,
[30] = 9,
[31] = 9,
[32] = 9,
};
#pragma GCC diagnostic push
@ -278,100 +294,105 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[0] = {
[sym_expression] = ACTIONS(SHIFT(1)),
[sym_sum] = ACTIONS(SHIFT(2)),
[sym_difference] = ACTIONS(SHIFT(2)),
[sym_product] = ACTIONS(SHIFT(2)),
[sym_quotient] = ACTIONS(SHIFT(2)),
[sym_exponent] = ACTIONS(SHIFT(2)),
[sym_group] = ACTIONS(SHIFT(2)),
[sym_number] = ACTIONS(SHIFT(2)),
[sym_variable] = ACTIONS(SHIFT(2)),
[sym_program] = ACTIONS(SHIFT(1)),
[sym__expression] = ACTIONS(SHIFT(2)),
[sym_sum] = ACTIONS(SHIFT(3)),
[sym_difference] = ACTIONS(SHIFT(3)),
[sym_product] = ACTIONS(SHIFT(3)),
[sym_quotient] = ACTIONS(SHIFT(3)),
[sym_exponent] = ACTIONS(SHIFT(3)),
[sym_group] = ACTIONS(SHIFT(3)),
[sym_number] = ACTIONS(SHIFT(3)),
[sym_variable] = ACTIONS(SHIFT(3)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(3)),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(4)),
},
[1] = {
[ts_builtin_sym_end] = ACTIONS(ACCEPT_INPUT()),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(SHIFT(22)),
[aux_sym_STR_DASH] = ACTIONS(SHIFT(23)),
[aux_sym_STR_STAR] = ACTIONS(SHIFT(24)),
[aux_sym_STR_SLASH] = ACTIONS(SHIFT(25)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(26)),
},
[2] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_expression, 1)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_program, 1)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_expression, 1)),
[aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_expression, 1)),
[aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_expression, 1)),
[aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_expression, 1)),
[aux_sym_STR_CARET] = ACTIONS(REDUCE(sym_expression, 1)),
[aux_sym_STR_PLUS] = ACTIONS(SHIFT(23)),
[aux_sym_STR_DASH] = ACTIONS(SHIFT(24)),
[aux_sym_STR_STAR] = ACTIONS(SHIFT(25)),
[aux_sym_STR_SLASH] = ACTIONS(SHIFT(26)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(27)),
},
[3] = {
[sym_expression] = ACTIONS(SHIFT(4)),
[sym_sum] = ACTIONS(SHIFT(5)),
[sym_difference] = ACTIONS(SHIFT(5)),
[sym_product] = ACTIONS(SHIFT(5)),
[sym_quotient] = ACTIONS(SHIFT(5)),
[sym_exponent] = ACTIONS(SHIFT(5)),
[sym_group] = ACTIONS(SHIFT(5)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(6)),
[sym_number] = ACTIONS(SHIFT(5)),
[sym_variable] = ACTIONS(SHIFT(5)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym__expression, 1)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(7)),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
[aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
[aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
[aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
[aux_sym_STR_CARET] = ACTIONS(REDUCE(sym__expression, 1)),
},
[4] = {
[sym__expression] = ACTIONS(SHIFT(5)),
[sym_sum] = ACTIONS(SHIFT(6)),
[sym_difference] = ACTIONS(SHIFT(6)),
[sym_product] = ACTIONS(SHIFT(6)),
[sym_quotient] = ACTIONS(SHIFT(6)),
[sym_exponent] = ACTIONS(SHIFT(6)),
[sym_group] = ACTIONS(SHIFT(6)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(7)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_variable] = ACTIONS(SHIFT(6)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(SHIFT(11)),
[aux_sym_STR_DASH] = ACTIONS(SHIFT(12)),
[aux_sym_STR_STAR] = ACTIONS(SHIFT(13)),
[aux_sym_STR_SLASH] = ACTIONS(SHIFT(14)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(15)),
[aux_sym_STR_RPAREN] = ACTIONS(SHIFT(21)),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(8)),
},
[5] = {
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_expression, 1)),
[aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_expression, 1)),
[aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_expression, 1)),
[aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_expression, 1)),
[aux_sym_STR_CARET] = ACTIONS(REDUCE(sym_expression, 1)),
[aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_expression, 1)),
[aux_sym_STR_PLUS] = ACTIONS(SHIFT(12)),
[aux_sym_STR_DASH] = ACTIONS(SHIFT(13)),
[aux_sym_STR_STAR] = ACTIONS(SHIFT(14)),
[aux_sym_STR_SLASH] = ACTIONS(SHIFT(15)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(16)),
[aux_sym_STR_RPAREN] = ACTIONS(SHIFT(22)),
},
[6] = {
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_RPAREN] = ACTIONS(SHIFT(21)),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
[aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
[aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
[aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
[aux_sym_STR_CARET] = ACTIONS(REDUCE(sym__expression, 1)),
[aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
},
[7] = {
[sym_expression] = ACTIONS(SHIFT(8)),
[sym_sum] = ACTIONS(SHIFT(5)),
[sym_difference] = ACTIONS(SHIFT(5)),
[sym_product] = ACTIONS(SHIFT(5)),
[sym_quotient] = ACTIONS(SHIFT(5)),
[sym_exponent] = ACTIONS(SHIFT(5)),
[sym_group] = ACTIONS(SHIFT(5)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(9)),
[sym_number] = ACTIONS(SHIFT(5)),
[sym_variable] = ACTIONS(SHIFT(5)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(7)),
[aux_sym_STR_RPAREN] = ACTIONS(SHIFT(22)),
},
[8] = {
[sym__expression] = ACTIONS(SHIFT(9)),
[sym_sum] = ACTIONS(SHIFT(6)),
[sym_difference] = ACTIONS(SHIFT(6)),
[sym_product] = ACTIONS(SHIFT(6)),
[sym_quotient] = ACTIONS(SHIFT(6)),
[sym_exponent] = ACTIONS(SHIFT(6)),
[sym_group] = ACTIONS(SHIFT(6)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(10)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_variable] = ACTIONS(SHIFT(6)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(SHIFT(11)),
[aux_sym_STR_DASH] = ACTIONS(SHIFT(12)),
[aux_sym_STR_STAR] = ACTIONS(SHIFT(13)),
[aux_sym_STR_SLASH] = ACTIONS(SHIFT(14)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(15)),
[aux_sym_STR_RPAREN] = ACTIONS(SHIFT(10)),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(8)),
},
[9] = {
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_RPAREN] = ACTIONS(SHIFT(10)),
[aux_sym_STR_PLUS] = ACTIONS(SHIFT(12)),
[aux_sym_STR_DASH] = ACTIONS(SHIFT(13)),
[aux_sym_STR_STAR] = ACTIONS(SHIFT(14)),
[aux_sym_STR_SLASH] = ACTIONS(SHIFT(15)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(16)),
[aux_sym_STR_RPAREN] = ACTIONS(SHIFT(11)),
},
[10] = {
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_RPAREN] = ACTIONS(SHIFT(11)),
},
[11] = {
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_group, 3)),
[aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_group, 3)),
@ -380,72 +401,72 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[aux_sym_STR_CARET] = ACTIONS(REDUCE(sym_group, 3)),
[aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_group, 3)),
},
[11] = {
[sym_expression] = ACTIONS(SHIFT(20)),
[sym_sum] = ACTIONS(SHIFT(5)),
[sym_difference] = ACTIONS(SHIFT(5)),
[sym_product] = ACTIONS(SHIFT(5)),
[sym_quotient] = ACTIONS(SHIFT(5)),
[sym_exponent] = ACTIONS(SHIFT(5)),
[sym_group] = ACTIONS(SHIFT(5)),
[sym_number] = ACTIONS(SHIFT(5)),
[sym_variable] = ACTIONS(SHIFT(5)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(7)),
},
[12] = {
[sym_expression] = ACTIONS(SHIFT(19)),
[sym_sum] = ACTIONS(SHIFT(5)),
[sym_difference] = ACTIONS(SHIFT(5)),
[sym_product] = ACTIONS(SHIFT(5)),
[sym_quotient] = ACTIONS(SHIFT(5)),
[sym_exponent] = ACTIONS(SHIFT(5)),
[sym_group] = ACTIONS(SHIFT(5)),
[sym_number] = ACTIONS(SHIFT(5)),
[sym_variable] = ACTIONS(SHIFT(5)),
[sym__expression] = ACTIONS(SHIFT(21)),
[sym_sum] = ACTIONS(SHIFT(6)),
[sym_difference] = ACTIONS(SHIFT(6)),
[sym_product] = ACTIONS(SHIFT(6)),
[sym_quotient] = ACTIONS(SHIFT(6)),
[sym_exponent] = ACTIONS(SHIFT(6)),
[sym_group] = ACTIONS(SHIFT(6)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_variable] = ACTIONS(SHIFT(6)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(7)),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(8)),
},
[13] = {
[sym_expression] = ACTIONS(SHIFT(18)),
[sym_sum] = ACTIONS(SHIFT(5)),
[sym_difference] = ACTIONS(SHIFT(5)),
[sym_product] = ACTIONS(SHIFT(5)),
[sym_quotient] = ACTIONS(SHIFT(5)),
[sym_exponent] = ACTIONS(SHIFT(5)),
[sym_group] = ACTIONS(SHIFT(5)),
[sym_number] = ACTIONS(SHIFT(5)),
[sym_variable] = ACTIONS(SHIFT(5)),
[sym__expression] = ACTIONS(SHIFT(20)),
[sym_sum] = ACTIONS(SHIFT(6)),
[sym_difference] = ACTIONS(SHIFT(6)),
[sym_product] = ACTIONS(SHIFT(6)),
[sym_quotient] = ACTIONS(SHIFT(6)),
[sym_exponent] = ACTIONS(SHIFT(6)),
[sym_group] = ACTIONS(SHIFT(6)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_variable] = ACTIONS(SHIFT(6)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(7)),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(8)),
},
[14] = {
[sym_expression] = ACTIONS(SHIFT(17)),
[sym_sum] = ACTIONS(SHIFT(5)),
[sym_difference] = ACTIONS(SHIFT(5)),
[sym_product] = ACTIONS(SHIFT(5)),
[sym_quotient] = ACTIONS(SHIFT(5)),
[sym_exponent] = ACTIONS(SHIFT(5)),
[sym_group] = ACTIONS(SHIFT(5)),
[sym_number] = ACTIONS(SHIFT(5)),
[sym_variable] = ACTIONS(SHIFT(5)),
[sym__expression] = ACTIONS(SHIFT(19)),
[sym_sum] = ACTIONS(SHIFT(6)),
[sym_difference] = ACTIONS(SHIFT(6)),
[sym_product] = ACTIONS(SHIFT(6)),
[sym_quotient] = ACTIONS(SHIFT(6)),
[sym_exponent] = ACTIONS(SHIFT(6)),
[sym_group] = ACTIONS(SHIFT(6)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_variable] = ACTIONS(SHIFT(6)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(7)),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(8)),
},
[15] = {
[sym_expression] = ACTIONS(SHIFT(16)),
[sym_sum] = ACTIONS(SHIFT(5)),
[sym_difference] = ACTIONS(SHIFT(5)),
[sym_product] = ACTIONS(SHIFT(5)),
[sym_quotient] = ACTIONS(SHIFT(5)),
[sym_exponent] = ACTIONS(SHIFT(5)),
[sym_group] = ACTIONS(SHIFT(5)),
[sym_number] = ACTIONS(SHIFT(5)),
[sym_variable] = ACTIONS(SHIFT(5)),
[sym__expression] = ACTIONS(SHIFT(18)),
[sym_sum] = ACTIONS(SHIFT(6)),
[sym_difference] = ACTIONS(SHIFT(6)),
[sym_product] = ACTIONS(SHIFT(6)),
[sym_quotient] = ACTIONS(SHIFT(6)),
[sym_exponent] = ACTIONS(SHIFT(6)),
[sym_group] = ACTIONS(SHIFT(6)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_variable] = ACTIONS(SHIFT(6)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(7)),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(8)),
},
[16] = {
[sym__expression] = ACTIONS(SHIFT(17)),
[sym_sum] = ACTIONS(SHIFT(6)),
[sym_difference] = ACTIONS(SHIFT(6)),
[sym_product] = ACTIONS(SHIFT(6)),
[sym_quotient] = ACTIONS(SHIFT(6)),
[sym_exponent] = ACTIONS(SHIFT(6)),
[sym_group] = ACTIONS(SHIFT(6)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_variable] = ACTIONS(SHIFT(6)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(8)),
},
[17] = {
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
[aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
@ -454,43 +475,43 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[aux_sym_STR_CARET] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
[aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
},
[17] = {
[18] = {
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(15)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(16)),
[aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
},
[18] = {
[19] = {
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(15)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(16)),
[aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
},
[19] = {
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
[aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
[aux_sym_STR_STAR] = ACTIONS(SHIFT(13)),
[aux_sym_STR_SLASH] = ACTIONS(SHIFT(14)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(15)),
[aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
},
[20] = {
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
[aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
[aux_sym_STR_STAR] = ACTIONS(SHIFT(13)),
[aux_sym_STR_SLASH] = ACTIONS(SHIFT(14)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(15)),
[aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
[aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
[aux_sym_STR_STAR] = ACTIONS(SHIFT(14)),
[aux_sym_STR_SLASH] = ACTIONS(SHIFT(15)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(16)),
[aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
},
[21] = {
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
[aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
[aux_sym_STR_STAR] = ACTIONS(SHIFT(14)),
[aux_sym_STR_SLASH] = ACTIONS(SHIFT(15)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(16)),
[aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
},
[22] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_group, 3)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_group, 3)),
@ -499,72 +520,72 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_group, 3)),
[aux_sym_STR_CARET] = ACTIONS(REDUCE(sym_group, 3)),
},
[22] = {
[sym_expression] = ACTIONS(SHIFT(31)),
[sym_sum] = ACTIONS(SHIFT(2)),
[sym_difference] = ACTIONS(SHIFT(2)),
[sym_product] = ACTIONS(SHIFT(2)),
[sym_quotient] = ACTIONS(SHIFT(2)),
[sym_exponent] = ACTIONS(SHIFT(2)),
[sym_group] = ACTIONS(SHIFT(2)),
[sym_number] = ACTIONS(SHIFT(2)),
[sym_variable] = ACTIONS(SHIFT(2)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(3)),
},
[23] = {
[sym_expression] = ACTIONS(SHIFT(30)),
[sym_sum] = ACTIONS(SHIFT(2)),
[sym_difference] = ACTIONS(SHIFT(2)),
[sym_product] = ACTIONS(SHIFT(2)),
[sym_quotient] = ACTIONS(SHIFT(2)),
[sym_exponent] = ACTIONS(SHIFT(2)),
[sym_group] = ACTIONS(SHIFT(2)),
[sym_number] = ACTIONS(SHIFT(2)),
[sym_variable] = ACTIONS(SHIFT(2)),
[sym__expression] = ACTIONS(SHIFT(32)),
[sym_sum] = ACTIONS(SHIFT(3)),
[sym_difference] = ACTIONS(SHIFT(3)),
[sym_product] = ACTIONS(SHIFT(3)),
[sym_quotient] = ACTIONS(SHIFT(3)),
[sym_exponent] = ACTIONS(SHIFT(3)),
[sym_group] = ACTIONS(SHIFT(3)),
[sym_number] = ACTIONS(SHIFT(3)),
[sym_variable] = ACTIONS(SHIFT(3)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(3)),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(4)),
},
[24] = {
[sym_expression] = ACTIONS(SHIFT(29)),
[sym_sum] = ACTIONS(SHIFT(2)),
[sym_difference] = ACTIONS(SHIFT(2)),
[sym_product] = ACTIONS(SHIFT(2)),
[sym_quotient] = ACTIONS(SHIFT(2)),
[sym_exponent] = ACTIONS(SHIFT(2)),
[sym_group] = ACTIONS(SHIFT(2)),
[sym_number] = ACTIONS(SHIFT(2)),
[sym_variable] = ACTIONS(SHIFT(2)),
[sym__expression] = ACTIONS(SHIFT(31)),
[sym_sum] = ACTIONS(SHIFT(3)),
[sym_difference] = ACTIONS(SHIFT(3)),
[sym_product] = ACTIONS(SHIFT(3)),
[sym_quotient] = ACTIONS(SHIFT(3)),
[sym_exponent] = ACTIONS(SHIFT(3)),
[sym_group] = ACTIONS(SHIFT(3)),
[sym_number] = ACTIONS(SHIFT(3)),
[sym_variable] = ACTIONS(SHIFT(3)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(3)),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(4)),
},
[25] = {
[sym_expression] = ACTIONS(SHIFT(28)),
[sym_sum] = ACTIONS(SHIFT(2)),
[sym_difference] = ACTIONS(SHIFT(2)),
[sym_product] = ACTIONS(SHIFT(2)),
[sym_quotient] = ACTIONS(SHIFT(2)),
[sym_exponent] = ACTIONS(SHIFT(2)),
[sym_group] = ACTIONS(SHIFT(2)),
[sym_number] = ACTIONS(SHIFT(2)),
[sym_variable] = ACTIONS(SHIFT(2)),
[sym__expression] = ACTIONS(SHIFT(30)),
[sym_sum] = ACTIONS(SHIFT(3)),
[sym_difference] = ACTIONS(SHIFT(3)),
[sym_product] = ACTIONS(SHIFT(3)),
[sym_quotient] = ACTIONS(SHIFT(3)),
[sym_exponent] = ACTIONS(SHIFT(3)),
[sym_group] = ACTIONS(SHIFT(3)),
[sym_number] = ACTIONS(SHIFT(3)),
[sym_variable] = ACTIONS(SHIFT(3)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(3)),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(4)),
},
[26] = {
[sym_expression] = ACTIONS(SHIFT(27)),
[sym_sum] = ACTIONS(SHIFT(2)),
[sym_difference] = ACTIONS(SHIFT(2)),
[sym_product] = ACTIONS(SHIFT(2)),
[sym_quotient] = ACTIONS(SHIFT(2)),
[sym_exponent] = ACTIONS(SHIFT(2)),
[sym_group] = ACTIONS(SHIFT(2)),
[sym_number] = ACTIONS(SHIFT(2)),
[sym_variable] = ACTIONS(SHIFT(2)),
[sym__expression] = ACTIONS(SHIFT(29)),
[sym_sum] = ACTIONS(SHIFT(3)),
[sym_difference] = ACTIONS(SHIFT(3)),
[sym_product] = ACTIONS(SHIFT(3)),
[sym_quotient] = ACTIONS(SHIFT(3)),
[sym_exponent] = ACTIONS(SHIFT(3)),
[sym_group] = ACTIONS(SHIFT(3)),
[sym_number] = ACTIONS(SHIFT(3)),
[sym_variable] = ACTIONS(SHIFT(3)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(3)),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(4)),
},
[27] = {
[sym__expression] = ACTIONS(SHIFT(28)),
[sym_sum] = ACTIONS(SHIFT(3)),
[sym_difference] = ACTIONS(SHIFT(3)),
[sym_product] = ACTIONS(SHIFT(3)),
[sym_quotient] = ACTIONS(SHIFT(3)),
[sym_exponent] = ACTIONS(SHIFT(3)),
[sym_group] = ACTIONS(SHIFT(3)),
[sym_number] = ACTIONS(SHIFT(3)),
[sym_variable] = ACTIONS(SHIFT(3)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_LPAREN] = ACTIONS(SHIFT(4)),
},
[28] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
@ -573,41 +594,41 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
[aux_sym_STR_CARET] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
},
[28] = {
[29] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(26)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(27)),
},
[29] = {
[30] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(26)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(27)),
},
[30] = {
[31] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
[aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
[aux_sym_STR_STAR] = ACTIONS(SHIFT(24)),
[aux_sym_STR_SLASH] = ACTIONS(SHIFT(25)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(26)),
[aux_sym_STR_STAR] = ACTIONS(SHIFT(25)),
[aux_sym_STR_SLASH] = ACTIONS(SHIFT(26)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(27)),
},
[31] = {
[32] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
[aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
[aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
[aux_sym_STR_STAR] = ACTIONS(SHIFT(24)),
[aux_sym_STR_SLASH] = ACTIONS(SHIFT(25)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(26)),
[aux_sym_STR_STAR] = ACTIONS(SHIFT(25)),
[aux_sym_STR_SLASH] = ACTIONS(SHIFT(26)),
[aux_sym_STR_CARET] = ACTIONS(SHIFT(27)),
},
};

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

File diff suppressed because it is too large Load diff

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

File diff suppressed because it is too large Load diff

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

@ -4,7 +4,7 @@
#define SYMBOL_COUNT 18
enum {
sym_value = ts_builtin_sym_start,
sym__value = ts_builtin_sym_start,
sym_object,
sym_array,
sym_string,
@ -23,7 +23,7 @@ enum {
};
static const char *ts_symbol_names[] = {
[sym_value] = "value",
[sym__value] = "_value",
[sym_object] = "object",
[sym_array] = "array",
[ts_builtin_sym_error] = "ERROR",
@ -44,6 +44,7 @@ static const char *ts_symbol_names[] = {
};
static const int ts_hidden_symbol_flags[SYMBOL_COUNT] = {
[sym__value] = 1,
[aux_sym_object_repeat1] = 1,
[aux_sym_array_repeat1] = 1,
[aux_sym_STR_LBRACE] = 1,
@ -441,7 +442,7 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[0] = {
[sym_value] = ACTIONS(SHIFT(1)),
[sym__value] = ACTIONS(SHIFT(1)),
[sym_object] = ACTIONS(SHIFT(2)),
[sym_array] = ACTIONS(SHIFT(2)),
[sym_string] = ACTIONS(SHIFT(2)),
@ -456,7 +457,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[ts_builtin_sym_end] = ACTIONS(ACCEPT_INPUT()),
},
[2] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_value, 1)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym__value, 1)),
},
[3] = {
[ts_builtin_sym_error] = ACTIONS(SHIFT(58)),
@ -464,7 +465,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[aux_sym_STR_RBRACE] = ACTIONS(SHIFT(60)),
},
[4] = {
[sym_value] = ACTIONS(SHIFT(5)),
[sym__value] = ACTIONS(SHIFT(5)),
[sym_object] = ACTIONS(SHIFT(6)),
[sym_array] = ACTIONS(SHIFT(6)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(5)),
@ -483,9 +484,9 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[aux_sym_STR_RBRACK] = ACTIONS(SHIFT(56)),
},
[6] = {
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_value, 1)),
[aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_value, 1)),
[aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_value, 1)),
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym__value, 1)),
[aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__value, 1)),
[aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym__value, 1)),
},
[7] = {
[ts_builtin_sym_error] = ACTIONS(SHIFT(18)),
@ -493,7 +494,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[aux_sym_STR_RBRACE] = ACTIONS(SHIFT(20)),
},
[8] = {
[sym_value] = ACTIONS(SHIFT(10)),
[sym__value] = ACTIONS(SHIFT(10)),
[sym_object] = ACTIONS(SHIFT(6)),
[sym_array] = ACTIONS(SHIFT(6)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(10)),
@ -523,7 +524,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[aux_sym_STR_RBRACK] = ACTIONS(SHIFT(17)),
},
[13] = {
[sym_value] = ACTIONS(SHIFT(15)),
[sym__value] = ACTIONS(SHIFT(15)),
[sym_object] = ACTIONS(SHIFT(6)),
[sym_array] = ACTIONS(SHIFT(6)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(15)),
@ -567,7 +568,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_object, 2)),
},
[21] = {
[sym_value] = ACTIONS(SHIFT(22)),
[sym__value] = ACTIONS(SHIFT(22)),
[sym_object] = ACTIONS(SHIFT(23)),
[sym_array] = ACTIONS(SHIFT(23)),
[sym_string] = ACTIONS(SHIFT(23)),
@ -584,9 +585,9 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[aux_sym_STR_RBRACE] = ACTIONS(SHIFT(50)),
},
[23] = {
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_value, 1)),
[aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_value, 1)),
[aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_value, 1)),
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym__value, 1)),
[aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__value, 1)),
[aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__value, 1)),
},
[24] = {
[ts_builtin_sym_error] = ACTIONS(SHIFT(31)),
@ -594,7 +595,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[aux_sym_STR_RBRACE] = ACTIONS(SHIFT(33)),
},
[25] = {
[sym_value] = ACTIONS(SHIFT(26)),
[sym__value] = ACTIONS(SHIFT(26)),
[sym_object] = ACTIONS(SHIFT(6)),
[sym_array] = ACTIONS(SHIFT(6)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(26)),
@ -644,7 +645,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_object, 2)),
},
[34] = {
[sym_value] = ACTIONS(SHIFT(35)),
[sym__value] = ACTIONS(SHIFT(35)),
[sym_object] = ACTIONS(SHIFT(23)),
[sym_array] = ACTIONS(SHIFT(23)),
[sym_string] = ACTIONS(SHIFT(23)),
@ -681,7 +682,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[aux_sym_STR_COLON] = ACTIONS(SHIFT(41)),
},
[41] = {
[sym_value] = ACTIONS(SHIFT(42)),
[sym__value] = ACTIONS(SHIFT(42)),
[sym_object] = ACTIONS(SHIFT(23)),
[sym_array] = ACTIONS(SHIFT(23)),
[sym_string] = ACTIONS(SHIFT(23)),
@ -768,7 +769,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_object, 2)),
},
[61] = {
[sym_value] = ACTIONS(SHIFT(62)),
[sym__value] = ACTIONS(SHIFT(62)),
[sym_object] = ACTIONS(SHIFT(23)),
[sym_array] = ACTIONS(SHIFT(23)),
[sym_string] = ACTIONS(SHIFT(23)),

2
spec/runtime/document_spec.cc
View file

@ -85,7 +85,7 @@ describe("Document", [&]() {
AssertThat(debugger->messages, Contains("new_parse"));
AssertThat(debugger->messages, Contains("lookahead char:'['"));
AssertThat(debugger->messages, Contains("reduce sym:value, count:1"));
AssertThat(debugger->messages, Contains("reduce sym:array, count:4"));
AssertThat(debugger->messages, Contains("accept"));
});

4
spec/runtime/languages/arithmetic/errors.txt
View file

@ -16,7 +16,7 @@ x + (y * + z) * 5
---
(sum
(program (sum
(variable)
(product
(group (ERROR (variable) (UNEXPECTED '+') (variable))) (number)))
(group (ERROR (variable) (UNEXPECTED '+') (variable))) (number))))

18
spec/runtime/languages/arithmetic/main.txt
View file

@ -6,7 +6,7 @@ numbers
---
(number)
(program (number))
===================
variables
@ -16,7 +16,7 @@ x
---
(variable)
(program (variable))
====================================
variables with greek letters
@ -26,7 +26,7 @@ variables with greek letters
---
(variable)
(program (variable))
===================
products
@ -36,7 +36,7 @@ x * x
---
(product (variable) (variable))
(program (product (variable) (variable)))
===================
sums
@ -46,7 +46,7 @@ x + x
---
(sum (variable) (variable))
(program (sum (variable) (variable)))
===============================================
operators of different precedence
@ -56,9 +56,9 @@ a * b + c * d
---
(sum
(program (sum
(product (variable) (variable))
(product (variable) (variable)))
(product (variable) (variable))))
============================
exponents
@ -68,10 +68,10 @@ x + y * z^(a + b)
---
(sum
(program (sum
(variable)
(product
(variable)
(exponent
(variable)
(group (sum (variable) (variable))))))
(group (sum (variable) (variable)))))))

27
spec/runtime/languages/c/declarations.txt
View file

@ -6,7 +6,8 @@ int x;
---
(declaration (identifier) (identifier))
(program
(declaration (type_name (identifier)) (declarator (identifier))))
==========================================
simple functions
@ -17,25 +18,27 @@ int main() {
---
(function_definition
(identifier) (direct_declarator (identifier))
(compound_statement))
(program (function_definition
(type_name (identifier))
(declarator (identifier))
(compound_statement)))
==========================================
ambiguous declarations
==========================================
int main() {
int i;
someTypeOrValue * pointerOrMultiplicand();
float y;
int i;
someTypeOrValue * pointerOrMultiplicand();
float y;
}
---
(function_definition
(identifier) (direct_declarator (identifier))
(program (function_definition
(type_name (identifier))
(declarator (identifier))
(compound_statement
(declaration (identifier) (identifier))
(declaration (identifier) (declarator (pointer) (direct_declarator (identifier))))
(declaration (identifier) (identifier))))
(declaration (type_name (identifier)) (declarator (identifier)))
(declaration (type_name (identifier)) (declarator (pointer) (identifier)))
(declaration (type_name (identifier)) (declarator (identifier))))))

2
spec/runtime/languages/golang/declarations.txt
View file

@ -48,5 +48,5 @@ func main() {
(program
(package_directive (package_name))
(var_declaration (var_name) (expression (number) (comment)))
(var_declaration (var_name) (number) (comment))
(func_declaration (var_name) (block_statement (comment))))

6
spec/runtime/languages/golang/errors.txt
View file

@ -10,6 +10,6 @@ package trivial
---
(program
(package_directive (package_name))
(func_declaration (var_name) (block_statement))
(func_declaration (var_name) (block_statement)))
(package_directive (package_name))
(func_declaration (var_name) (block_statement))
(func_declaration (var_name) (block_statement)))

27
spec/runtime/languages/golang/expressions.txt
View file

@ -5,17 +5,17 @@ function calls
package main
func main() {
println("1", 2)
println()
println("1", 2)
println()
}
---
(program
(package_directive (package_name))
(func_declaration (var_name) (block_statement
(expression_statement (call_expression (var_name) (string) (number)))
(expression_statement (call_expression (var_name))))))
(package_directive (package_name))
(func_declaration (var_name) (block_statement
(expression_statement (call_expression (var_name) (string) (number)))
(expression_statement (call_expression (var_name))))))
============================================
selector expressions
@ -24,16 +24,15 @@ selector expressions
package main
func main() {
x.SomeMethod(x.SomeField, x.OtherField.NestedField);
x.SomeMethod(x.SomeField, x.OtherField.NestedField);
}
---
(program
(package_directive (package_name))
(func_declaration (var_name) (block_statement
(expression_statement (call_expression
(selector_expression (var_name) (var_name))
(selector_expression (var_name) (var_name))
(selector_expression (selector_expression (var_name) (var_name)) (var_name)))))))
(package_directive (package_name))
(func_declaration (var_name) (block_statement
(expression_statement (call_expression
(selector_expression (var_name) (var_name))
(selector_expression (var_name) (var_name))
(selector_expression (selector_expression (var_name) (var_name)) (var_name)))))))

58
spec/runtime/languages/golang/statements.txt
View file

@ -14,10 +14,10 @@ func helper() {
---
(program (package_directive (package_name))
(func_declaration (var_name) (block_statement
(return_statement)))
(func_declaration (var_name) (block_statement
(return_statement (number) (var_name) (string)))))
(func_declaration (var_name) (block_statement
(return_statement)))
(func_declaration (var_name) (block_statement
(return_statement (number) (var_name) (string)))))
============================================
variable declarations
@ -34,10 +34,10 @@ func main() {
---
(program (package_directive (package_name))
(func_declaration (var_name) (block_statement
(declaration_statement (var_name) (var_name) (call_expression (var_name)))
(var_declaration (var_name) (number))
(expression_statement (call_expression (var_name) (var_name) (var_name) (var_name))))))
(func_declaration (var_name) (block_statement
(short_var_declaration (var_name) (var_name) (call_expression (var_name)))
(var_declaration (var_name) (number))
(expression_statement (call_expression (var_name) (var_name) (var_name) (var_name))))))
============================================
if statements
@ -46,30 +46,30 @@ if statements
package main
func main() {
if condition1() {
}
if condition1() {
}
if condition2() {
} else {
}
if condition2() {
} else {
}
if condition3() {
} else if condition4() {
}
if condition3() {
} else if condition4() {
}
}
---
(program (package_directive (package_name))
(func_declaration (var_name) (block_statement
(func_declaration (var_name) (block_statement
(if_statement (call_expression (var_name))
(block_statement))
(if_statement (call_expression (var_name))
(block_statement) (block_statement))
(if_statement (call_expression (var_name))
(block_statement)
(if_statement (call_expression (var_name))
(block_statement))
(if_statement (call_expression (var_name))
(block_statement) (block_statement))
(if_statement (call_expression (var_name))
(block_statement)
(if_statement (call_expression (var_name))
(block_statement))))))
(block_statement))))))
=============================================
range statements
@ -90,8 +90,8 @@ func main() {
---
(program (package_directive (package_name))
(func_declaration (var_name) (block_statement
(range_statement (var_name) (call_expression (var_name)) (block_statement
(expression_statement (call_expression (var_name) (var_name)))))
(range_statement (var_name) (var_name) (call_expression (var_name)) (block_statement
(expression_statement (call_expression (var_name) (var_name) (var_name))))))))
(func_declaration (var_name) (block_statement
(range_statement (var_name) (call_expression (var_name)) (block_statement
(expression_statement (call_expression (var_name) (var_name)))))
(range_statement (var_name) (var_name) (call_expression (var_name)) (block_statement
(expression_statement (call_expression (var_name) (var_name) (var_name))))))))

49
spec/runtime/languages/golang/types.txt
View file

@ -5,21 +5,21 @@ composite types
package main
type x *struct {
field1 []int64
field2 map[string]interface{
DoStuff()
}
field1 []int64
field2 map[string]interface{
DoStuff()
}
}
---
(program
(package_directive (package_name))
(type_declaration
(type_name)
(pointer_type (struct_type
(var_name) (slice_type (type_name))
(var_name) (map_type (type_name) (interface_type (var_name)))))))
(package_directive (package_name))
(type_declaration
(type_name)
(pointer_type (struct_type
(var_name) (slice_type (type_name))
(var_name) (map_type (type_name) (interface_type (var_name)))))))
============================================
functions arguments
@ -34,10 +34,10 @@ func argsOfDifferentTypes() (arg1 string, arg2 int64) {}
---
(program
(package_directive (package_name))
(func_declaration (var_name) (var_name) (interface_type) (block_statement))
(func_declaration (var_name) (var_name) (var_name) (type_name) (block_statement))
(func_declaration (var_name) (var_name) (type_name) (var_name) (type_name) (block_statement)))
(package_directive (package_name))
(func_declaration (var_name) (var_name) (interface_type) (block_statement))
(func_declaration (var_name) (var_name) (var_name) (type_name) (block_statement))
(func_declaration (var_name) (var_name) (type_name) (var_name) (type_name) (block_statement)))
============================================
functions with unnamed return values
@ -51,11 +51,11 @@ func multipleReturnValues() (string, int64, error) {}
---
(program
(package_directive (package_name))
(func_declaration (var_name) (type_name)
(block_statement))
(func_declaration (var_name) (type_name) (type_name) (type_name)
(block_statement)))
(package_directive (package_name))
(func_declaration (var_name) (type_name)
(block_statement))
(func_declaration (var_name) (type_name) (type_name) (type_name)
(block_statement)))
============================================
functions with named return values
@ -69,9 +69,8 @@ func multipleReturnValues() (result string, count int64, err error) {}
---
(program
(package_directive (package_name))
(func_declaration (var_name) (var_name) (type_name)
(block_statement))
(func_declaration (var_name) (var_name) (type_name) (var_name) (type_name) (var_name) (type_name)
(block_statement)))
(package_directive (package_name))
(func_declaration (var_name) (var_name) (type_name)
(block_statement))
(func_declaration (var_name) (var_name) (type_name) (var_name) (type_name) (var_name) (type_name)
(block_statement)))

66
spec/runtime/parser_spec.cc
View file

@ -160,7 +160,7 @@ describe("Parser", [&]() {
set_text("fn()\n");
AssertThat(ts_node_string(root, doc), Equals(
"(expression_statement (function_call (identifier) (arguments)))"));
"(program (expression_statement (function_call (identifier) (arguments))))"));
});
});
@ -171,9 +171,9 @@ describe("Parser", [&]() {
" .otherFn();");
AssertThat(ts_node_string(root, doc), Equals(
"(expression_statement (function_call "
"(program (expression_statement (function_call "
"(member_access (function_call (identifier) (arguments)) (identifier)) "
"(arguments)))"));
"(arguments))))"));
});
});
@ -186,11 +186,11 @@ describe("Parser", [&]() {
".otherFn();");
AssertThat(ts_node_string(root, doc), Equals(
"(expression_statement (function_call "
"(program (expression_statement (function_call "
"(member_access (function_call (identifier) (arguments)) "
"(comment) "
"(identifier)) "
"(arguments)))"));
"(arguments))))"));
});
});
});
@ -206,18 +206,18 @@ describe("Parser", [&]() {
set_text("x ^ (100 + abc)");
AssertThat(ts_node_string(root, doc), Equals(
"(exponent "
"(program (exponent "
"(variable) "
"(group (sum (number) (variable))))"));
"(group (sum (number) (variable)))))"));
insert_text(strlen("x ^ (100 + abc"), " * 5");
});
it("updates the parse tree", [&]() {
AssertThat(ts_node_string(root, doc), Equals(
"(exponent "
"(program (exponent "
"(variable) "
"(group (sum (number) (product (variable) (number)))))"));
"(group (sum (number) (product (variable) (number))))))"));
});
it("re-reads only the changed portion of the input", [&]() {
@ -232,20 +232,20 @@ describe("Parser", [&]() {
set_text("123 * 456 ^ (10 + x)");
AssertThat(ts_node_string(root, doc), Equals(
"(product "
"(program (product "
"(number) "
"(exponent (number) (group (sum (number) (variable)))))"));
"(exponent (number) (group (sum (number) (variable))))))"));
insert_text(strlen("123"), " + 5");
});
it("updates the parse tree", [&]() {
AssertThat(ts_node_string(root, doc), Equals(
"(sum "
"(program (sum "
"(number) "
"(product "
"(number) "
"(exponent (number) (group (sum (number) (variable))))))"));
"(exponent (number) (group (sum (number) (variable)))))))"));
});
it("re-reads only the changed portion of the input", [&]() {
@ -260,19 +260,19 @@ describe("Parser", [&]() {
set_text("var x = y;");
AssertThat(ts_node_string(root, doc), Equals(
"(var_declaration (var_assignment "
"(identifier) (identifier)))"));
"(program (var_declaration (var_assignment "
"(identifier) (identifier))))"));
insert_text(strlen("var x = y"), " *");
AssertThat(ts_node_string(root, doc), Equals(
"(var_declaration (ERROR (identifier) (identifier) (UNEXPECTED ';')))"));
"(program (var_declaration (ERROR (identifier) (identifier) (UNEXPECTED ';'))))"));
insert_text(strlen("var x = y *"), " z");
AssertThat(ts_node_string(root, doc), Equals(
"(var_declaration (var_assignment "
"(identifier) (math_op (identifier) (identifier))))"));
"(program (var_declaration (var_assignment "
"(identifier) (math_op (identifier) (identifier)))))"));
});
});
@ -281,14 +281,14 @@ describe("Parser", [&]() {
set_text("abc * 123");
AssertThat(ts_node_string(root, doc), Equals(
"(product (variable) (number))"));
"(program (product (variable) (number)))"));
insert_text(strlen("ab"), "XYZ");
});
it("updates the parse tree", [&]() {
AssertThat(ts_node_string(root, doc), Equals(
"(product (variable) (number))"));
"(program (product (variable) (number)))"));
TSNode node = ts_node_find_for_pos(root, 1);
AssertThat(ts_node_name(node, doc), Equals("variable"));
@ -301,14 +301,14 @@ describe("Parser", [&]() {
set_text("abc * 123");
AssertThat(ts_node_string(root, doc), Equals(
"(product (variable) (number))"));
"(program (product (variable) (number)))"));
insert_text(strlen("abc"), "XYZ");
});
it("updates the parse tree", [&]() {
AssertThat(ts_node_string(root, doc), Equals(
"(product (variable) (number))"));
"(program (product (variable) (number)))"));
TSNode node = ts_node_find_for_pos(root, 1);
AssertThat(ts_node_name(node, doc), Equals("variable"));
@ -322,7 +322,7 @@ describe("Parser", [&]() {
set_text("\u03b1\u03b2\u03b4 + 1");
AssertThat(ts_node_string(root, doc), Equals(
"(sum (variable) (number))"));
"(program (sum (variable) (number)))"));
// αβδ + ψ1
insert_text(strlen("abd + "), "\u03c8");
@ -330,7 +330,7 @@ describe("Parser", [&]() {
it("inserts the text according to the UTF8 character index", [&]() {
AssertThat(ts_node_string(root, doc), Equals(
"(sum (variable) (variable))"));
"(program (sum (variable) (variable)))"));
});
});
@ -341,7 +341,7 @@ describe("Parser", [&]() {
"abc");
AssertThat(ts_node_string(root, doc), Equals(
"(product (number) (comment) (variable))"));
"(program (product (number) (comment) (variable)))"));
insert_text(
strlen("123 *\n"
@ -352,7 +352,7 @@ describe("Parser", [&]() {
it("updates the parse tree", [&]() {
AssertThat(ts_node_string(root, doc), Equals(
"(product (number) (comment) (variable))"));
"(program (product (number) (comment) (variable)))"));
});
});
});
@ -363,7 +363,7 @@ describe("Parser", [&]() {
set_text("123 * 456");
AssertThat(ts_node_string(root, doc), Equals(
"(product (number) (number))"));
"(program (product (number) (number)))"));
delete_text(strlen("123 "), 2);
});
@ -382,14 +382,14 @@ describe("Parser", [&]() {
set_text("{ x: (b.c) };");
AssertThat(ts_node_string(root, doc), Equals(
"(expression_statement (object (pair "
"(identifier) (member_access (identifier) (identifier)))))"));
"(program (expression_statement (object (pair "
"(identifier) (member_access (identifier) (identifier))))))"));
replace_text(strlen("{ x: "), strlen("(b.c)"), "b.c");
AssertThat(ts_node_string(root, doc), Equals(
"(expression_statement (object (pair "
"(identifier) (member_access (identifier) (identifier)))))"));
"(program (expression_statement (object (pair "
"(identifier) (member_access (identifier) (identifier))))))"));
});
});
});
@ -404,7 +404,7 @@ describe("Parser", [&]() {
set_text("x # this is a comment");
AssertThat(ts_node_string(root, doc), Equals(
"(expression (variable) (comment))"));
"(program (variable) (comment))"));
TSNode comment = ts_node_child(root, 1);
@ -417,7 +417,7 @@ describe("Parser", [&]() {
set_text("x # \u03A9\u03A9\u03A9 \u2014 \u0394\u0394");
AssertThat(ts_node_string(root, doc), Equals(
"(expression (variable) (comment))"));
"(program (variable) (comment))"));
AssertThat(ts_node_size(root).chars, Equals(strlen("x # OOO - DD")));
AssertThat(ts_node_size(root).bytes, Equals(strlen("x # \u03A9\u03A9\u03A9 \u2014 \u0394\u0394")));

8
src/runtime/document.c
View file

@ -63,8 +63,8 @@ void ts_document_set_input_string(TSDocument *document, const char *text) {
}
TSNode ts_document_root_node(const TSDocument *document) {
TSTree *tree = document->tree;
while (tree && ts_tree_is_singleton(tree))
tree = tree->children[0];
return ts_node_make(tree, ts_length_zero());
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);
return result;
}

4
src/runtime/tree.c
View file

@ -67,9 +67,6 @@ TSTree *ts_tree_make_node(TSSymbol symbol, size_t child_count,
} else {
if (is_hidden)
options |= TSTreeOptionsHidden;
if (child_count == 1 &&
(ts_tree_is_visible(children[0]) || ts_tree_is_singleton(children[0])))
options |= (TSTreeOptionsSingleton | TSTreeOptionsHidden);
if (child_count > 0) {
if (ts_tree_is_fragile_left(children[0]))
options |= (TSTreeOptionsFragileLeft);
@ -207,7 +204,6 @@ void ts_tree_prepend_children(TSTree *tree, size_t count, TSTree **children) {
tree->child_count * sizeof(TSTree *));
free(tree->children);
ts_tree_unset_singleton(tree);
tree->children = new_children;
tree->visible_child_count += visible_count;
tree->child_count += count;

13
src/runtime/tree.h
View file

@ -11,9 +11,8 @@ extern "C" {
typedef enum {
TSTreeOptionsHidden = 1 << 0,
TSTreeOptionsExtra = 1 << 1,
TSTreeOptionsSingleton = 1 << 2,
TSTreeOptionsFragileLeft = 1 << 3,
TSTreeOptionsFragileRight = 1 << 4,
TSTreeOptionsFragileLeft = 1 << 2,
TSTreeOptionsFragileRight = 1 << 3,
} TSTreeOptions;
struct TSTree {
@ -47,14 +46,6 @@ static inline bool ts_tree_is_visible(const TSTree *tree) {
return !(tree->options & TSTreeOptionsHidden);
}
static inline bool ts_tree_is_singleton(const TSTree *tree) {
return !!(tree->options & TSTreeOptionsSingleton);
}
static inline void ts_tree_unset_singleton(TSTree *tree) {
tree->options = (TSTreeOptions)(tree->options & ~TSTreeOptionsSingleton);
}
static inline void ts_tree_set_options(TSTree *tree, TSTreeOptions options) {
tree->options = (TSTreeOptions)(tree->options | options);
}