tree_cursor.c File Reference

#include "tree_sitter/api.h"
#include "./alloc.h"
#include "./tree_cursor.h"
#include "./language.h"
#include "./tree.h"

Go to the source code of this file.

Classes
struct	CursorChildIterator

Macros
#define	subtree_symbol(subtree, structural_child_index)

Functions
static CursorChildIterator	ts_tree_cursor_iterate_children (const TreeCursor *self)
static bool	ts_tree_cursor_child_iterator_next (CursorChildIterator *self, TreeCursorEntry *result, bool *visible)
TSTreeCursor	ts_tree_cursor_new (TSNode node)
void	ts_tree_cursor_reset (TSTreeCursor *_self, TSNode node)
void	ts_tree_cursor_init (TreeCursor *self, TSNode node)
void	ts_tree_cursor_delete (TSTreeCursor *_self)
bool	ts_tree_cursor_goto_first_child (TSTreeCursor *_self)
int64_t	ts_tree_cursor_goto_first_child_for_byte (TSTreeCursor *_self, uint32_t goal_byte)
int64_t	ts_tree_cursor_goto_first_child_for_point (TSTreeCursor *_self, TSPoint goal_point)
bool	ts_tree_cursor_goto_next_sibling (TSTreeCursor *_self)
bool	ts_tree_cursor_goto_parent (TSTreeCursor *_self)
TSNode	ts_tree_cursor_current_node (const TSTreeCursor *_self)
void	ts_tree_cursor_current_status (const TSTreeCursor *_self, TSFieldId *field_id, bool *has_later_siblings, bool *has_later_named_siblings, bool *can_have_later_siblings_with_this_field, TSSymbol *supertypes, unsigned *supertype_count)
TSNode	ts_tree_cursor_parent_node (const TSTreeCursor *_self)
TSFieldId	ts_tree_cursor_current_field_id (const TSTreeCursor *_self)
const char *	ts_tree_cursor_current_field_name (const TSTreeCursor *_self)
TSTreeCursor	ts_tree_cursor_copy (const TSTreeCursor *_cursor)

Macro Definition Documentation

subtree_symbol

#define subtree_symbol	(		subtree,
			structural_child_index
	)

Value:

      ((                                                    \
        !ts_subtree_extra(subtree) &&                       \
        alias_sequence &&                                   \
        alias_sequence[structural_child_index]              \
      ) ?                                                   \
        alias_sequence[structural_child_index] :            \
        ts_subtree_symbol(subtree))

Function Documentation

ts_tree_cursor_child_iterator_next()

static bool ts_tree_cursor_child_iterator_next ( CursorChildIterator *  self, TreeCursorEntry *  result, bool *  visible  )

inlinestatic

Definition at line 37 of file tree_cursor.c.

  {
  if (!self->parent.ptr || self->child_index == self->parent.ptr->child_count) return false;
  const Subtree *child = &ts_subtree_children(self->parent)[self->child_index];
  *result = (TreeCursorEntry) {
    .subtree = child,
    .position = self->position,
    .child_index = self->child_index,
    .structural_child_index = self->structural_child_index,
  };
  *visible = ts_subtree_visible(*child);
  bool extra = ts_subtree_extra(*child);
  if (!extra && self->alias_sequence) {
    *visible |= self->alias_sequence[self->structural_child_index];
    self->structural_child_index++;
  }
 
  self->position = length_add(self->position, ts_subtree_size(*child));
  self->child_index++;
 
  if (self->child_index < self->parent.ptr->child_count) {
    Subtree next_child = ts_subtree_children(self->parent)[self->child_index];
    self->position = length_add(self->position, ts_subtree_padding(next_child));
  }
 
  return true;
}

References length_add(), TreeCursorEntry::subtree, ts_subtree_children, ts_subtree_extra(), ts_subtree_padding(), ts_subtree_size(), and ts_subtree_visible().

Referenced by ts_tree_cursor_goto_first_child(), ts_tree_cursor_goto_first_child_for_byte(), ts_tree_cursor_goto_first_child_for_point(), and ts_tree_cursor_goto_next_sibling().

ts_tree_cursor_copy()

TSTreeCursor ts_tree_cursor_copy

(

const TSTreeCursor *

_cursor

)

