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

fix(lib): replace raw array accesses with array_get

Browse source 
(cherry picked from commit 8bd923ab9e)
This commit is contained in:
Will Lillis 2025-05-04 00:12:07 -04:00 • committed by Amaan Qureshi
parent bf655c0bea
commit b890e8bea0
7 changed files with 229 additions and 227 deletions
Download patch file Download diff file Expand all files Collapse all files

50
lib/src/parser.c
View file

@ -193,7 +193,7 @@ static bool ts_parser__breakdown_top_of_stack(
did_break_down = true;
pending = false;
for (uint32_t i = 0; i < pop.size; i++) {
StackSlice slice = pop.contents[i];
StackSlice slice = *array_get(&pop, i);
TSStateId state = ts_stack_state(self->stack, slice.version);
Subtree parent = *array_front(&slice.subtrees);
@ -212,7 +212,7 @@ static bool ts_parser__breakdown_top_of_stack(
}
for (uint32_t j = 1; j < slice.subtrees.size; j++) {
Subtree tree = slice.subtrees.contents[j];
Subtree tree = *array_get(&slice.subtrees, j);
ts_stack_push(self->stack, slice.version, tree, false, state);
}
@ -951,7 +951,7 @@ static StackVersion ts_parser__reduce(
uint32_t removed_version_count = 0;
uint32_t halted_version_count = ts_stack_halted_version_count(self->stack);
for (uint32_t i = 0; i < pop.size; i++) {
StackSlice slice = pop.contents[i];
StackSlice slice = *array_get(&pop, i);
StackVersion slice_version = slice.version - removed_version_count;
// This is where new versions are added to the parse stack. The versions
@ -964,7 +964,7 @@ static StackVersion ts_parser__reduce(
removed_version_count++;
while (i + 1 < pop.size) {
LOG("aborting reduce with too many versions")
StackSlice next_slice = pop.contents[i + 1];
StackSlice next_slice = *array_get(&pop, i + 1);
if (next_slice.version != slice.version) break;
ts_subtree_array_delete(&self->tree_pool, &next_slice.subtrees);
i++;
@ -987,7 +987,7 @@ static StackVersion ts_parser__reduce(
// choose one of the arrays of trees to be the parent node's children, and
// delete the rest of the tree arrays.
while (i + 1 < pop.size) {
StackSlice next_slice = pop.contents[i + 1];
StackSlice next_slice = *array_get(&pop, i + 1);
if (next_slice.version != slice.version) break;
i++;
@ -1029,7 +1029,7 @@ static StackVersion ts_parser__reduce(
// were previously on top of the stack.
ts_stack_push(self->stack, slice_version, ts_subtree_from_mut(parent), false, next_state);
for (uint32_t j = 0; j < self->trailing_extras.size; j++) {
ts_stack_push(self->stack, slice_version, self->trailing_extras.contents[j], false, next_state);
ts_stack_push(self->stack, slice_version, *array_get(&self->trailing_extras, j), false, next_state);
}
for (StackVersion j = 0; j < slice_version; j++) {
@ -1057,11 +1057,11 @@ static void ts_parser__accept(
StackSliceArray pop = ts_stack_pop_all(self->stack, version);
for (uint32_t i = 0; i < pop.size; i++) {
SubtreeArray trees = pop.contents[i].subtrees;
SubtreeArray trees = array_get(&pop, i)->subtrees;
Subtree root = NULL_SUBTREE;
for (uint32_t j = trees.size - 1; j + 1 > 0; j--) {
Subtree tree = trees.contents[j];
Subtree tree = *array_get(&trees, j);
if (!ts_subtree_extra(tree)) {
ts_assert(!tree.data.is_inline);
uint32_t child_count = ts_subtree_child_count(tree);
@ -1096,7 +1096,7 @@ static void ts_parser__accept(
}
}
ts_stack_remove_version(self->stack, pop.contents[0].version);
ts_stack_remove_version(self->stack, array_get(&pop, 0)->version);
ts_stack_halt(self->stack, version);
}
@ -1162,7 +1162,7 @@ static bool ts_parser__do_all_potential_reductions(
StackVersion reduction_version = STACK_VERSION_NONE;
for (uint32_t j = 0; j < self->reduce_actions.size; j++) {
ReduceAction action = self->reduce_actions.contents[j];
ReduceAction action = *array_get(&self->reduce_actions, j);
reduction_version = ts_parser__reduce(
self, version, action.symbol, action.count,
@ -1200,7 +1200,7 @@ static bool ts_parser__recover_to_state(
StackVersion previous_version = STACK_VERSION_NONE;
for (unsigned i = 0; i < pop.size; i++) {
StackSlice slice = pop.contents[i];
StackSlice slice = *array_get(&pop, i);
if (slice.version == previous_version) {
ts_subtree_array_delete(&self->tree_pool, &slice.subtrees);
@ -1218,12 +1218,12 @@ static bool ts_parser__recover_to_state(
SubtreeArray error_trees = ts_stack_pop_error(self->stack, slice.version);
if (error_trees.size > 0) {
ts_assert(error_trees.size == 1);
Subtree error_tree = error_trees.contents[0];
Subtree error_tree = *array_get(&error_trees, 0);
uint32_t error_child_count = ts_subtree_child_count(error_tree);
if (error_child_count > 0) {
array_splice(&slice.subtrees, 0, 0, error_child_count, ts_subtree_children(error_tree));
for (unsigned j = 0; j < error_child_count; j++) {
ts_subtree_retain(slice.subtrees.contents[j]);
ts_subtree_retain(*array_get(&slice.subtrees, j));
}
}
ts_subtree_array_delete(&self->tree_pool, &error_trees);
@ -1239,7 +1239,7 @@ static bool ts_parser__recover_to_state(
}
for (unsigned j = 0; j < self->trailing_extras.size; j++) {
Subtree tree = self->trailing_extras.contents[j];
Subtree tree = *array_get(&self->trailing_extras, j);
ts_stack_push(self->stack, slice.version, tree, false, goal_state);
}
@ -1275,7 +1275,7 @@ static void ts_parser__recover(
// if the current lookahead token would be valid in that state.
if (summary && !ts_subtree_is_error(lookahead)) {
for (unsigned i = 0; i < summary->size; i++) {
StackSummaryEntry entry = summary->contents[i];
StackSummaryEntry entry = *array_get(summary, i);
if (entry.state == ERROR_STATE) continue;
if (entry.position.bytes == position.bytes) continue;
@ -1402,18 +1402,18 @@ static void ts_parser__recover(
// arbitrarily and discard the rest.
if (pop.size > 1) {
for (unsigned i = 1; i < pop.size; i++) {
ts_subtree_array_delete(&self->tree_pool, &pop.contents[i].subtrees);
ts_subtree_array_delete(&self->tree_pool, &array_get(&pop, i)->subtrees);
}
while (ts_stack_version_count(self->stack) > pop.contents[0].version + 1) {
ts_stack_remove_version(self->stack, pop.contents[0].version + 1);
while (ts_stack_version_count(self->stack) > array_get(&pop, 0)->version + 1) {
ts_stack_remove_version(self->stack, array_get(&pop, 0)->version + 1);
}
}
ts_stack_renumber_version(self->stack, pop.contents[0].version, version);
array_push(&pop.contents[0].subtrees, ts_subtree_from_mut(error_repeat));
ts_stack_renumber_version(self->stack, array_get(&pop, 0)->version, version);
array_push(&array_get(&pop, 0)->subtrees, ts_subtree_from_mut(error_repeat));
error_repeat = ts_subtree_new_node(
ts_builtin_sym_error_repeat,
&pop.contents[0].subtrees,
&array_get(&pop, 0)->subtrees,
0,
self->language
);
@ -1889,9 +1889,9 @@ static bool ts_parser__balance_subtree(TSParser *self) {
return false;
}
MutableSubtree tree = self->tree_pool.tree_stack.contents[
MutableSubtree tree = *array_get(&self->tree_pool.tree_stack,
self->tree_pool.tree_stack.size - 1
];
);
if (tree.ptr->repeat_depth > 0) {
Subtree child1 = ts_subtree_children(tree)[0];
@ -2140,7 +2140,7 @@ TSTree *ts_parser_parse(
LOG("parse_after_edit");
LOG_TREE(self->old_tree);
for (unsigned i = 0; i < self->included_range_differences.size; i++) {
TSRange *range = &self->included_range_differences.contents[i];
TSRange *range = array_get(&self->included_range_differences, i);
LOG("different_included_range %u - %u", range->start_byte, range->end_byte);
}
} else {
@ -2197,7 +2197,7 @@ TSTree *ts_parser_parse(
}
while (self->included_range_difference_index < self->included_range_differences.size) {
TSRange *range = &self->included_range_differences.contents[self->included_range_difference_index];
TSRange *range = array_get(&self->included_range_differences, self->included_range_difference_index);
if (range->end_byte <= position) {
self->included_range_difference_index++;
} else {