tree-sitter 0.0.1 → 0.1.0

data/ext/tree-sitter/tree-sitter/src/runtime/language.h

@@ -8,11 +8,12 @@ extern "C" {
 #include "tree_sitter/parser.h"
 #include "runtime/tree.h"
 
+#define ts_builtin_sym_error_repeat (ts_builtin_sym_error - 1)
+
 typedef struct {
   const TSParseAction *actions;
   uint32_t action_count;
   bool is_reusable;
-  bool depends_on_lookahead;
 } TableEntry;
 
 void ts_language_table_entry(const TSLanguage *, TSStateId, TSSymbol, TableEntry *);
@@ -33,10 +34,26 @@ static inline const TSParseAction *ts_language_actions(const TSLanguage *self,
   return entry.actions;
 }
 
+static inline bool ts_language_has_actions(const TSLanguage *self,
+                                           TSStateId state,
+                                           TSSymbol symbol) {
+  TableEntry entry;
+  ts_language_table_entry(self, state, symbol, &entry);
+  return entry.action_count > 0;
+}
+
+static inline bool ts_language_has_reduce_action(const TSLanguage *self,
+                                                 TSStateId state,
+                                                 TSSymbol symbol) {
+  TableEntry entry;
+  ts_language_table_entry(self, state, symbol, &entry);
+  return entry.action_count > 0 && entry.actions[0].type == TSParseActionTypeReduce;
+}
+
 static inline TSStateId ts_language_next_state(const TSLanguage *self,
                                                TSStateId state,
                                                TSSymbol symbol) {
-  if (symbol == ts_builtin_sym_error) {
+  if (symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat) {
     return 0;
   } else if (symbol < self->token_count) {
     uint32_t count;
@@ -44,7 +61,7 @@ static inline TSStateId ts_language_next_state(const TSLanguage *self,
     if (count > 0) {
       TSParseAction action = actions[count - 1];
       if (action.type == TSParseActionTypeShift || action.type == TSParseActionTypeRecover) {
-        return action.params.to_state;
+        return action.params.state;
       }
     }
     return 0;
@@ -63,6 +80,13 @@ ts_language_enabled_external_tokens(const TSLanguage *self,
   }
 }
 
+static inline const TSSymbol *
+ts_language_alias_sequence(const TSLanguage *self, unsigned id) {
+  return id > 0 ?
+    self->alias_sequences + id * self->max_alias_sequence_length :
+    NULL;
+}
+
 #ifdef __cplusplus
 }
 #endif

data/ext/tree-sitter/tree-sitter/src/runtime/length.h

@@ -8,16 +8,13 @@
 
 typedef struct {
   uint32_t bytes;
-  uint32_t chars;
   TSPoint extent;
 } Length;
 
-static inline bool length_has_unknown_chars(Length self) {
-  return self.bytes > 0 && self.chars == 0;
-}
+static const Length LENGTH_UNDEFINED = {0, {0, 1}};
 
-static inline void length_set_unknown_chars(Length *self) {
-  self->chars = 0;
+static inline bool length_is_undefined(Length length) {
+  return length.bytes == 0 && length.extent.column != 0;
 }
 
 static inline Length length_min(Length len1, Length len2) {
@@ -28,13 +25,6 @@ static inline Length length_add(Length len1, Length len2) {
   Length result;
   result.bytes = len1.bytes + len2.bytes;
   result.extent = point_add(len1.extent, len2.extent);
-
-  if (length_has_unknown_chars(len1) || length_has_unknown_chars(len2)) {
-    result.chars = 0;
-  } else {
-    result.chars = len1.chars + len2.chars;
-  }
-
   return result;
 }
 
@@ -42,18 +32,12 @@ static inline Length length_sub(Length len1, Length len2) {
   Length result;
   result.bytes = len1.bytes - len2.bytes;
   result.extent = point_sub(len1.extent, len2.extent);
-
-  if (length_has_unknown_chars(len1) || length_has_unknown_chars(len2)) {
-    result.chars = 0;
-  } else {
-    result.chars = len1.chars - len2.chars;
-  }
-
   return result;
 }
 
 static inline Length length_zero() {
-  return (Length){ 0, 0, {0, 0} };
+  Length result = {0, {0, 0}};
+  return result;
 }
 
 #endif

data/ext/tree-sitter/tree-sitter/src/runtime/lexer.c

@@ -5,9 +5,9 @@
 #include "runtime/utf16.h"
 #include "utf8proc.h"
 
-#define LOG(...)                                                              \
-  if (self->logger.log) {                                                     \
-    snprintf(self->debug_buffer, TS_DEBUG_BUFFER_SIZE, __VA_ARGS__);          \
+#define LOG(...)                                                                      \
+  if (self->logger.log) {                                                             \
+    snprintf(self->debug_buffer, TREE_SITTER_SERIALIZATION_BUFFER_SIZE, __VA_ARGS__); \
     self->logger.log(self->logger.payload, TSLogTypeLex, self->debug_buffer); \
   }
 
@@ -19,26 +19,37 @@ static const char empty_chunk[2] = { 0, 0 };
 static void ts_lexer__get_chunk(Lexer *self) {
   TSInput input = self->input;
   if (!self->chunk ||
-      self->current_position.bytes != self->chunk_start + self->chunk_size)
-    input.seek(input.payload, self->current_position.chars,
-               self->current_position.bytes);
+      self->current_position.bytes != self->chunk_start + self->chunk_size) {
+    input.seek(input.payload, self->current_position.bytes, self->current_position.extent);
+  }
 
   self->chunk_start = self->current_position.bytes;
   self->chunk = input.read(input.payload, &self->chunk_size);
-  if (!self->chunk_size)
-    self->chunk = empty_chunk;
+  if (!self->chunk_size) self->chunk = empty_chunk;
 }
 
 static void ts_lexer__get_lookahead(Lexer *self) {
   uint32_t position_in_chunk = self->current_position.bytes - self->chunk_start;
   const uint8_t *chunk = (const uint8_t *)self->chunk + position_in_chunk;
-  uint32_t size = self->chunk_size - position_in_chunk + 1;
+  uint32_t size = self->chunk_size - position_in_chunk;
+
+  if (size == 0) {
+    self->lookahead_size = 1;
+    self->data.lookahead = '\0';
+    return;
+  }
 
-  if (self->input.encoding == TSInputEncodingUTF8)
-    self->lookahead_size =
-      utf8proc_iterate(chunk, size, &self->data.lookahead);
-  else
+  if (self->input.encoding == TSInputEncodingUTF8) {
+    int64_t lookahead_size = utf8proc_iterate(chunk, size, &self->data.lookahead);
+    if (lookahead_size < 0) {
+      self->lookahead_size = 1;
+    } else {
+      self->lookahead_size = lookahead_size;
+    }
+  }
+  else {
     self->lookahead_size = utf16_iterate(chunk, size, &self->data.lookahead);
+  }
 }
 
 static void ts_lexer__advance(void *payload, bool skip) {
@@ -48,12 +59,11 @@ static void ts_lexer__advance(void *payload, bool skip) {
 
   if (self->lookahead_size) {
     self->current_position.bytes += self->lookahead_size;
-    self->current_position.chars++;
     if (self->data.lookahead == '\n') {
       self->current_position.extent.row++;
       self->current_position.extent.column = 0;
     } else {
-      self->current_position.extent.column++;
+      self->current_position.extent.column += self->lookahead_size;
     }
   }
 
@@ -70,6 +80,31 @@ static void ts_lexer__advance(void *payload, bool skip) {
   ts_lexer__get_lookahead(self);
 }
 
+static void ts_lexer__mark_end(void *payload) {
+  Lexer *self = (Lexer *)payload;
+  self->token_end_position = self->current_position;
+}
+
+static uint32_t ts_lexer__get_column(void *payload) {
+  Lexer *self = (Lexer *)payload;
+  uint32_t goal_byte = self->current_position.bytes;
+
+  self->current_position.bytes -= self->current_position.extent.column;
+  self->current_position.extent.column = 0;
+
+  if (self->current_position.bytes < self->chunk_start) {
+    ts_lexer__get_chunk(self);
+  }
+
+  uint32_t result = 0;
+  while (self->current_position.bytes < goal_byte) {
+    ts_lexer__advance(self, false);
+    result++;
+  }
+
+  return result;
+}
+
 /*
  *  The lexer's advance method is stored as a struct field so that generated
  *  parsers can call it without needing to be linked against this library.
@@ -79,6 +114,8 @@ void ts_lexer_init(Lexer *self) {
   *self = (Lexer){
     .data = {
       .advance = ts_lexer__advance,
+      .mark_end = ts_lexer__mark_end,
+      .get_column = ts_lexer__get_column,
       .lookahead = 0,
       .result_symbol = 0,
     },
@@ -88,13 +125,13 @@ void ts_lexer_init(Lexer *self) {
       .payload = NULL,
       .log = NULL
     },
-    .last_external_token_state = NULL,
   };
   ts_lexer_reset(self, length_zero());
 }
 
 static inline void ts_lexer__reset(Lexer *self, Length position) {
   self->token_start_position = position;
+  self->token_end_position = LENGTH_UNDEFINED;
   self->current_position = position;
 
   if (self->chunk && (position.bytes < self->chunk_start ||
@@ -110,8 +147,10 @@ static inline void ts_lexer__reset(Lexer *self, Length position) {
 
 void ts_lexer_set_input(Lexer *self, TSInput input) {
   self->input = input;
+  self->chunk = 0;
+  self->chunk_start = 0;
+  self->chunk_size = 0;
   ts_lexer__reset(self, length_zero());
-  self->last_external_token_state = NULL;
 }
 
 void ts_lexer_reset(Lexer *self, Length position) {
@@ -122,6 +161,7 @@ void ts_lexer_reset(Lexer *self, Length position) {
 
 void ts_lexer_start(Lexer *self) {
   self->token_start_position = self->current_position;
+  self->token_end_position = LENGTH_UNDEFINED;
   self->data.result_symbol = 0;
 
   if (!self->chunk)
@@ -129,3 +169,7 @@ void ts_lexer_start(Lexer *self) {
   if (!self->lookahead_size)
     ts_lexer__get_lookahead(self);
 }
+
+void ts_lexer_advance_to_end(Lexer *self) {
+  while (self->data.lookahead != 0) ts_lexer__advance(self, false);
+}

data/ext/tree-sitter/tree-sitter/src/runtime/lexer.h

@@ -8,30 +8,29 @@ extern "C" {
 #include "tree_sitter/parser.h"
 #include "tree_sitter/runtime.h"
 #include "runtime/length.h"
-
-#define TS_DEBUG_BUFFER_SIZE 512
+#include "runtime/tree.h"
 
 typedef struct {
   TSLexer data;
   Length current_position;
   Length token_start_position;
+  Length token_end_position;
 
   const char *chunk;
   uint32_t chunk_start;
   uint32_t chunk_size;
-
   uint32_t lookahead_size;
 
   TSInput input;
   TSLogger logger;
-  char debug_buffer[TS_DEBUG_BUFFER_SIZE];
-  const TSExternalTokenState *last_external_token_state;
+  char debug_buffer[TREE_SITTER_SERIALIZATION_BUFFER_SIZE];
 } Lexer;
 
 void ts_lexer_init(Lexer *);
 void ts_lexer_set_input(Lexer *, TSInput);
 void ts_lexer_reset(Lexer *, Length);
 void ts_lexer_start(Lexer *);
+void ts_lexer_advance_to_end(Lexer *);
 
 #ifdef __cplusplus
 }

data/ext/tree-sitter/tree-sitter/src/runtime/node.c

@@ -3,8 +3,8 @@
 #include "runtime/tree.h"
 #include "runtime/document.h"
 
-TSNode ts_node_make(const Tree *tree, uint32_t chars, uint32_t byte, uint32_t row) {
-  return (TSNode){.data = tree, .offset = { chars, byte, row } };
+TSNode ts_node_make(const Tree *tree, uint32_t byte, uint32_t row) {
+  return (TSNode){.data = tree, .offset = { byte, row } };
 }
 
 /*
@@ -12,34 +12,34 @@ TSNode ts_node_make(const Tree *tree, uint32_t chars, uint32_t byte, uint32_t ro
  */
 
 static inline TSNode ts_node__null() {
-  return ts_node_make(NULL, 0, 0, 0);
+  return ts_node_make(NULL, 0, 0);
 }
 
 static inline const Tree *ts_node__tree(TSNode self) {
   return self.data;
 }
 
-static inline uint32_t ts_node__offset_char(TSNode self) {
-  return self.offset[0];
-}
-
 static inline uint32_t ts_node__offset_byte(TSNode self) {
-  return self.offset[1];
+  return self.offset[0];
 }
 
 static inline uint32_t ts_node__offset_row(TSNode self) {
-  return self.offset[2];
+  return self.offset[1];
 }
 
 static inline bool ts_node__is_relevant(TSNode self, bool include_anonymous) {
   const Tree *tree = ts_node__tree(self);
-  return include_anonymous ? tree->visible : tree->visible && tree->named;
+  if (include_anonymous) {
+    return tree->context.alias_symbol || tree->visible;
+  } else {
+    return tree->context.alias_is_named || (tree->visible && tree->named);
+  }
 }
 
 static inline uint32_t ts_node__relevant_child_count(TSNode self,
                                                    bool include_anonymous) {
   const Tree *tree = ts_node__tree(self);
-  if (tree->child_count > 0) {
+  if (tree->children.size > 0) {
     if (include_anonymous) {
       return tree->visible_child_count;
     } else {
@@ -53,18 +53,20 @@ static inline uint32_t ts_node__relevant_child_count(TSNode self,
 static inline TSNode ts_node__direct_parent(TSNode self, uint32_t *index) {
   const Tree *tree = ts_node__tree(self);
   *index = tree->context.index;
-  return ts_node_make(tree->context.parent,
-                      ts_node__offset_char(self) - tree->context.offset.chars,
-                      ts_node__offset_byte(self) - tree->context.offset.bytes,
-                      ts_node__offset_row(self) - tree->context.offset.extent.row);
+  return ts_node_make(
+    tree->context.parent,
+    ts_node__offset_byte(self) - tree->context.offset.bytes,
+    ts_node__offset_row(self) - tree->context.offset.extent.row
+  );
 }
 
 static inline TSNode ts_node__direct_child(TSNode self, uint32_t i) {
-  const Tree *child_tree = ts_node__tree(self)->children[i];
+  const Tree *child_tree = ts_node__tree(self)->children.contents[i];
   return ts_node_make(
-    child_tree, ts_node__offset_char(self) + child_tree->context.offset.chars,
+    child_tree,
     ts_node__offset_byte(self) + child_tree->context.offset.bytes,
-    ts_node__offset_row(self) + child_tree->context.offset.extent.row);
+    ts_node__offset_row(self) + child_tree->context.offset.extent.row
+  );
 }
 
 static inline TSNode ts_node__child(TSNode self, uint32_t child_index,
@@ -76,7 +78,7 @@ static inline TSNode ts_node__child(TSNode self, uint32_t child_index,
     did_descend = false;
 
     uint32_t index = 0;
-    for (uint32_t i = 0; i < ts_node__tree(result)->child_count; i++) {
+    for (uint32_t i = 0; i < ts_node__tree(result)->children.size; i++) {
       TSNode child = ts_node__direct_child(result, i);
       if (ts_node__is_relevant(child, include_anonymous)) {
         if (index == child_index)
@@ -132,7 +134,7 @@ static inline TSNode ts_node__next_sibling(TSNode self, bool include_anonymous)
     if (!result.data)
       break;
 
-    for (uint32_t i = index + 1; i < ts_node__tree(result)->child_count; i++) {
+    for (uint32_t i = index + 1; i < ts_node__tree(result)->children.size; i++) {
       TSNode child = ts_node__direct_child(result, i);
       if (ts_node__is_relevant(child, include_anonymous))
         return child;
@@ -150,31 +152,29 @@ static inline bool point_gt(TSPoint a, TSPoint b) {
   return a.row > b.row || (a.row == b.row && a.column > b.column);
 }
 
-static inline TSNode ts_node__descendant_for_char_range(TSNode self, uint32_t min,
-                                                        uint32_t max,
-                                                        bool include_anonymous) {
+static inline TSNode ts_node__first_child_for_byte(TSNode self, uint32_t goal,
+                                                   bool include_anonymous) {
   TSNode node = self;
-  TSNode last_visible_node = self;
-
   bool did_descend = true;
+
   while (did_descend) {
     did_descend = false;
 
-    for (uint32_t i = 0; i < ts_node__tree(node)->child_count; i++) {
+    for (uint32_t i = 0; i < ts_node__tree(node)->children.size; i++) {
       TSNode child = ts_node__direct_child(node, i);
-      if (ts_node_start_char(child) > min)
-        break;
-      if (ts_node_end_char(child) > max) {
-        node = child;
-        if (ts_node__is_relevant(node, include_anonymous))
-          last_visible_node = node;
-        did_descend = true;
-        break;
+      if (ts_node_end_byte(child) > goal) {
+        if (ts_node__is_relevant(child, include_anonymous)) {
+          return child;
+        } else if (ts_node_child_count(child) > 0) {
+          did_descend = true;
+          node = child;
+          break;
+        }
       }
     }
   }
 
-  return last_visible_node;
+  return ts_node__null();
 }
 
 static inline TSNode ts_node__descendant_for_byte_range(TSNode self, uint32_t min,
@@ -187,14 +187,12 @@ static inline TSNode ts_node__descendant_for_byte_range(TSNode self, uint32_t mi
   while (did_descend) {
     did_descend = false;
 
-    for (uint32_t i = 0; i < ts_node__tree(node)->child_count; i++) {
+    for (uint32_t i = 0, n = ts_node__tree(node)->children.size; i < n; i++) {
       TSNode child = ts_node__direct_child(node, i);
-      if (ts_node_start_byte(child) > min)
-        break;
       if (ts_node_end_byte(child) > max) {
+        if (ts_node_start_byte(child) > min) break;
         node = child;
-        if (ts_node__is_relevant(node, include_anonymous))
-          last_visible_node = node;
+        if (ts_node__is_relevant(node, include_anonymous)) last_visible_node = node;
         did_descend = true;
         break;
       }
@@ -204,26 +202,31 @@ static inline TSNode ts_node__descendant_for_byte_range(TSNode self, uint32_t mi
   return last_visible_node;
 }
 
-static inline TSNode ts_node__descendant_for_point_range(
-  TSNode self, TSPoint min, TSPoint max, bool include_anonymous) {
+static inline TSNode ts_node__descendant_for_point_range(TSNode self, TSPoint min,
+                                                         TSPoint max,
+                                                         bool include_anonymous) {
   TSNode node = self;
   TSNode last_visible_node = self;
+  TSPoint start_position = ts_node_start_point(self);
+  TSPoint end_position = ts_node_end_point(self);
 
   bool did_descend = true;
   while (did_descend) {
     did_descend = false;
 
-    for (uint32_t i = 0; i < ts_node__tree(node)->child_count; i++) {
+    for (uint32_t i = 0, n = ts_node__tree(node)->children.size; i < n; i++) {
       TSNode child = ts_node__direct_child(node, i);
-      if (point_gt(ts_node_start_point(child), min))
-        break;
-      if (point_gt(ts_node_end_point(child), max)) {
+      const Tree *child_tree = ts_node__tree(child);
+      if (i > 0) start_position = point_add(start_position, child_tree->padding.extent);
+      end_position = point_add(start_position, child_tree->size.extent);
+      if (point_gt(end_position, max)) {
+        if (point_gt(start_position, min)) break;
         node = child;
-        if (ts_node__is_relevant(node, include_anonymous))
-          last_visible_node = node;
+        if (ts_node__is_relevant(node, include_anonymous)) last_visible_node = node;
         did_descend = true;
         break;
       }
+      start_position = end_position;
     }
   }
 
@@ -234,14 +237,6 @@ static inline TSNode ts_node__descendant_for_point_range(
  *  Public
  */
 
-uint32_t ts_node_start_char(TSNode self) {
-  return ts_node__offset_char(self) + ts_node__tree(self)->padding.chars;
-}
-
-uint32_t ts_node_end_char(TSNode self) {
-  return ts_node_start_char(self) + ts_node__tree(self)->size.chars;
-}
-
 uint32_t ts_node_start_byte(TSNode self) {
   return ts_node__offset_byte(self) + ts_node__tree(self)->padding.bytes;
 }
@@ -264,32 +259,12 @@ TSPoint ts_node_end_point(TSNode self) {
 }
 
 TSSymbol ts_node_symbol(TSNode self) {
-  return ts_node__tree(self)->symbol;
-}
-
-TSSymbolIterator ts_node_symbols(TSNode self) {
   const Tree *tree = ts_node__tree(self);
-  return (TSSymbolIterator){
-    .value = tree->symbol, .done = false, .data = (void *)tree,
-  };
-}
-
-void ts_symbol_iterator_next(TSSymbolIterator *self) {
-  const Tree *tree = (const Tree *)self->data;
-  const Tree *parent = tree->context.parent;
-  if (!self->done && parent) {
-    if (parent->child_count == 1 && !parent->visible) {
-      self->value = parent->symbol;
-      self->data = (void *)parent;
-      return;
-    }
-  }
-  self->done = true;
+  return tree->context.alias_symbol ? tree->context.alias_symbol : tree->symbol;
 }
 
 const char *ts_node_type(TSNode self, const TSDocument *document) {
-  TSSymbol symbol = ts_node__tree(self)->symbol;
-  return ts_language_symbol_name(document->parser.language, symbol);
+  return ts_language_symbol_name(document->parser.language, ts_node_symbol(self));
 }
 
 char *ts_node_string(TSNode self, const TSDocument *document) {
@@ -297,19 +272,30 @@ char *ts_node_string(TSNode self, const TSDocument *document) {
 }
 
 bool ts_node_eq(TSNode self, TSNode other) {
-  return ts_tree_eq(ts_node__tree(self), ts_node__tree(other)) &&
-         self.offset[0] == other.offset[0] &&
-         self.offset[1] == other.offset[1] && self.offset[2] == other.offset[2];
+  return
+    ts_tree_eq(ts_node__tree(self), ts_node__tree(other)) &&
+    self.offset[0] == other.offset[0] &&
+    self.offset[1] == other.offset[1];
 }
 
 bool ts_node_is_named(TSNode self) {
-  return ts_node__tree(self)->named;
+  const Tree *tree = ts_node__tree(self);
+  return tree->context.alias_symbol ? tree->context.alias_is_named : tree->named;
+}
+
+bool ts_node_is_missing(TSNode self) {
+  const Tree *tree = ts_node__tree(self);
+  return tree->is_missing;
 }
 
 bool ts_node_has_changes(TSNode self) {
   return ts_node__tree(self)->has_changes;
 }
 
+bool ts_node_has_error(TSNode self) {
+  return ts_node__tree(self)->error_cost > 0;
+}
+
 TSNode ts_node_parent(TSNode self) {
   TSNode result = self;
   uint32_t index;
@@ -323,6 +309,25 @@ TSNode ts_node_parent(TSNode self) {
   return result;
 }
 
+uint32_t ts_node_child_index(TSNode self) {
+  const Tree *tree = ts_node__tree(self);
+  uint32_t result = 0;
+
+  for (;;) {
+    const Tree *parent = tree->context.parent;
+    uint32_t index = tree->context.index;
+    if (!parent) return UINT32_MAX;
+    for (uint32_t i = 0; i < index; i++) {
+      Tree *child = parent->children.contents[i];
+      result += child->visible ? 1 : child->visible_child_count;
+    }
+    if (parent->visible) break;
+    tree = parent;
+  }
+
+  return result;
+}
+
 TSNode ts_node_child(TSNode self, uint32_t child_index) {
   return ts_node__child(self, child_index, true);
 }
@@ -333,7 +338,7 @@ TSNode ts_node_named_child(TSNode self, uint32_t child_index) {
 
 uint32_t ts_node_child_count(TSNode self) {
   const Tree *tree = ts_node__tree(self);
-  if (tree->child_count > 0) {
+  if (tree->children.size > 0) {
     return tree->visible_child_count;
   } else {
     return 0;
@@ -342,7 +347,7 @@ uint32_t ts_node_child_count(TSNode self) {
 
 uint32_t ts_node_named_child_count(TSNode self) {
   const Tree *tree = ts_node__tree(self);
-  if (tree->child_count > 0) {
+  if (tree->children.size > 0) {
     return tree->named_child_count;
   } else {
     return 0;
@@ -365,13 +370,12 @@ TSNode ts_node_prev_named_sibling(TSNode self) {
   return ts_node__prev_sibling(self, false);
 }
 
-TSNode ts_node_descendant_for_char_range(TSNode self, uint32_t min, uint32_t max) {
-  return ts_node__descendant_for_char_range(self, min, max, true);
+TSNode ts_node_first_child_for_byte(TSNode self, uint32_t byte) {
+  return ts_node__first_child_for_byte(self, byte, true);
 }
 
-TSNode ts_node_named_descendant_for_char_range(TSNode self, uint32_t min,
-                                               uint32_t max) {
-  return ts_node__descendant_for_char_range(self, min, max, false);
+TSNode ts_node_first_named_child_for_byte(TSNode self, uint32_t byte) {
+  return ts_node__first_child_for_byte(self, byte, false);
 }
 
 TSNode ts_node_descendant_for_byte_range(TSNode self, uint32_t min, uint32_t max) {