Definition at line 479 of file tree_cursor.c.

                                                              {
  const TreeCursor *cursor = (const TreeCursor *)_cursor;
  TSTreeCursor res = {NULL, NULL, {0, 0}};
  TreeCursor *copy = (TreeCursor *)&res;
  copy->tree = cursor->tree;
  array_init(&copy->stack);
  array_push_all(&copy->stack, &cursor->stack);
  return res;
}

References array_init, array_push_all, NULL, and TreeCursor::tree.

ts_tree_cursor_current_field_id()

TSFieldId ts_tree_cursor_current_field_id

(

const TSTreeCursor *

_self

)

Get the field id of the tree cursor's current node.

This returns zero if the current node doesn't have a field. See also ts_node_child_by_field_id, ts_language_field_id_for_name.

Definition at line 431 of file tree_cursor.c.

                                                                     {
  const TreeCursor *self = (const TreeCursor *)_self;
 
  // Walk up the tree, visiting the current node and its invisible ancestors.
  for (unsigned i = self->stack.size - 1; i > 0; i--) {
    TreeCursorEntry *entry = &self->stack.contents[i];
    TreeCursorEntry *parent_entry = &self->stack.contents[i - 1];
 
    // Stop walking up when another visible node is found.
    if (i != self->stack.size - 1) {
      if (ts_subtree_visible(*entry->subtree)) break;
      if (
        !ts_subtree_extra(*entry->subtree) &&
        ts_language_alias_at(
          self->tree->language,
          parent_entry->subtree->ptr->production_id,
          entry->structural_child_index
        )
      ) break;
    }
 
    if (ts_subtree_extra(*entry->subtree)) break;
 
    const TSFieldMapEntry *field_map, *field_map_end;
    ts_language_field_map(
      self->tree->language,
      parent_entry->subtree->ptr->production_id,
      &field_map, &field_map_end
    );
    for (const TSFieldMapEntry *i = field_map; i < field_map_end; i++) {
      if (!i->inherited && i->child_index == entry->structural_child_index) {
        return i->field_id;
      }
    }
  }
  return 0;
}

References i, SubtreeHeapData::production_id, Subtree::ptr, TreeCursorEntry::subtree, ts_language_alias_at(), ts_language_field_map(), ts_subtree_extra(), and ts_subtree_visible().

Referenced by ts_tree_cursor_current_field_id_wasm(), and ts_tree_cursor_current_field_name().

ts_tree_cursor_current_field_name()

const char* ts_tree_cursor_current_field_name

(

const TSTreeCursor *

_self

)

Get the field name of the tree cursor's current node.

This returns NULL if the current node doesn't have a field. See also ts_node_child_by_field_name.

Definition at line 469 of file tree_cursor.c.

                                                                         {
  TSFieldId id = ts_tree_cursor_current_field_id(_self);
  if (id) {
    const TreeCursor *self = (const TreeCursor *)_self;
    return self->tree->language->field_names[id];
  } else {
    return NULL;
  }
}

References id, NULL, TSTreeCursor::tree, and ts_tree_cursor_current_field_id().

ts_tree_cursor_current_node()

TSNode ts_tree_cursor_current_node

(

const TSTreeCursor *

_self

)

Get the tree cursor's current node.

Definition at line 262 of file tree_cursor.c.

                                                              {
  const TreeCursor *self = (const TreeCursor *)_self;
  TreeCursorEntry *last_entry = array_back(&self->stack);
  TSSymbol alias_symbol = 0;
  if (self->stack.size > 1 && !ts_subtree_extra(*last_entry->subtree)) {
    TreeCursorEntry *parent_entry = &self->stack.contents[self->stack.size - 2];
    alias_symbol = ts_language_alias_at(
      self->tree->language,
      parent_entry->subtree->ptr->production_id,
      last_entry->structural_child_index
    );
  }
  return ts_node_new(
    self->tree,
    last_entry->subtree,
    last_entry->position,
    alias_symbol
  );
}

References array_back, TreeCursorEntry::position, SubtreeHeapData::production_id, Subtree::ptr, TreeCursorEntry::structural_child_index, TreeCursorEntry::subtree, ts_language_alias_at(), ts_node_new(), and ts_subtree_extra().

