From 4106ecda43f7a9601087235bec7266bca7af5936 Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Fri, 4 Nov 2016 09:18:38 -0700 Subject: [PATCH] Remove logic for recovering from OOM --- include/tree_sitter/runtime.h | 4 +- script/test | 2 +- spec/helpers/record_alloc.cc | 44 +---- spec/runtime/parser_spec.cc | 77 +------- spec/runtime/stack_spec.cc | 12 +- src/runtime/array.h | 37 ++-- src/runtime/document.c | 18 +- src/runtime/parser.c | 323 +++++++++------------------------- src/runtime/reduce_action.h | 6 +- src/runtime/stack.c | 91 +++------- src/runtime/stack.h | 6 +- src/runtime/tree.c | 30 +--- src/runtime/tree.h | 2 +- src/runtime/tree_path.h | 11 +- 14 files changed, 162 insertions(+), 501 deletions(-) diff --git a/include/tree_sitter/runtime.h b/include/tree_sitter/runtime.h index 5ee5ba6f..8ab952d0 100644 --- a/include/tree_sitter/runtime.h +++ b/include/tree_sitter/runtime.h @@ -105,8 +105,8 @@ TSLogger ts_document_logger(const TSDocument *); void ts_document_set_logger(TSDocument *, TSLogger); void ts_document_print_debugging_graphs(TSDocument *, bool); void ts_document_edit(TSDocument *, TSInputEdit); -int ts_document_parse(TSDocument *); -int ts_document_parse_and_get_changed_ranges(TSDocument *, TSRange **, size_t *); +void ts_document_parse(TSDocument *); +void ts_document_parse_and_get_changed_ranges(TSDocument *, TSRange **, size_t *); void ts_document_invalidate(TSDocument *); TSNode ts_document_root_node(const TSDocument *); size_t ts_document_parse_count(const TSDocument *); diff --git a/script/test b/script/test index 0b61b0cb..27a34e6f 100755 --- a/script/test +++ b/script/test @@ -24,7 +24,7 @@ OPTIONS -s set the seed used to control random behavior - -z pipe tests' stderr to `dot(1)`, to render an SVG log + -z pipe tests' stderr to \`dot(1)\` to render an SVG log EOF } diff --git a/spec/helpers/record_alloc.cc b/spec/helpers/record_alloc.cc index 4b057a61..fca5ec02 100644 --- a/spec/helpers/record_alloc.cc +++ b/spec/helpers/record_alloc.cc @@ -6,10 +6,9 @@ using std::map; using std::set; -bool _enabled = false; +static bool _enabled = false; static size_t _allocation_count = 0; static map _outstanding_allocations; -static size_t _allocation_failure_index = -1; namespace record_alloc { @@ -17,17 +16,12 @@ void start() { _enabled = true; _allocation_count = 0; _outstanding_allocations.clear(); - _allocation_failure_index = -1; } void stop() { _enabled = false; } -void fail_at_allocation_index(size_t failure_index) { - _allocation_failure_index = failure_index; -} - set outstanding_allocation_indices() { set result; for (const auto &entry : _outstanding_allocations) { @@ -42,12 +36,7 @@ size_t allocation_count() { } // namespace record_alloc -static bool can_allocate() { - if (!_enabled) - return true; - - return _allocation_count < _allocation_failure_index; -} +extern "C" { static void *record_allocation(void *result) { if (!_enabled) @@ -58,10 +47,6 @@ static void *record_allocation(void *result) { return result; } -static void record_allocation_failure() { - _allocation_count++; -} - static void record_deallocation(void *pointer) { if (!_enabled) return; @@ -72,34 +57,17 @@ static void record_deallocation(void *pointer) { } } -extern "C" { - void *ts_record_malloc(size_t size) { - if (can_allocate()) { - return record_allocation(malloc(size)); - } else { - record_allocation_failure(); - return NULL; - } + return record_allocation(malloc(size)); } void *ts_record_realloc(void *pointer, size_t size) { - if (can_allocate()) { - record_deallocation(pointer); - return record_allocation(realloc(pointer, size)); - } else { - record_allocation_failure(); - return NULL; - } + record_deallocation(pointer); + return record_allocation(realloc(pointer, size)); } void *ts_record_calloc(size_t count, size_t size) { - if (can_allocate()) { - return record_allocation(calloc(count, size)); - } else { - record_allocation_failure(); - return NULL; - } + return record_allocation(calloc(count, size)); } void ts_record_free(void *pointer) { diff --git a/spec/runtime/parser_spec.cc b/spec/runtime/parser_spec.cc index 00acdd85..a14fa68e 100644 --- a/spec/runtime/parser_spec.cc +++ b/spec/runtime/parser_spec.cc @@ -36,7 +36,7 @@ describe("Parser", [&]() { auto set_text = [&](const char *text) { input = new SpyInput(text, chunk_size); ts_document_set_input(doc, input->input()); - AssertThat(ts_document_parse(doc), Equals(0)); + ts_document_parse(doc); root = ts_document_root_node(doc); AssertThat(ts_node_end_byte(root), Equals(strlen(text))); @@ -446,81 +446,6 @@ describe("Parser", [&]() { AssertThat(ts_node_end_byte(root), Equals(strlen("'\u03A9\u03A9\u03A9 \u2014 \u0394\u0394';"))); }); }); - - describe("handling allocation failures", [&]() { - it("handles failures when allocating documents", [&]() { - record_alloc::start(); - - TSDocument *document = ts_document_new(); - ts_document_free(document); - AssertThat(record_alloc::outstanding_allocation_indices(), IsEmpty()); - - size_t allocation_count = record_alloc::allocation_count(); - AssertThat(allocation_count, IsGreaterThan(1)); - - for (size_t i = 0; i < allocation_count; i++) { - record_alloc::start(); - record_alloc::fail_at_allocation_index(i); - AssertThat(ts_document_new(), Equals(nullptr)); - AssertThat(record_alloc::outstanding_allocation_indices(), IsEmpty()); - } - - record_alloc::stop(); - }); - - it("handles allocation failures during parsing", [&]() { - const TSLanguage *language = get_test_language("cpp"); - const char *input_string = "int main() { return vector().size(); }"; - string expected_node_string = - "(translation_unit (function_definition " - "(identifier) " - "(function_declarator (identifier)) " - "(compound_statement " - "(return_statement (call_expression (field_expression " - "(call_expression (template_call " - "(identifier) " - "(type_name (identifier) (abstract_pointer_declarator)))) " - "(identifier)))))))"; - - record_alloc::start(); - ts_document_set_language(doc, language); - ts_document_set_input_string(doc, input_string); - AssertThat(ts_document_parse(doc), Equals(0)); - - size_t allocation_count = record_alloc::allocation_count(); - AssertThat(allocation_count, IsGreaterThan(1)); - - assert_root_node(expected_node_string); - ts_document_free(doc); - doc = nullptr; - AssertThat(record_alloc::outstanding_allocation_indices(), IsEmpty()); - - for (size_t i = 0; i < allocation_count; i++) { - record_alloc::stop(); - doc = ts_document_new(); - - record_alloc::start(); - record_alloc::fail_at_allocation_index(i); - ts_document_set_language(doc, language); - ts_document_set_input_string(doc, input_string); - AssertThat(ts_document_parse(doc), Equals(-1)); - AssertThat(ts_document_root_node(doc).data, Equals(nullptr)); - - ts_document_free(doc); - doc = nullptr; - } - - record_alloc::stop(); - doc = ts_document_new(); - - record_alloc::start(); - record_alloc::fail_at_allocation_index(allocation_count + 1); - ts_document_set_language(doc, language); - ts_document_set_input_string(doc, input_string); - AssertThat(ts_document_parse(doc), Equals(0)); - assert_root_node(expected_node_string); - }); - }); }); END_TEST diff --git a/spec/runtime/stack_spec.cc b/spec/runtime/stack_spec.cc index 7738f2fe..b625a0af 100644 --- a/spec/runtime/stack_spec.cc +++ b/spec/runtime/stack_spec.cc @@ -217,7 +217,7 @@ describe("Stack", [&]() { // ↑ // └─* StackPopResult pop = ts_stack_pop_count(stack, 0, 2); - AssertThat(pop.status, Equals(StackPopResult::StackPopSucceeded)); + AssertThat(pop.stopped_at_error, Equals(false)); AssertThat(pop.slices.size, Equals(1)); AssertThat(ts_stack_version_count(stack), Equals(2)); @@ -236,7 +236,7 @@ describe("Stack", [&]() { // ↑ // └─* StackPopResult pop = ts_stack_pop_count(stack, 0, 2); - AssertThat(pop.status, Equals(StackPopResult::StackPopSucceeded)); + AssertThat(pop.stopped_at_error, Equals(false)); AssertThat(pop.slices.size, Equals(1)); StackSlice slice = pop.slices.contents[0]; @@ -255,7 +255,7 @@ describe("Stack", [&]() { // ↑ // └─* StackPopResult pop = ts_stack_pop_count(stack, 0, 3); - AssertThat(pop.status, Equals(StackPopResult::StackPopStoppedAtError)); + AssertThat(pop.stopped_at_error, Equals(true)); AssertThat(ts_stack_version_count(stack), Equals(2)); AssertThat(ts_stack_top_state(stack, 1), Equals(ERROR_STATE)); @@ -471,7 +471,7 @@ describe("Stack", [&]() { ts_stack_push(stack, 0, trees[1], true, stateB); StackPopResult pop = ts_stack_pop_pending(stack, 0); - AssertThat(pop.status, Equals(StackPopResult::StackPopSucceeded)); + AssertThat(pop.stopped_at_error, Equals(false)); AssertThat(pop.slices.size, Equals(1)); AssertThat(get_stack_entries(stack, 0), Equals(vector({ @@ -492,7 +492,7 @@ describe("Stack", [&]() { ts_stack_push(stack, 0, trees[3], false, stateB); StackPopResult pop = ts_stack_pop_pending(stack, 0); - AssertThat(pop.status, Equals(StackPopResult::StackPopSucceeded)); + AssertThat(pop.stopped_at_error, Equals(false)); AssertThat(pop.slices.size, Equals(1)); AssertThat(pop.slices.contents[0].trees, Equals(vector({ trees[1], trees[2], trees[3] }))); @@ -509,7 +509,7 @@ describe("Stack", [&]() { ts_stack_push(stack, 0, trees[1], false, stateB); StackPopResult pop = ts_stack_pop_pending(stack, 0); - AssertThat(pop.status, Equals(StackPopResult::StackPopSucceeded)); + AssertThat(pop.stopped_at_error, Equals(false)); AssertThat(pop.slices.size, Equals(0)); AssertThat(get_stack_entries(stack, 0), Equals(vector({ diff --git a/src/runtime/array.h b/src/runtime/array.h index c68522cf..f78a1ec7 100644 --- a/src/runtime/array.h +++ b/src/runtime/array.h @@ -42,9 +42,9 @@ extern "C" { #define array_delete(self) array__delete((VoidArray *)self) #define array_push(self, element) \ - (((self)->size < (self)->capacity || \ - array_grow((self), (self)->capacity ? (self)->capacity * 2 : 8)) && \ - ((self)->contents[(self)->size++] = (element), true)) + ((self)->size < (self)->capacity || \ + (array_grow((self), (self)->capacity ? (self)->capacity * 2 : 8), true), \ + (self)->contents[(self)->size++] = (element)) #define array_splice(self, index, old_count, new_count, new_elements) \ array__splice((VoidArray *)(self), array__elem_size(self), index, old_count, \ @@ -80,25 +80,21 @@ static inline void array__erase(VoidArray *self, size_t element_size, self->size--; } -static inline bool array__grow(VoidArray *self, size_t element_size, +static inline void array__grow(VoidArray *self, size_t element_size, size_t new_capacity) { - if (new_capacity == 0) - return true; + if (new_capacity > self->capacity) { + void *new_contents; + if (self->contents) + new_contents = ts_realloc(self->contents, new_capacity * element_size); + else + new_contents = ts_calloc(new_capacity, element_size); - void *new_contents; - if (self->contents) - new_contents = ts_realloc(self->contents, new_capacity * element_size); - else - new_contents = ts_calloc(new_capacity, element_size); - - if (!new_contents) - return false; - self->capacity = new_capacity; - self->contents = new_contents; - return true; + self->capacity = new_capacity; + self->contents = new_contents; + } } -static inline bool array__splice(VoidArray *self, size_t element_size, +static inline void array__splice(VoidArray *self, size_t element_size, size_t index, size_t old_count, size_t new_count, void *elements) { size_t new_size = self->size + new_count - old_count; @@ -106,9 +102,7 @@ static inline bool array__splice(VoidArray *self, size_t element_size, size_t new_end = index + new_count; assert(old_end <= self->size); - if (new_size >= self->capacity) - if (!array__grow(self, element_size, new_size)) - return false; + array__grow(self, element_size, new_size); char *contents = (char *)self->contents; if (self->size > old_end) @@ -118,7 +112,6 @@ static inline bool array__splice(VoidArray *self, size_t element_size, memcpy((contents + index * element_size), elements, new_count * element_size); self->size += new_count - old_count; - return true; } static inline void array__reverse(VoidArray *self, size_t element_size) { diff --git a/src/runtime/document.c b/src/runtime/document.c index 2ccb8d6f..8e9e8c94 100644 --- a/src/runtime/document.c +++ b/src/runtime/document.c @@ -89,21 +89,19 @@ void ts_document_edit(TSDocument *self, TSInputEdit edit) { ts_tree_edit(self->tree, &edit); } -int ts_document_parse_and_get_changed_ranges(TSDocument *self, TSRange **ranges, +void ts_document_parse_and_get_changed_ranges(TSDocument *self, TSRange **ranges, size_t *range_count) { if (ranges) *ranges = NULL; if (range_count) *range_count = 0; if (!self->input.read || !self->parser.language) - return -1; + return; TSTree *reusable_tree = self->valid ? self->tree : NULL; if (reusable_tree && !reusable_tree->has_changes) - return 0; + return; TSTree *tree = parser_parse(&self->parser, self->input, reusable_tree); - if (!tree) - return -1; if (self->tree) { TSTree *old_tree = self->tree; @@ -112,9 +110,8 @@ int ts_document_parse_and_get_changed_ranges(TSDocument *self, TSRange **ranges, if (ranges && range_count) { tree_path_init(&self->parser.tree_path1, old_tree); tree_path_init(&self->parser.tree_path2, tree); - if (!tree_path_get_changes(&self->parser.tree_path1, - &self->parser.tree_path2, ranges, range_count)) - return -1; + tree_path_get_changes(&self->parser.tree_path1, &self->parser.tree_path2, + ranges, range_count); } ts_tree_release(old_tree); @@ -123,11 +120,10 @@ int ts_document_parse_and_get_changed_ranges(TSDocument *self, TSRange **ranges, self->tree = tree; self->parse_count++; self->valid = true; - return 0; } -int ts_document_parse(TSDocument *self) { - return ts_document_parse_and_get_changed_ranges(self, NULL, NULL); +void ts_document_parse(TSDocument *self) { + ts_document_parse_and_get_changed_ranges(self, NULL, NULL); } void ts_document_invalidate(TSDocument *self) { diff --git a/src/runtime/parser.c b/src/runtime/parser.c index 9bb78a7e..aedc789d 100644 --- a/src/runtime/parser.c +++ b/src/runtime/parser.c @@ -42,11 +42,6 @@ #define BOOL_STRING(value) (value ? "true" : "false") -#define CHECK(expr) \ - if (!(expr)) { \ - goto error; \ - } - typedef struct { Parser *parser; TSSymbol lookahead_symbol; @@ -59,42 +54,22 @@ typedef struct { } ErrorRepairSession; typedef struct { - enum { - ReduceFailed, - ReduceSucceeded, - ReduceStoppedAtError, - } status; - + bool stopped_at_error; StackSlice slice; } Reduction; -typedef enum { - RepairFailed, - RepairSucceeded, - RepairNoneFound, -} RepairResult; - -typedef enum { - BreakdownFailed, - BreakdownPerformed, - BreakdownAborted, -} BreakdownResult; - -static bool parser__push(Parser *self, StackVersion version, TSTree *tree, +static void parser__push(Parser *self, StackVersion version, TSTree *tree, TSStateId state) { - bool result = ts_stack_push(self->stack, version, tree, false, state); + ts_stack_push(self->stack, version, tree, false, state); ts_tree_release(tree); - return result; } -static BreakdownResult parser__breakdown_top_of_stack(Parser *self, - StackVersion version) { +static bool parser__breakdown_top_of_stack(Parser *self, StackVersion version) { bool did_break_down = false; bool pending = false; do { StackPopResult pop = ts_stack_pop_pending(self->stack, version); - CHECK(pop.status); if (!pop.slices.size) break; @@ -119,12 +94,12 @@ static BreakdownResult parser__breakdown_top_of_stack(Parser *self, state = action->params.to_state; } - CHECK(ts_stack_push(self->stack, slice.version, child, pending, state)); + ts_stack_push(self->stack, slice.version, child, pending, state); } for (size_t j = 1; j < slice.trees.size; j++) { TSTree *tree = slice.trees.contents[j]; - CHECK(parser__push(self, slice.version, tree, state)); + parser__push(self, slice.version, tree, state); } LOG("breakdown_top_of_stack tree:%s", SYM_NAME(parent->symbol)); @@ -137,10 +112,7 @@ static BreakdownResult parser__breakdown_top_of_stack(Parser *self, } } while (pending); - return did_break_down ? BreakdownPerformed : BreakdownAborted; - -error: - return BreakdownFailed; + return did_break_down; } static void parser__pop_reusable_node(ReusableNode *reusable_node) { @@ -335,7 +307,7 @@ static TSTree *parser__get_lookahead(Parser *self, StackVersion version, reusable_node->tree->size.bytes); if (!parser__breakdown_reusable_node(reusable_node)) { parser__pop_reusable_node(reusable_node); - CHECK(parser__breakdown_top_of_stack(self, version)); + parser__breakdown_top_of_stack(self, version); } continue; } @@ -346,7 +318,7 @@ static TSTree *parser__get_lookahead(Parser *self, StackVersion version, reusable_node->tree->size.bytes); if (!parser__breakdown_reusable_node(reusable_node)) { parser__pop_reusable_node(reusable_node); - CHECK(parser__breakdown_top_of_stack(self, version)); + parser__breakdown_top_of_stack(self, version); } continue; } @@ -364,9 +336,6 @@ static TSTree *parser__get_lookahead(Parser *self, StackVersion version, ts_lexer_reset(&self->lexer, position); TSStateId parse_state = ts_stack_top_state(self->stack, version); return parser__lex(self, parse_state); - -error: - return NULL; } static bool parser__select_tree(Parser *self, TSTree *left, TSTree *right) { @@ -427,13 +396,13 @@ static bool parser__better_version_exists(Parser *self, StackVersion version, return false; } -static bool parser__shift(Parser *self, StackVersion version, TSStateId state, +static void parser__shift(Parser *self, StackVersion version, TSStateId state, TSTree *lookahead, bool extra) { if (extra != lookahead->extra) { TSSymbolMetadata metadata = ts_language_symbol_metadata(self->language, lookahead->symbol); if (metadata.structural && ts_stack_version_count(self->stack) > 1) { - CHECK(lookahead = ts_tree_make_copy(lookahead)); + lookahead = ts_tree_make_copy(lookahead); } else { ts_tree_retain(lookahead); } @@ -443,13 +412,8 @@ static bool parser__shift(Parser *self, StackVersion version, TSStateId state, } bool is_pending = lookahead->child_count > 0; - CHECK(ts_stack_push(self->stack, version, lookahead, is_pending, state)); + ts_stack_push(self->stack, version, lookahead, is_pending, state); ts_tree_release(lookahead); - return true; - -error: - ts_tree_release(lookahead); - return false; } static bool parser__switch_children(Parser *self, TSTree *tree, @@ -476,13 +440,8 @@ static Reduction parser__reduce(Parser *self, StackVersion version, bool allow_skipping) { size_t initial_version_count = ts_stack_version_count(self->stack); StackPopResult pop = ts_stack_pop_count(self->stack, version, count); - switch (pop.status) { - case StackPopFailed: - goto error; - case StackPopStoppedAtError: - return (Reduction){ ReduceStoppedAtError, pop.slices.contents[0] }; - default: - break; + if (pop.stopped_at_error) { + return (Reduction){ true, pop.slices.contents[0] }; } const TSLanguage *language = self->language; @@ -497,10 +456,6 @@ static Reduction parser__reduce(Parser *self, StackVersion version, TSTree *parent = ts_tree_make_node(symbol, child_count, slice.trees.contents, metadata); - if (!parent) { - ts_tree_array_delete(&slice.trees); - goto error; - } while (i + 1 < pop.slices.size) { StackSlice next_slice = pop.slices.contents[i + 1]; @@ -540,14 +495,11 @@ static Reduction parser__reduce(Parser *self, StackVersion version, allow_skipping) { StackVersion other_version = ts_stack_duplicate_version(self->stack, slice.version); - CHECK(other_version != STACK_VERSION_NONE); - CHECK( - ts_stack_push(self->stack, other_version, parent, false, ERROR_STATE)); + ts_stack_push(self->stack, other_version, parent, false, ERROR_STATE); for (size_t j = parent->child_count; j < slice.trees.size; j++) { TSTree *tree = slice.trees.contents[j]; - CHECK( - ts_stack_push(self->stack, other_version, tree, false, ERROR_STATE)); + ts_stack_push(self->stack, other_version, tree, false, ERROR_STATE); } ErrorStatus error_status = @@ -556,10 +508,10 @@ static Reduction parser__reduce(Parser *self, StackVersion version, ts_stack_remove_version(self->stack, other_version); } - CHECK(parser__push(self, slice.version, parent, action->params.to_state)); + parser__push(self, slice.version, parent, action->params.to_state); for (size_t j = parent->child_count; j < slice.trees.size; j++) { TSTree *tree = slice.trees.contents[j]; - CHECK(parser__push(self, slice.version, tree, action->params.to_state)); + parser__push(self, slice.version, tree, action->params.to_state); } } @@ -573,10 +525,7 @@ static Reduction parser__reduce(Parser *self, StackVersion version, } } - return (Reduction){ ReduceSucceeded, pop.slices.contents[0] }; - -error: - return (Reduction){ ReduceFailed, {} }; + return (Reduction){ false, pop.slices.contents[0] }; } static inline const TSParseAction *parser__reductions_after_sequence( @@ -698,7 +647,7 @@ static StackIterateAction parser__error_repair_callback( return result; } -static RepairResult parser__repair_error(Parser *self, StackSlice slice, +static bool parser__repair_error(Parser *self, StackSlice slice, TSSymbol lookahead_symbol, const TSParseAction *actions, size_t action_count) { @@ -719,21 +668,18 @@ static RepairResult parser__repair_error(Parser *self, StackSlice slice, if ((child_count > session.tree_count_above_error) || (child_count == session.tree_count_above_error && !ts_language_symbol_metadata(self->language, symbol).visible)) - CHECK(array_push( - &self->reduce_actions, - ((ReduceAction){.symbol = symbol, .count = child_count }))); + array_push(&self->reduce_actions, ((ReduceAction){symbol, child_count })); } } StackPopResult pop = ts_stack_iterate( self->stack, slice.version, parser__error_repair_callback, &session); - CHECK(pop.status); if (!session.found_repair) { LOG("no_repair_found"); ts_stack_remove_version(self->stack, slice.version); ts_tree_array_delete(&slice.trees); - return RepairNoneFound; + return false; } ReduceAction repair = session.best_repair; @@ -754,12 +700,11 @@ static RepairResult parser__repair_error(Parser *self, StackSlice slice, } TreeArray skipped_children = array_new(); - CHECK(array_grow(&skipped_children, skip_count)); + array_grow(&skipped_children, skip_count); for (size_t i = count_below; i < children.size; i++) array_push(&skipped_children, children.contents[i]); TSTree *error = ts_tree_make_error_node(&skipped_children); - CHECK(error); children.size = count_below; array_push(&children, error); @@ -770,24 +715,19 @@ static RepairResult parser__repair_error(Parser *self, StackSlice slice, TSTree *parent = ts_tree_make_node(symbol, children.size, children.contents, ts_language_symbol_metadata(self->language, symbol)); - CHECK(parent); - CHECK(parser__push(self, slice.version, parent, next_state)); + parser__push(self, slice.version, parent, next_state); ts_stack_decrease_push_count(self->stack, slice.version, error->child_count); ErrorStatus error_status = ts_stack_error_status(self->stack, slice.version); if (parser__better_version_exists(self, slice.version, error_status)) { LOG("no_better_repair_found"); ts_stack_halt(self->stack, slice.version); - return RepairNoneFound; + return false; } else { LOG("repair_found sym:%s, child_count:%lu, cost:%u", SYM_NAME(symbol), repair.count, parent->error_cost); - return RepairSucceeded; + return true; } - -error: - ts_tree_array_delete(&slice.trees); - return RepairFailed; } static void parser__start(Parser *self, TSInput input, TSTree *previous_tree) { @@ -804,14 +744,12 @@ static void parser__start(Parser *self, TSInput input, TSTree *previous_tree) { self->finished_tree = NULL; } -static bool parser__accept(Parser *self, StackVersion version, +static void parser__accept(Parser *self, StackVersion version, TSTree *lookahead) { lookahead->extra = true; assert(lookahead->symbol == ts_builtin_sym_end); - CHECK(ts_stack_push(self->stack, version, lookahead, false, 1)); + ts_stack_push(self->stack, version, lookahead, false, 1); StackPopResult pop = ts_stack_pop_all(self->stack, version); - CHECK(pop.status); - CHECK(pop.slices.size); for (size_t i = 0; i < pop.slices.size; i++) { StackSlice slice = pop.slices.contents[i]; @@ -825,11 +763,11 @@ static bool parser__accept(Parser *self, StackVersion version, for (size_t j = trees.size - 1; j + 1 > 0; j--) { TSTree *child = trees.contents[j]; if (!child->extra) { - CHECK(root = ts_tree_make_copy(child)); + root = ts_tree_make_copy(child); root->child_count = 0; for (size_t k = 0; k < child->child_count; k++) ts_tree_retain(child->children[k]); - CHECK(array_splice(&trees, j, 1, child->child_count, child->children)); + array_splice(&trees, j, 1, child->child_count, child->children); ts_tree_set_children(root, trees.size, trees.contents); ts_tree_release(child); break; @@ -848,22 +786,9 @@ static bool parser__accept(Parser *self, StackVersion version, ts_stack_remove_version(self->stack, pop.slices.contents[0].version); ts_stack_halt(self->stack, version); - - return true; - -error: - for (size_t i = 0; i < pop.slices.size; i++) - ts_tree_array_delete(&pop.slices.contents[i].trees); - return false; } -typedef enum { - PotentialReductionsFailed, - PotentialReductionsContinue, - PotentialReductionsDone, -} PotentialReductionStatus; - -static PotentialReductionStatus parser__do_potential_reductions( +static bool parser__do_potential_reductions( Parser *self, StackVersion version) { bool has_shift_action = false; TSStateId state = ts_stack_top_state(self->stack, version); @@ -884,11 +809,10 @@ static PotentialReductionStatus parser__do_potential_reductions( break; case TSParseActionTypeReduce: if (action.params.child_count > 0) - CHECK(ts_reduce_action_set_add( - &self->reduce_actions, - (ReduceAction){ - .symbol = action.params.symbol, .count = action.params.child_count, - })); + ts_reduce_action_set_add(&self->reduce_actions, (ReduceAction){ + .symbol = action.params.symbol, + .count = action.params.child_count, + }); default: break; } @@ -900,32 +824,25 @@ static PotentialReductionStatus parser__do_potential_reductions( ReduceAction action = self->reduce_actions.contents[i]; Reduction reduction = parser__reduce(self, version, action.symbol, action.count, true, false); - switch (reduction.status) { - case ReduceFailed: - goto error; - case ReduceStoppedAtError: - ts_tree_array_delete(&reduction.slice.trees); - ts_stack_remove_version(self->stack, reduction.slice.version); - continue; - default: - did_reduce = true; - break; + if (reduction.stopped_at_error) { + ts_tree_array_delete(&reduction.slice.trees); + ts_stack_remove_version(self->stack, reduction.slice.version); + continue; + } else { + did_reduce = true; } } if (did_reduce) { if (has_shift_action) { - return PotentialReductionsDone; + return true; } else { ts_stack_renumber_version(self->stack, previous_version_count, version); - return PotentialReductionsContinue; + return false; } } else { - return PotentialReductionsDone; + return true; } - -error: - return PotentialReductionsFailed; } typedef struct { @@ -949,12 +866,11 @@ static StackIterateAction parser__repair_consumed_error_callback( return StackIterateNone; } -static bool parser__repair_consumed_error(Parser *self, StackVersion version, +static void parser__repair_consumed_error(Parser *self, StackVersion version, TSSymbol lookahead_symbol) { SkipPrecedingTokensSession session = { self, lookahead_symbol }; StackPopResult pop = ts_stack_iterate( self->stack, version, parser__repair_consumed_error_callback, &session); - CHECK(pop.status); StackVersion last_slice_version = STACK_VERSION_NONE; for (size_t i = 0; i < pop.slices.size; i++) { @@ -966,96 +882,73 @@ static bool parser__repair_consumed_error(Parser *self, StackVersion version, last_slice_version = slice.version; TSTree *error = ts_tree_make_error_node(&slice.trees); - CHECK(error); error->extra = true; TSStateId state = ts_stack_top_state(self->stack, slice.version); parser__push(self, slice.version, error, state); } - - return true; -error: - return false; } -static bool parser__handle_error(Parser *self, StackVersion version, +static void parser__handle_error(Parser *self, StackVersion version, TSSymbol lookahead_symbol) { ErrorStatus error_status = ts_stack_error_status(self->stack, version); error_status.count++; if (parser__better_version_exists(self, version, error_status)) { ts_stack_halt(self->stack, version); LOG("bail_on_error"); - return true; + return; } LOG("handle_error"); - CHECK(parser__repair_consumed_error(self, version, lookahead_symbol)); + parser__repair_consumed_error(self, version, lookahead_symbol); size_t previous_version_count = ts_stack_version_count(self->stack); for (StackVersion v = version; v < ts_stack_version_count(self->stack);) { - switch (parser__do_potential_reductions(self, v)) { - case PotentialReductionsFailed: - goto error; - case PotentialReductionsContinue: - break; - case PotentialReductionsDone: - if (v == version) { - v = previous_version_count; - } else { - v++; - } - break; + if (parser__do_potential_reductions(self, v)) { + if (v == version) { + v = previous_version_count; + } else { + v++; + } } } - CHECK(ts_stack_push(self->stack, version, NULL, false, ERROR_STATE)); + ts_stack_push(self->stack, version, NULL, false, ERROR_STATE); while (ts_stack_version_count(self->stack) > previous_version_count) { - CHECK(ts_stack_push(self->stack, previous_version_count, NULL, false, - ERROR_STATE)); + ts_stack_push(self->stack, previous_version_count, NULL, false, ERROR_STATE); assert(ts_stack_merge(self->stack, version, previous_version_count)); } - - return true; - -error: - return false; } -static bool parser__recover(Parser *self, StackVersion version, TSStateId state, +static void parser__recover(Parser *self, StackVersion version, TSStateId state, TSTree *lookahead) { if (lookahead->symbol == ts_builtin_sym_end) { LOG("recover_eof"); TreeArray children = array_new(); TSTree *parent = ts_tree_make_error_node(&children); - CHECK(parser__push(self, version, parent, 1)); - return parser__accept(self, version, lookahead); + parser__push(self, version, parent, 1); + parser__accept(self, version, lookahead); } LOG("recover state:%u", state); StackVersion new_version = ts_stack_duplicate_version(self->stack, version); - CHECK(new_version != STACK_VERSION_NONE); - CHECK(parser__shift( + parser__shift( self, new_version, ERROR_STATE, lookahead, - ts_language_symbol_metadata(self->language, lookahead->symbol).extra)); + ts_language_symbol_metadata(self->language, lookahead->symbol).extra); ErrorStatus error_status = ts_stack_error_status(self->stack, new_version); if (parser__better_version_exists(self, version, error_status)) { ts_stack_remove_version(self->stack, new_version); LOG("bail_on_recovery"); } - CHECK(parser__shift(self, version, state, lookahead, false)); - return true; - -error: - return false; + parser__shift(self, version, state, lookahead, false); } -static bool parser__advance(Parser *self, StackVersion version, +static void parser__advance(Parser *self, StackVersion version, ReusableNode *reusable_node) { bool validated_lookahead = false; TSTree *lookahead = parser__get_lookahead(self, version, reusable_node); - CHECK(lookahead); for (;;) { TSStateId state = ts_stack_top_state(self->stack, version); @@ -1073,7 +966,6 @@ static bool parser__advance(Parser *self, StackVersion version, ts_tree_release(lookahead); lookahead = parser__get_lookahead(self, version, reusable_node); - CHECK(lookahead); continue; } @@ -1097,7 +989,6 @@ static bool parser__advance(Parser *self, StackVersion version, parser__pop_reusable_node(reusable_node); ts_tree_release(lookahead); lookahead = parser__get_lookahead(self, version, reusable_node); - CHECK(lookahead); } } @@ -1114,14 +1005,13 @@ static bool parser__advance(Parser *self, StackVersion version, LOG("shift state:%u", next_state); } - CHECK( - parser__shift(self, version, next_state, lookahead, action.extra)); + parser__shift(self, version, next_state, lookahead, action.extra); if (lookahead == reusable_node->tree) parser__pop_reusable_node(reusable_node); ts_tree_release(lookahead); - return true; + return; } case TSParseActionTypeReduce: { @@ -1135,28 +1025,17 @@ static bool parser__advance(Parser *self, StackVersion version, parser__reduce(self, version, action.params.symbol, action.params.child_count, (i < table_entry.action_count - 1), true); - switch (reduction.status) { - case ReduceFailed: - goto error; - case ReduceSucceeded: + if (reduction.stopped_at_error) { + reduction_stopped_at_error = true; + if (parser__repair_error( + self, reduction.slice, lookahead->first_leaf.symbol, + table_entry.actions, table_entry.action_count)) { last_reduction_version = reduction.slice.version; - break; - case ReduceStoppedAtError: { - reduction_stopped_at_error = true; - switch (parser__repair_error( - self, reduction.slice, lookahead->first_leaf.symbol, - table_entry.actions, table_entry.action_count)) { - case RepairFailed: - goto error; - case RepairNoneFound: - break; - case RepairSucceeded: - last_reduction_version = reduction.slice.version; - break; - } - break; } + } else { + last_reduction_version = reduction.slice.version; } + break; } @@ -1165,10 +1044,10 @@ static bool parser__advance(Parser *self, StackVersion version, continue; LOG("accept"); - CHECK(parser__accept(self, version, lookahead)); + parser__accept(self, version, lookahead); ts_tree_release(lookahead); - return true; + return; } case TSParseActionTypeRecover: { @@ -1181,13 +1060,13 @@ static bool parser__advance(Parser *self, StackVersion version, action = *ts_language_last_action(self->language, state, lookahead->symbol); - CHECK(parser__recover(self, version, action.params.to_state, lookahead)); + parser__recover(self, version, action.params.to_state, lookahead); if (lookahead == reusable_node->tree) parser__pop_reusable_node(reusable_node); ts_tree_release(lookahead); - return true; + return; } } } @@ -1198,58 +1077,33 @@ static bool parser__advance(Parser *self, StackVersion version, continue; } - switch (parser__breakdown_top_of_stack(self, version)) { - case BreakdownFailed: - goto error; - case BreakdownPerformed: - continue; - case BreakdownAborted: - break; + if (parser__breakdown_top_of_stack(self, version)) { + continue; } if (state == ERROR_STATE) { - return parser__push(self, version, lookahead, ERROR_STATE); + parser__push(self, version, lookahead, ERROR_STATE); + return; } - CHECK(parser__handle_error(self, version, lookahead->symbol)); + parser__handle_error(self, version, lookahead->symbol); if (ts_stack_is_halted(self->stack, version)) { ts_tree_release(lookahead); - return true; + return; } } - -error: - if (lookahead) - ts_tree_release(lookahead); - return false; } bool parser_init(Parser *self) { ts_lexer_init(&self->lexer); - self->finished_tree = NULL; - self->stack = NULL; array_init(&self->reduce_actions); array_init(&self->tree_path1); array_init(&self->tree_path2); - + array_grow(&self->reduce_actions, 4); self->stack = ts_stack_new(); - if (!self->stack) - goto error; - - if (!array_grow(&self->reduce_actions, 4)) - goto error; - + self->finished_tree = NULL; return true; - -error: - if (self->stack) { - ts_stack_delete(self->stack); - self->stack = NULL; - } - if (self->reduce_actions.contents) - array_delete(&self->reduce_actions); - return false; } void parser_destroy(Parser *self) { @@ -1287,7 +1141,7 @@ TSTree *parser_parse(Parser *self, TSInput input, TSTree *old_tree) { ts_stack_top_position(self->stack, version).extent.row + 1, ts_stack_top_position(self->stack, version).extent.column + 1); - CHECK(parser__advance(self, version, &reusable_node)); + parser__advance(self, version, &reusable_node); LOG_STACK(); } } @@ -1306,9 +1160,6 @@ TSTree *parser_parse(Parser *self, TSInput input, TSTree *old_tree) { LOG_TREE(); ts_stack_clear(self->stack); parser__clear_cached_token(self); - CHECK(ts_tree_assign_parents(self->finished_tree, &self->tree_path1)); + ts_tree_assign_parents(self->finished_tree, &self->tree_path1); return self->finished_tree; - -error: - return NULL; } diff --git a/src/runtime/reduce_action.h b/src/runtime/reduce_action.h index 3b8841e5..d48a1c15 100644 --- a/src/runtime/reduce_action.h +++ b/src/runtime/reduce_action.h @@ -15,14 +15,14 @@ typedef struct { typedef Array(ReduceAction) ReduceActionSet; -static inline bool ts_reduce_action_set_add(ReduceActionSet *self, +static inline void ts_reduce_action_set_add(ReduceActionSet *self, ReduceAction new_action) { for (size_t i = 0; i < self->size; i++) { ReduceAction action = self->contents[i]; if (action.symbol == new_action.symbol && action.count == new_action.count) - return true; + return; } - return array_push(self, new_action); + array_push(self, new_action); } #ifdef __cplusplus diff --git a/src/runtime/stack.c b/src/runtime/stack.c index c1863a47..fccffdde 100644 --- a/src/runtime/stack.c +++ b/src/runtime/stack.c @@ -167,29 +167,29 @@ static void stack_node_add_link(StackNode *self, StackLink link) { static StackVersion ts_stack__add_version(Stack *self, StackNode *node, unsigned push_count) { StackHead head = { - .node = node, .is_halted = false, .push_count = push_count, + .node = node, + .is_halted = false, + .push_count = push_count, }; - if (!array_push(&self->heads, head)) - return STACK_VERSION_NONE; + array_push(&self->heads, head); stack_node_retain(node); return (StackVersion)(self->heads.size - 1); } -static bool ts_stack__add_slice(Stack *self, StackNode *node, TreeArray *trees, +static void ts_stack__add_slice(Stack *self, StackNode *node, TreeArray *trees, unsigned push_count) { for (size_t i = self->slices.size - 1; i + 1 > 0; i--) { StackVersion version = self->slices.contents[i].version; if (self->heads.contents[version].node == node) { StackSlice slice = { *trees, version }; - return array_insert(&self->slices, i + 1, slice); + array_insert(&self->slices, i + 1, slice); + return; } } StackVersion version = ts_stack__add_version(self, node, push_count); - if (version == STACK_VERSION_NONE) - return false; StackSlice slice = { *trees, version }; - return array_push(&self->slices, slice); + array_push(&self->slices, slice); } INLINE StackPopResult stack__iter(Stack *self, StackVersion version, @@ -206,8 +206,7 @@ INLINE StackPopResult stack__iter(Stack *self, StackVersion version, .is_pending = true, .push_count = 0, }; - if (!array_push(&self->iterators, iterator)) - goto error; + array_push(&self->iterators, iterator); while (self->iterators.size > 0) { for (size_t i = 0, size = self->iterators.size; i < size; i++) { @@ -225,12 +224,9 @@ INLINE StackPopResult stack__iter(Stack *self, StackVersion version, if (should_pop) { TreeArray trees = iterator->trees; if (!should_stop) - if (!ts_tree_array_copy(trees, &trees)) - goto error; + ts_tree_array_copy(trees, &trees); array_reverse(&trees); - if (!ts_stack__add_slice(self, node, &trees, - push_count + iterator->push_count)) - goto error; + ts_stack__add_slice(self, node, &trees, push_count + iterator->push_count); } if (should_stop) { @@ -249,11 +245,9 @@ INLINE StackPopResult stack__iter(Stack *self, StackVersion version, next_iterator = &self->iterators.contents[i]; } else { link = node->links[j]; - if (!array_push(&self->iterators, self->iterators.contents[i])) - goto error; + array_push(&self->iterators, self->iterators.contents[i]); next_iterator = array_back(&self->iterators); - if (!ts_tree_array_copy(next_iterator->trees, &next_iterator->trees)) - goto error; + ts_tree_array_copy(next_iterator->trees, &next_iterator->trees); } next_iterator->node = link.node; @@ -264,8 +258,7 @@ INLINE StackPopResult stack__iter(Stack *self, StackVersion version, if (!link.is_pending) next_iterator->is_pending = false; } - if (!array_push(&next_iterator->trees, link.tree)) - goto error; + array_push(&next_iterator->trees, link.tree); ts_tree_retain(link.tree); } else { next_iterator->is_pending = false; @@ -274,60 +267,27 @@ INLINE StackPopResult stack__iter(Stack *self, StackVersion version, } } - return (StackPopResult){ StackPopSucceeded, self->slices }; - -error: - for (size_t i = 0; i < self->iterators.size; i++) - ts_tree_array_delete(&self->iterators.contents[i].trees); - array_clear(&self->slices); - return (StackPopResult){.status = StackPopFailed }; + return (StackPopResult){ false, self->slices }; } Stack *ts_stack_new() { Stack *self = ts_calloc(1, sizeof(Stack)); - if (!self) - goto error; array_init(&self->heads); array_init(&self->slices); array_init(&self->iterators); array_init(&self->node_pool); - - if (!array_grow(&self->heads, 4)) - goto error; - - if (!array_grow(&self->slices, 4)) - goto error; - - if (!array_grow(&self->iterators, 4)) - goto error; - - if (!array_grow(&self->node_pool, MAX_NODE_POOL_SIZE)) - goto error; + array_grow(&self->heads, 4); + array_grow(&self->slices, 4); + array_grow(&self->iterators, 4); + array_grow(&self->node_pool, MAX_NODE_POOL_SIZE); self->base_node = stack_node_new(NULL, NULL, false, 1, ts_length_zero(), &self->node_pool); stack_node_retain(self->base_node); - if (!self->base_node) - goto error; - array_push(&self->heads, ((StackHead){ self->base_node, false, 0 })); return self; - -error: - if (self) { - if (self->heads.contents) - array_delete(&self->heads); - if (self->slices.contents) - array_delete(&self->slices); - if (self->iterators.contents) - array_delete(&self->iterators); - if (self->node_pool.contents) - array_delete(&self->node_pool); - ts_free(self); - } - return NULL; } void ts_stack_delete(Stack *self) { @@ -436,7 +396,7 @@ StackPopResult ts_stack_pop_count(Stack *self, StackVersion version, .goal_tree_count = count, .found_error = false, .found_valid_path = false, }; StackPopResult pop = stack__iter(self, version, pop_count_callback, &session); - if (pop.status && session.found_error) { + if (session.found_error) { if (session.found_valid_path) { StackSlice error_slice = pop.slices.contents[0]; ts_tree_array_delete(&error_slice.trees); @@ -447,7 +407,7 @@ StackPopResult ts_stack_pop_count(Stack *self, StackVersion version, pop.slices.contents[i].version--; } } else { - pop.status = StackPopStoppedAtError; + pop.stopped_at_error = true; } } return pop; @@ -503,8 +463,7 @@ void ts_stack_renumber_version(Stack *self, StackVersion v1, StackVersion v2) { StackVersion ts_stack_duplicate_version(Stack *self, StackVersion version) { assert(version < self->heads.size); - if (!array_push(&self->heads, self->heads.contents[version])) - return STACK_VERSION_NONE; + array_push(&self->heads, self->heads.contents[version]); stack_node_retain(array_back(&self->heads)->node); return self->heads.size - 1; } @@ -568,8 +527,7 @@ bool ts_stack_print_dot_graph(Stack *self, const char **symbol_names, FILE *f) { "node_head_%lu -> node_%p [label=%lu, fontcolor=blue, weight=10000, " "labeltooltip=\"push_count: %u\"]\n", i, head->node, i, head->push_count); - if (!array_push(&self->iterators, ((Iterator){.node = head->node }))) - goto error; + array_push(&self->iterators, ((Iterator){.node = head->node })); } bool all_iterators_done = false; @@ -638,8 +596,7 @@ bool ts_stack_print_dot_graph(Stack *self, const char **symbol_names, FILE *f) { if (j == 0) { iterator->node = link.node; } else { - if (!array_push(&self->iterators, *iterator)) - goto error; + array_push(&self->iterators, *iterator); Iterator *next_iterator = array_back(&self->iterators); next_iterator->node = link.node; } diff --git a/src/runtime/stack.h b/src/runtime/stack.h index 881f0ea7..1996662d 100644 --- a/src/runtime/stack.h +++ b/src/runtime/stack.h @@ -24,11 +24,7 @@ typedef struct { typedef Array(StackSlice) StackSliceArray; typedef struct { - enum { - StackPopFailed, - StackPopStoppedAtError, - StackPopSucceeded, - } status; + bool stopped_at_error; StackSliceArray slices; } StackPopResult; diff --git a/src/runtime/tree.c b/src/runtime/tree.c index 2f0760c6..26635130 100644 --- a/src/runtime/tree.c +++ b/src/runtime/tree.c @@ -13,9 +13,6 @@ TSStateId TS_TREE_STATE_NONE = USHRT_MAX; TSTree *ts_tree_make_leaf(TSSymbol sym, TSLength padding, TSLength size, TSSymbolMetadata metadata) { TSTree *result = ts_malloc(sizeof(TSTree)); - if (!result) - return NULL; - *result = (TSTree){ .ref_count = 1, .symbol = sym, @@ -30,7 +27,6 @@ TSTree *ts_tree_make_leaf(TSSymbol sym, TSLength padding, TSLength size, .first_leaf.symbol = sym, .has_changes = false, }; - return result; } @@ -38,8 +34,6 @@ bool ts_tree_array_copy(TreeArray self, TreeArray *dest) { TSTree **contents = NULL; if (self.capacity > 0) { contents = ts_calloc(self.capacity, sizeof(TSTree *)); - if (!contents) - return false; memcpy(contents, self.contents, self.size * sizeof(TSTree *)); for (size_t i = 0; i < self.size; i++) ts_tree_retain(contents[i]); @@ -72,9 +66,6 @@ TSTree *ts_tree_make_error(TSLength size, TSLength padding, char lookahead_char) (TSSymbolMetadata){ .visible = true, .named = true, }); - if (!result) - return NULL; - result->fragile_left = true; result->fragile_right = true; result->lookahead_char = lookahead_char; @@ -83,18 +74,14 @@ TSTree *ts_tree_make_error(TSLength size, TSLength padding, char lookahead_char) TSTree *ts_tree_make_copy(TSTree *self) { TSTree *result = ts_malloc(sizeof(TSTree)); - if (!result) - return NULL; - *result = *self; result->ref_count = 1; return result; } -bool ts_tree_assign_parents(TSTree *self, TreePath *path) { +void ts_tree_assign_parents(TSTree *self, TreePath *path) { array_clear(path); - if (!array_push(path, ((TreePathEntry){self, ts_length_zero(), 0}))) - return false; + array_push(path, ((TreePathEntry){self, ts_length_zero(), 0})); while (path->size > 0) { TSTree *tree = array_pop(path).tree; TSLength offset = ts_length_zero(); @@ -104,13 +91,11 @@ bool ts_tree_assign_parents(TSTree *self, TreePath *path) { child->context.parent = tree; child->context.index = i; child->context.offset = offset; - if (!array_push(path, ((TreePathEntry){child, ts_length_zero(), 0}))) - return false; + array_push(path, ((TreePathEntry){child, ts_length_zero(), 0})); } offset = ts_length_add(offset, ts_tree_total_size(child)); } } - return true; } @@ -172,9 +157,6 @@ TSTree *ts_tree_make_node(TSSymbol symbol, size_t child_count, TSTree **children, TSSymbolMetadata metadata) { TSTree *result = ts_tree_make_leaf(symbol, ts_length_zero(), ts_length_zero(), metadata); - if (!result) - return NULL; - ts_tree_set_children(result, child_count, children); return result; } @@ -183,8 +165,7 @@ TSTree *ts_tree_make_error_node(TreeArray *children) { for (size_t i = 0; i < children->size; i++) { TSTree *child = children->contents[i]; if (child->symbol == ts_builtin_sym_error && child->child_count > 0) { - if (!array_splice(children, i, 1, child->child_count, child->children)) - return NULL; + array_splice(children, i, 1, child->child_count, child->children); i += child->child_count - 1; for (size_t j = 0; j < child->child_count; j++) ts_tree_retain(child->children[j]); @@ -196,9 +177,6 @@ TSTree *ts_tree_make_error_node(TreeArray *children) { ts_builtin_sym_error, children->size, children->contents, (TSSymbolMetadata){.extra = false, .visible = true, .named = true }); - if (!result) - return NULL; - result->fragile_left = true; result->fragile_right = true; return result; diff --git a/src/runtime/tree.h b/src/runtime/tree.h index a274c186..6daaa1c9 100644 --- a/src/runtime/tree.h +++ b/src/runtime/tree.h @@ -77,7 +77,7 @@ int ts_tree_compare(const TSTree *tree1, const TSTree *tree2); size_t ts_tree_start_column(const TSTree *self); size_t ts_tree_end_column(const TSTree *self); void ts_tree_set_children(TSTree *, size_t, TSTree **); -bool ts_tree_assign_parents(TSTree *, TreePath *); +void ts_tree_assign_parents(TSTree *, TreePath *); void ts_tree_edit(TSTree *, const TSInputEdit *edit); char *ts_tree_string(const TSTree *, const TSLanguage *, bool include_all); void ts_tree_print_dot_graph(const TSTree *, const TSLanguage *, FILE *); diff --git a/src/runtime/tree_path.h b/src/runtime/tree_path.h index f6bf2366..7f350bc1 100644 --- a/src/runtime/tree_path.h +++ b/src/runtime/tree_path.h @@ -6,21 +6,19 @@ typedef Array(TSRange) RangeArray; -static bool range_array_add(RangeArray *results, TSPoint start, TSPoint end) { +static void range_array_add(RangeArray *results, TSPoint start, TSPoint end) { if (results->size > 0) { TSRange *last_range = array_back(results); if (ts_point_lte(start, last_range->end)) { last_range->end = end; - return true; + return; } } if (ts_point_lt(start, end)) { TSRange range = { start, end }; - return array_push(results, range); + array_push(results, range); } - - return true; } static bool tree_path_descend(TreePath *path, TSPoint position) { @@ -109,7 +107,7 @@ static bool tree_must_eq(TSTree *old_tree, TSTree *new_tree) { ); } -static bool tree_path_get_changes(TreePath *old_path, TreePath *new_path, +static void tree_path_get_changes(TreePath *old_path, TreePath *new_path, TSRange **ranges, size_t *range_count) { TSPoint position = { 0, 0 }; RangeArray results = array_new(); @@ -195,7 +193,6 @@ static bool tree_path_get_changes(TreePath *old_path, TreePath *new_path, *ranges = results.contents; *range_count = results.size; - return true; } #endif // RUNTIME_TREE_PATH_H_