willbooster-tree-sitter 7.0.20

WillBooster's fork of the Tree-sitter parsing library, with Rust bindings
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

#include "./subtree.h"

typedef enum {
  ExtraLookaheadUnknown,
  ExtraLookaheadSyntax,
  ExtraLookaheadUnstable,
  ExtraLookaheadEnd,
  ExtraLookaheadTrailing,
} ExtraLookahead;

typedef struct {
  Subtree tree;
  uint32_t child_index;
  uint32_t byte_offset;
  ExtraLookahead extra_lookahead;
} StackEntry;

typedef struct {
  Array(StackEntry) stack;
  Subtree last_external_token;
  bool after_extra;
} ReusableNode;

static inline ReusableNode reusable_node_new(void) {
  return (ReusableNode) {.stack = array_new(), .last_external_token = NULL_SUBTREE};
}

static inline void reusable_node_clear(ReusableNode *self) {
  array_clear(&self->stack);
  self->last_external_token = NULL_SUBTREE;
  self->after_extra = false;
}

static inline Subtree reusable_node_tree(ReusableNode *self) {
  return self->stack.size > 0
    ? self->stack.contents[self->stack.size - 1].tree
    : NULL_SUBTREE;
}

static inline uint32_t reusable_node_byte_offset(ReusableNode *self) {
  return self->stack.size > 0
    ? self->stack.contents[self->stack.size - 1].byte_offset
    : UINT32_MAX;
}

static inline ExtraLookahead reusable_node_extra_lookahead(StackEntry parent, uint32_t child_index);

static inline bool reusable_node_precedes_unstable_extra(ReusableNode *self) {
  uint32_t first = self->stack.size - 1;
  while (self->stack.contents[first].extra_lookahead == ExtraLookaheadUnknown) first--;
  for (uint32_t i = first + 1; i < self->stack.size; i++) {
    StackEntry *entry = &self->stack.contents[i];
    entry->extra_lookahead = reusable_node_extra_lookahead(self->stack.contents[i - 1], entry->child_index);
  }
  ExtraLookahead result = array_back(&self->stack)->extra_lookahead;
  return result == ExtraLookaheadUnstable || result == ExtraLookaheadTrailing;
}

static inline ExtraLookahead reusable_node_extra_lookahead(StackEntry parent, uint32_t child_index) {
  ExtraLookahead result = parent.extra_lookahead;
  for (uint32_t next_index = child_index + 1; next_index < ts_subtree_child_count(parent.tree); next_index++) {
    Subtree next = ts_subtree_children(parent.tree)[next_index];
    if (!ts_subtree_extra(next)) return ExtraLookaheadSyntax;
    if (ts_subtree_child_count(next) == 0) continue;
    if (ts_subtree_has_changes(next) || ts_subtree_is_fragile(next) || ts_subtree_error_cost(next) > 0) {
      return ExtraLookaheadUnstable;
    }
    if (result == ExtraLookaheadEnd) result = ExtraLookaheadTrailing;
  }
  return result;
}

static inline void reusable_node_delete(ReusableNode *self) {
  array_delete(&self->stack);
}

static inline void reusable_node_advance(ReusableNode *self) {
  StackEntry last_entry = *array_back(&self->stack);
  uint32_t byte_offset = last_entry.byte_offset + ts_subtree_total_bytes(last_entry.tree);
  if (ts_subtree_has_external_tokens(last_entry.tree)) {
    self->last_external_token = ts_subtree_last_external_token(last_entry.tree);
  }

  Subtree tree;
  uint32_t next_index;
  do {
    StackEntry popped_entry = array_pop(&self->stack);
    if (ts_subtree_total_bytes(popped_entry.tree) || ts_subtree_has_external_tokens(popped_entry.tree) || ts_subtree_extra(popped_entry.tree)) {
      self->after_extra = ts_subtree_trailing_extra(popped_entry.tree);
    }
    next_index = popped_entry.child_index + 1;
    if (self->stack.size == 0) return;
    tree = array_back(&self->stack)->tree;
  } while (ts_subtree_child_count(tree) <= next_index);

  array_push(&self->stack, ((StackEntry) {
    .tree = ts_subtree_children(tree)[next_index],
    .child_index = next_index,
    .byte_offset = byte_offset,
  }));
}

static inline bool reusable_node_descend(ReusableNode *self) {
  StackEntry last_entry = *array_back(&self->stack);
  if (ts_subtree_child_count(last_entry.tree) > 0) {
    array_push(&self->stack, ((StackEntry) {
      .tree = ts_subtree_children(last_entry.tree)[0],
      .child_index = 0,
      .byte_offset = last_entry.byte_offset,
    }));
    return true;
  } else {
    return false;
  }
}

static inline void reusable_node_advance_past_leaf(ReusableNode *self) {
  while (reusable_node_descend(self)) {}
  reusable_node_advance(self);
}

static inline void reusable_node_reset(ReusableNode *self, Subtree tree) {
  reusable_node_clear(self);
  if (ts_subtree_is_error(tree) || ts_subtree_error_cost(tree)) return;
  array_push(&self->stack, ((StackEntry) {
    .tree = tree,
    .child_index = 0,
    .byte_offset = 0,
    .extra_lookahead = ExtraLookaheadEnd,
  }));

  // Never reuse the root node, because it has a non-standard internal structure
  // due to transformations that are applied when it is accepted: adding the EOF
  // child and any extra children.
  if (!reusable_node_descend(self)) {
    reusable_node_clear(self);
  }
}