Referenced by ts_node_children_wasm(), ts_node_descendants_of_type_wasm(), ts_node_named_children_wasm(), ts_query_cursor__advance(), ts_tree_cursor_current_node_id_wasm(), ts_tree_cursor_current_node_is_missing_wasm(), ts_tree_cursor_current_node_is_named_wasm(), ts_tree_cursor_current_node_type_id_wasm(), ts_tree_cursor_current_node_wasm(), ts_tree_cursor_end_index_wasm(), ts_tree_cursor_end_position_wasm(), ts_tree_cursor_start_index_wasm(), and ts_tree_cursor_start_position_wasm().

ts_tree_cursor_current_status()

void ts_tree_cursor_current_status	(	const TSTreeCursor *	_self,
		TSFieldId *	field_id,
		bool *	has_later_siblings,
		bool *	has_later_named_siblings,
		bool *	can_have_later_siblings_with_this_field,
		TSSymbol *	supertypes,
		unsigned *	supertype_count
	)

Definition at line 284 of file tree_cursor.c.

  {
  const TreeCursor *self = (const TreeCursor *)_self;
  unsigned max_supertypes = *supertype_count;
  *field_id = 0;
  *supertype_count = 0;
  *has_later_siblings = false;
  *has_later_named_siblings = false;
  *can_have_later_siblings_with_this_field = false;
 
  // Walk up the tree, visiting the current node and its invisible ancestors,
  // because fields can refer to nodes through invisible *wrapper* nodes,
  for (unsigned i = self->stack.size - 1; i > 0; i--) {
    TreeCursorEntry *entry = &self->stack.contents[i];
    TreeCursorEntry *parent_entry = &self->stack.contents[i - 1];
 
    const TSSymbol *alias_sequence = ts_language_alias_sequence(
      self->tree->language,
      parent_entry->subtree->ptr->production_id
    );
 
    #define subtree_symbol(subtree, structural_child_index) \
      ((                                                    \
        !ts_subtree_extra(subtree) &&                       \
        alias_sequence &&                                   \
        alias_sequence[structural_child_index]              \
      ) ?                                                   \
        alias_sequence[structural_child_index] :            \
        ts_subtree_symbol(subtree))
 
    // Stop walking up when a visible ancestor is found.
    TSSymbol entry_symbol = subtree_symbol(
      *entry->subtree,
      entry->structural_child_index
    );
    TSSymbolMetadata entry_metadata = ts_language_symbol_metadata(
      self->tree->language,
      entry_symbol
    );
    if (i != self->stack.size - 1 && entry_metadata.visible) break;
 
    // Record any supertypes
    if (entry_metadata.supertype && *supertype_count < max_supertypes) {
      supertypes[*supertype_count] = entry_symbol;
      (*supertype_count)++;
    }
 
    // Determine if the current node has later siblings.
    if (!*has_later_siblings) {
      unsigned sibling_count = parent_entry->subtree->ptr->child_count;
      unsigned structural_child_index = entry->structural_child_index;
      if (!ts_subtree_extra(*entry->subtree)) structural_child_index++;
      for (unsigned j = entry->child_index + 1; j < sibling_count; j++) {
        Subtree sibling = ts_subtree_children(*parent_entry->subtree)[j];
        TSSymbolMetadata sibling_metadata = ts_language_symbol_metadata(
          self->tree->language,
          subtree_symbol(sibling, structural_child_index)
        );
        if (sibling_metadata.visible) {
          *has_later_siblings = true;
          if (*has_later_named_siblings) break;
          if (sibling_metadata.named) {
            *has_later_named_siblings = true;
            break;
          }
        } else if (ts_subtree_visible_child_count(sibling) > 0) {
          *has_later_siblings = true;
          if (*has_later_named_siblings) break;
          if (sibling.ptr->named_child_count > 0) {
            *has_later_named_siblings = true;
            break;
          }
        }
        if (!ts_subtree_extra(sibling)) structural_child_index++;
      }
    }
 
    #undef subtree_symbol
 
    if (!ts_subtree_extra(*entry->subtree)) {
      const TSFieldMapEntry *field_map, *field_map_end;
      ts_language_field_map(
        self->tree->language,
        parent_entry->subtree->ptr->production_id,
        &field_map, &field_map_end
      );
 
      // Look for a field name associated with the current node.
      if (!*field_id) {
        for (const TSFieldMapEntry *i = field_map; i < field_map_end; i++) {
          if (!i->inherited && i->child_index == entry->structural_child_index) {
            *field_id = i->field_id;
            break;
          }
        }
      }
 
      // Determine if the current node can have later siblings with the same field name.
      if (*field_id) {
        for (const TSFieldMapEntry *i = field_map; i < field_map_end; i++) {
          if (
            i->field_id == *field_id &&
            i->child_index > entry->structural_child_index
          ) {
            *can_have_later_siblings_with_this_field = true;
            break;
          }
        }
      }
    }
  }
}

References SubtreeHeapData::child_count, field_id, i, TSSymbolMetadata::named, SubtreeHeapData::named_child_count, SubtreeHeapData::production_id, Subtree::ptr, TreeCursorEntry::subtree, subtree_symbol, TSSymbolMetadata::supertype, ts_language_alias_sequence(), ts_language_field_map(), ts_language_symbol_metadata(), ts_subtree_children, ts_subtree_extra(), ts_subtree_visible_child_count(), and TSSymbolMetadata::visible.

Referenced by ts_query_cursor__advance().

ts_tree_cursor_delete()

void ts_tree_cursor_delete

(

TSTreeCursor *

_self

)

Delete a tree cursor, freeing all of the memory that it used.

Definition at line 94 of file tree_cursor.c.

                                                {
  TreeCursor *self = (TreeCursor *)_self;
  array_delete(&self->stack);
}

References array_delete.

Referenced by ts_query_cursor_delete(), and ts_tree_cursor_delete_wasm().

ts_tree_cursor_goto_first_child()

bool ts_tree_cursor_goto_first_child

(

TSTreeCursor *

_self

)

Move the cursor to the first child of its current node.

This returns true if the cursor successfully moved, and returns false if there were no children.

Definition at line 101 of file tree_cursor.c.

                                                          {
  TreeCursor *self = (TreeCursor *)_self;
 
  bool did_descend;
  do {
    did_descend = false;
 
    bool visible;
    TreeCursorEntry entry;
    CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
    while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
      if (visible) {
        array_push(&self->stack, entry);
        return true;
      }
 
      if (ts_subtree_visible_child_count(*entry.subtree) > 0) {
        array_push(&self->stack, entry);
        did_descend = true;
        break;
      }
    }
  } while (did_descend);
 
  return false;
}

References array_push, ts_subtree_visible_child_count(), ts_tree_cursor_child_iterator_next(), and ts_tree_cursor_iterate_children().

Referenced by ts_node_children_wasm(), ts_node_descendants_of_type_wasm(), ts_node_named_children_wasm(), ts_query_cursor__advance(), ts_tree_cursor_goto_first_child_wasm(), and ts_tree_cursor_goto_next_sibling().

ts_tree_cursor_goto_first_child_for_byte()

int64_t ts_tree_cursor_goto_first_child_for_byte	(	TSTreeCursor *	_self,
		uint32_t	goal_byte
	)

Move the cursor to the first child of its current node that extends beyond the given byte offset or point.

This returns the index of the child node if one was found, and returns -1 if no such child was found.

Definition at line 128 of file tree_cursor.c.

                                                                                          {
  TreeCursor *self = (TreeCursor *)_self;
  uint32_t initial_size = self->stack.size;
  uint32_t visible_child_index = 0;
 
  bool did_descend;
  do {
    did_descend = false;
 
    bool visible;
    TreeCursorEntry entry;
    CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
    while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
      uint32_t end_byte = entry.position.bytes + ts_subtree_size(*entry.subtree).bytes;
      bool at_goal = end_byte >= goal_byte;
      uint32_t visible_child_count = ts_subtree_visible_child_count(*entry.subtree);
 
      if (at_goal) {
        if (visible) {
          array_push(&self->stack, entry);
          return visible_child_index;
        }
 
        if (visible_child_count > 0) {
          array_push(&self->stack, entry);
          did_descend = true;
          break;
        }
      } else if (visible) {
        visible_child_index++;
      } else {
        visible_child_index += visible_child_count;
      }
    }
  } while (did_descend);
 
  self->stack.size = initial_size;
  return -1;
}

References array_push, Length::bytes, ts_subtree_size(), ts_subtree_visible_child_count(), ts_tree_cursor_child_iterator_next(), and ts_tree_cursor_iterate_children().

ts_tree_cursor_goto_first_child_for_point()

int64_t ts_tree_cursor_goto_first_child_for_point	(	TSTreeCursor *	_self,
		TSPoint	goal_point
	)

Definition at line 168 of file tree_cursor.c.

                                                                                           {
  TreeCursor *self = (TreeCursor *)_self;
  uint32_t initial_size = self->stack.size;
  uint32_t visible_child_index = 0;
 
  bool did_descend;
  do {
    did_descend = false;
 
    bool visible;
    TreeCursorEntry entry;
    CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
    while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
      TSPoint end_point = point_add(entry.position.extent, ts_subtree_size(*entry.subtree).extent);
      bool at_goal = point_gte(end_point, goal_point);
      uint32_t visible_child_count = ts_subtree_visible_child_count(*entry.subtree);
      if (at_goal) {
        if (visible) {
          array_push(&self->stack, entry);
          return visible_child_index;
        }
        if (visible_child_count > 0) {
          array_push(&self->stack, entry);
          did_descend = true;
          break;
        }
      } else if (visible) {
        visible_child_index++;
      } else {
        visible_child_index += visible_child_count;
      }
    }
  } while (did_descend);
 
  self->stack.size = initial_size;
  return -1;
}

References array_push, Length::extent, point_add(), point_gte(), ts_subtree_size(), ts_subtree_visible_child_count(), ts_tree_cursor_child_iterator_next(), and ts_tree_cursor_iterate_children().

ts_tree_cursor_goto_next_sibling()

bool ts_tree_cursor_goto_next_sibling

(

TSTreeCursor *

_self

)

Move the cursor to the next sibling of its current node.

This returns true if the cursor successfully moved, and returns false if there was no next sibling node.

Definition at line 206 of file tree_cursor.c.

                                                           {
  TreeCursor *self = (TreeCursor *)_self;
  uint32_t initial_size = self->stack.size;
 
  while (self->stack.size > 1) {
    TreeCursorEntry entry = array_pop(&self->stack);
    CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
    iterator.child_index = entry.child_index;
    iterator.structural_child_index = entry.structural_child_index;
    iterator.position = entry.position;
 
    bool visible = false;
    ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible);
    if (visible && self->stack.size + 1 < initial_size) break;
 
    while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
      if (visible) {
        array_push(&self->stack, entry);
        return true;
      }
 
      if (ts_subtree_visible_child_count(*entry.subtree)) {
        array_push(&self->stack, entry);
        ts_tree_cursor_goto_first_child(_self);
        return true;
      }
    }
  }
 
  self->stack.size = initial_size;
  return false;
}

References array_pop, array_push, ts_subtree_visible_child_count(), ts_tree_cursor_child_iterator_next(), ts_tree_cursor_goto_first_child(), and ts_tree_cursor_iterate_children().

Referenced by ts_node_children_wasm(), ts_node_descendants_of_type_wasm(), ts_node_named_children_wasm(), ts_query_cursor__advance(), and ts_tree_cursor_goto_next_sibling_wasm().

ts_tree_cursor_goto_parent()

bool ts_tree_cursor_goto_parent

(

TSTreeCursor *

_self

)

Move the cursor to the parent of its current node.

This returns true if the cursor successfully moved, and returns false if there was no parent node (the cursor was already on the root node).

Definition at line 239 of file tree_cursor.c.

                                                     {
  TreeCursor *self = (TreeCursor *)_self;
  for (unsigned i = self->stack.size - 2; i + 1 > 0; i--) {
    TreeCursorEntry *entry = &self->stack.contents[i];
    if (ts_subtree_visible(*entry->subtree)) {
      self->stack.size = i + 1;
      return true;
    }
    if (i > 0 && !ts_subtree_extra(*entry->subtree)) {
      TreeCursorEntry *parent_entry = &self->stack.contents[i - 1];
      if (ts_language_alias_at(
        self->tree->language,
        parent_entry->subtree->ptr->production_id,
        entry->structural_child_index
      )) {
        self->stack.size = i + 1;
        return true;
      }
    }
  }
  return false;
}

References i, SubtreeHeapData::production_id, Subtree::ptr, entry::size, TreeCursorEntry::subtree, ts_language_alias_at(), ts_subtree_extra(), and ts_subtree_visible().

Referenced by ts_node_descendants_of_type_wasm(), ts_query_cursor__advance(), and ts_tree_cursor_goto_parent_wasm().

ts_tree_cursor_init()

void ts_tree_cursor_init	(	TreeCursor *	self,
		TSNode	node
	)

Definition at line 80 of file tree_cursor.c.

                                                        {
  self->tree = node.tree;
  array_clear(&self->stack);
  array_push(&self->stack, ((TreeCursorEntry) {
    .subtree = (const Subtree *)node.id,
    .position = {
      ts_node_start_byte(node),
      ts_node_start_point(node)
    },
    .child_index = 0,
    .structural_child_index = 0,
  }));
}

References array_clear, array_push, and TSNode::tree.

Referenced by ts_tree_cursor_new(), ts_tree_cursor_reset(), and ts_tree_get_changed_ranges().

ts_tree_cursor_iterate_children()

static CursorChildIterator ts_tree_cursor_iterate_children ( const TreeCursor *  self )

inlinestatic

Definition at line 18 of file tree_cursor.c.

                                                                                          {
  TreeCursorEntry *last_entry = array_back(&self->stack);
  if (ts_subtree_child_count(*last_entry->subtree) == 0) {
    return (CursorChildIterator) {NULL_SUBTREE, self->tree, length_zero(), 0, 0, NULL};
  }
  const TSSymbol *alias_sequence = ts_language_alias_sequence(
    self->tree->language,
    last_entry->subtree->ptr->production_id
  );
  return (CursorChildIterator) {
    .tree = self->tree,
    .parent = *last_entry->subtree,
    .position = last_entry->position,
    .child_index = 0,
    .structural_child_index = 0,
    .alias_sequence = alias_sequence,
  };
}

References array_back, length_zero(), NULL, NULL_SUBTREE, TreeCursorEntry::position, SubtreeHeapData::production_id, Subtree::ptr, TreeCursorEntry::subtree, ts_language_alias_sequence(), and ts_subtree_child_count().

Referenced by ts_tree_cursor_goto_first_child(), ts_tree_cursor_goto_first_child_for_byte(), ts_tree_cursor_goto_first_child_for_point(), and ts_tree_cursor_goto_next_sibling().

ts_tree_cursor_new()

TSTreeCursor ts_tree_cursor_new

(

TSNode

node

)

Create a new tree cursor starting from the given node.

A tree cursor allows you to walk a syntax tree more efficiently than is possible using the TSNode functions. It is a mutable object that is always on a certain syntax node, and can be moved imperatively to different nodes.

Definition at line 70 of file tree_cursor.c.

                                             {
  TSTreeCursor self = {NULL, NULL, {0, 0}};
  ts_tree_cursor_init((TreeCursor *)&self, node);
  return self;
}

References NULL, and ts_tree_cursor_init().

Referenced by ts_tree_cursor_new_wasm().

ts_tree_cursor_parent_node()

TSNode ts_tree_cursor_parent_node

(

const TSTreeCursor *

_self

)

Definition at line 404 of file tree_cursor.c.

                                                             {
  const TreeCursor *self = (const TreeCursor *)_self;
  for (int i = (int)self->stack.size - 2; i >= 0; i--) {
    TreeCursorEntry *entry = &self->stack.contents[i];
    bool is_visible = true;
    TSSymbol alias_symbol = 0;
    if (i > 0) {
      TreeCursorEntry *parent_entry = &self->stack.contents[i - 1];
      alias_symbol = ts_language_alias_at(
        self->tree->language,
        parent_entry->subtree->ptr->production_id,
        entry->structural_child_index
      );
      is_visible = (alias_symbol != 0) || ts_subtree_visible(*entry->subtree);
    }
    if (is_visible) {
      return ts_node_new(
        self->tree,
        entry->subtree,
        entry->position,
        alias_symbol
      );
    }
  }
  return ts_node_new(NULL, NULL, length_zero(), 0);
}

References i, length_zero(), NULL, SubtreeHeapData::production_id, Subtree::ptr, TreeCursorEntry::subtree, ts_language_alias_at(), ts_node_new(), and ts_subtree_visible().

Referenced by ts_query_cursor__advance().

ts_tree_cursor_reset()

void ts_tree_cursor_reset	(	TSTreeCursor *	_self,
		TSNode	node
	)

Re-initialize a tree cursor to start at a different node.

Definition at line 76 of file tree_cursor.c.

                                                            {
  ts_tree_cursor_init((TreeCursor *)_self, node);
}

References ts_tree_cursor_init().

Referenced by ts_node_children_wasm(), ts_node_descendants_of_type_wasm(), ts_node_named_children_wasm(), ts_query_cursor_exec(), and ts_tree_cursor_reset_wasm().