Tree-sitter

https://docs.rs/tree-sitter/latest/
Admin
Rust bindings to the Tree-sitter parsing library, enabling incremental parsing with support for...
Tokens:190,831
Snippets:1,911
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Execute a query

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/tree-sitter/a65eccf90197d882/out/bindings.rs.html?search=std%3A%3Avec

Starts running a query on a specific node, with optional configuration.

```rust
pub fn ts_query_cursor_exec(self_: *mut TSQueryCursor, query: *const TSQuery, node: TSNode);
pub fn ts_query_cursor_exec_with_options(
    self_: *mut TSQueryCursor,
    query: *const TSQuery,
    node: TSNode,
    query_options: *const TSQueryCursorOptions,
);
```

--------------------------------

### Library Module Configuration and Imports

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=std%3A%3Avec

Initial module setup including conditional compilation for no_std environments and necessary external imports.

```rust
1#![cfg_attr(not(any(test, doctest)), doc = include_str!("./README.md"))]
2#![cfg_attr(not(feature = "std"), no_std)]
3#![cfg_attr(docsrs, feature(doc_cfg))]
4
5pub mod ffi;
6mod util;
7
8#[cfg(not(feature = "std"))]
9extern crate alloc;
10#[cfg(not(feature = "std"))]
11use alloc::{boxed::Box, format, string::String, string::ToString, vec::Vec};
12use core::{
13    ffi::{c_char, c_void, CStr},
14    fmt::{self, Write},
15    hash, iter,
16    marker::PhantomData,
17    mem::MaybeUninit,
18    num::NonZeroU16,
19    ops::{self, ControlFlow, Deref},
20    ptr::{self, NonNull},
21    slice, str,
22};
23#[cfg(feature = "std")]
24use std::error;
25#[cfg(all(unix, feature = "std"))]
26use std::os::fd::AsRawFd;
27#[cfg(all(windows, feature = "std"))]
28use std::os::windows::io::AsRawHandle;
29
30pub use streaming_iterator::{StreamingIterator, StreamingIteratorMut};
31use tree_sitter_language::LanguageFn;
32
33#[cfg(feature = "wasm")]
34mod wasm_language;
35#[cfg(feature = "wasm")]
36#[cfg_attr(docsrs, doc(cfg(feature = "wasm")))]
37pub use wasm_language::*;
```

--------------------------------

### ts_query_cursor_exec

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/tree-sitter/a65eccf90197d882/out/bindings.rs.html?search=

Starts running a query on a specific node.

```APIDOC
## ts_query_cursor_exec

### Description
Starts running a given query on a given syntax node.

### Signature
`void ts_query_cursor_exec(TSQueryCursor *self, const TSQuery *query, TSNode node)`
```

--------------------------------

### Asserting Option equality

Source: https://docs.rs/tree-sitter/latest/tree_sitter/ffi/type.TSDecodeFunction.html?search=std%3A%3Avec

A basic assertion example for an Option value.

```rust
assert_eq!(Some(67), o);
```

--------------------------------

### Create Tree Cursor

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=

Initializes a new TreeCursor starting from the root of the tree.

```rust
pub fn walk(&self) -> TreeCursor {
        self.root_node().walk()
    }
```

--------------------------------

### Get Node Positions

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html

Methods to retrieve the start and end positions of a node as Point objects.

```rust
    #[doc(alias = "ts_node_start_point")]
    #[must_use]
    pub fn start_position(&self) -> Point {
        let result = unsafe { ffi::ts_node_start_point(self.0) };
        result.into()
    }
```

```rust
    #[doc(alias = "ts_node_end_point")]
    #[must_use]
    pub fn end_position(&self) -> Point {
        let result = unsafe { ffi::ts_node_end_point(self.0) };
        result.into()
    }
```

--------------------------------

### ts_node_first_named_child_for_byte

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/tree-sitter/a65eccf90197d882/out/bindings.rs.html?search=std%3A%3Avec

Get the node's first named child that contains or starts after the given byte offset.

```APIDOC
## ts_node_first_named_child_for_byte

### Description
Get the node's first named child that contains or starts after the given byte offset.

### Signature
`pub fn ts_node_first_named_child_for_byte(self_: TSNode, byte: u32) -> TSNode;`
```

--------------------------------

### Initialize Wasm Parser

Source: https://docs.rs/tree-sitter/latest/index.html

Set up a parser with a Wasm store to support dynamic grammar loading.

```rust
use tree_sitter::{wasmtime::Engine, Parser, WasmStore};

let engine = Engine::default();
let store = WasmStore::new(&engine).unwrap();

let mut parser = Parser::new();
parser.set_wasm_store(store).unwrap();
```

--------------------------------

### ParseOptions::new

Source: https://docs.rs/tree-sitter/latest/tree_sitter/struct.ParseOptions.html

Creates a new instance of ParseOptions with default settings.

```APIDOC
## pub fn new() -> Self

### Description
Creates a new instance of `ParseOptions` with default values.

### Returns
- **Self** - A new `ParseOptions` instance.
```

--------------------------------

### Retrieve node start point

Source: https://docs.rs/tree-sitter/latest/tree_sitter/ffi/fn.ts_node_start_point.html?search=

This function returns the start position of a node as a TSPoint structure.

```rust
pub unsafe extern "C" fn ts_node_start_point(self_: TSNode) -> TSPoint
```

--------------------------------

### QueryCursor Initialization and Configuration

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for creating and configuring a QueryCursor to execute queries.

```rust
impl Default for QueryCursor {
    fn default() -> Self {
        Self::new()
    }
}
```

```rust
pub fn new() -> Self {
    Self {
        ptr: unsafe { NonNull::new_unchecked(ffi::ts_query_cursor_new()) },
    }
}
```

```rust
pub fn match_limit(&self) -> u32 {
    unsafe { ffi::ts_query_cursor_match_limit(self.ptr.as_ptr()) }
}
```

--------------------------------

### next_state

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=u32+-%3E+bool

Get the next parse state.

```APIDOC
## fn next_state(&self, state: u16, id: u16) -> u16

### Description
Get the next parse state. Combine this with lookahead_iterator to generate completion suggestions or valid symbols in error nodes.
```

--------------------------------

### Parser Configuration Methods

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=

Methods for initializing and configuring the parser instance.

```APIDOC
## Parser::new()

### Description
Creates a new parser instance.

## Parser::set_language(&mut self, language: &Language) -> Result<(), LanguageError>

### Description
Sets the language that the parser should use for parsing. Returns an error if the language version is incompatible with the library.

## Parser::language(&self) -> Option<LanguageRef<'_>>

### Description
Retrieves the parser's current language.

## Parser::set_logger(&mut self, logger: Option<Logger>)

### Description
Sets the logging callback that the parser should use during parsing.

## Parser::print_dot_graphs(&mut self, file: &impl AsRawFd/AsRawHandle)

### Description
Sets the destination to which the parser should write debugging graphs in the DOT language.
```

--------------------------------

### ts_node_string

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/tree-sitter/a65eccf90197d882/out/bindings.rs.html

Get an S-expression representing the node as a string.

```APIDOC
## ts_node_string

### Description
Returns an S-expression string representation of the node. The caller is responsible for freeing the returned string using `free`.

### Signature
`char* ts_node_string(TSNode self)`
```

--------------------------------

### QueryCursorOptions::new

Source: https://docs.rs/tree-sitter/latest/tree_sitter/struct.QueryCursorOptions.html?search=

Creates a new instance of QueryCursorOptions with default settings.

```APIDOC
### pub fn new() -> Self

Creates a new `QueryCursorOptions` instance.
```

--------------------------------

### QueryCursorOptions::new

Source: https://docs.rs/tree-sitter/latest/tree_sitter/struct.QueryCursorOptions.html

Creates a new instance of QueryCursorOptions with default settings.

```APIDOC
## pub fn new() -> Self

### Description
Creates a new instance of `QueryCursorOptions` with default values.
```

--------------------------------

### ts_node_start_byte

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/tree-sitter/a65eccf90197d882/out/bindings.rs.html?search=u32+-%3E+bool

Retrieves the starting byte offset of a syntax node.

```APIDOC
## ts_node_start_byte

### Description
Get the node's start byte.

### Signature
`pub fn ts_node_start_byte(self_: TSNode) -> u32;`
```

--------------------------------

### field_id_for_name

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=u32+-%3E+bool

Get the numerical id for the given field name.

```APIDOC
## fn field_id_for_name(&self, field_name: impl AsRef<[u8]>) -> Option<FieldId>

### Description
Get the numerical id for the given field name.
```

--------------------------------

### Initialize a Tree-sitter Parser

Source: https://docs.rs/tree-sitter/latest/index.html

Create a new parser instance to begin the parsing process.

```rust
use tree_sitter::{InputEdit, Language, Parser, Point};

let mut parser = Parser::new();
```

--------------------------------

### Initialize a new Parser

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=u32+-%3E+bool

Creates a new parser instance using the underlying FFI.

```rust
#[must_use]
pub fn new() -> Self {
    unsafe {
        let parser = ffi::ts_parser_new();
        Self(NonNull::new_unchecked(parser))
    }
}
```

--------------------------------

### field_name_for_id

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=u32+-%3E+bool

Get the field name for the given numerical id.

```APIDOC
## fn field_name_for_id(&self, field_id: u16) -> Option<&'static str>

### Description
Get the field name for the given numerical id.
```

--------------------------------

### field_count

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=u32+-%3E+bool

Get the number of distinct field names in this language.

```APIDOC
## fn field_count(&self) -> usize

### Description
Get the number of distinct field names in this language.
```

--------------------------------

### id_for_node_kind

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=u32+-%3E+bool

Get the numeric id for the given node kind.

```APIDOC
## fn id_for_node_kind(&self, kind: &str, named: bool) -> u16

### Description
Get the numeric id for the given node kind.

### Parameters
- **kind** (&str) - The name of the node kind.
- **named** (bool) - Whether the node kind is named.
```

--------------------------------

### QueryProperty::new

Source: https://docs.rs/tree-sitter/latest/tree_sitter/struct.QueryProperty.html

Creates a new QueryProperty instance.

```APIDOC
## fn new(key: &str, value: Option<&str>, capture_id: Option<usize>) -> Self

### Description
Creates a new QueryProperty with the specified key, optional value, and optional capture ID.

### Parameters
- **key** (&str) - Required - The key for the property.
- **value** (Option<&str>) - Required - The optional value associated with the key.
- **capture_id** (Option<usize>) - Required - The optional capture ID associated with the property.
```

--------------------------------

### ts_node_child

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/tree-sitter/a65eccf90197d882/out/bindings.rs.html

Get the node's child at the given index.

```APIDOC
## ts_node_child

### Description
Retrieves the child node at the specified index, where zero is the first child.

### Signature
`TSNode ts_node_child(TSNode self, uint32_t child_index)`
```

--------------------------------

### Query implementation methods

Source: https://docs.rs/tree-sitter/latest/tree_sitter/struct.Query.html?search=

Methods for creating, managing, and inspecting Query objects.

```rust
pub unsafe fn from_raw( ptr: *mut TSQuery, source: &str, ) -> Result<Self, QueryError>
```

```rust
pub fn into_raw(self) -> *mut TSQuery
```

```rust
pub fn new(language: &Language, source: &str) -> Result<Self, QueryError>
```

```rust
pub fn new_raw( language: &Language, source: &str, ) -> Result<*mut TSQuery, QueryError>
```

```rust
pub fn start_byte_for_pattern(&self, pattern_index: usize) -> usize
```

```rust
pub fn end_byte_for_pattern(&self, pattern_index: usize) -> usize
```

```rust
pub fn pattern_count(&self) -> usize
```

```rust
pub const fn capture_names(&self) -> &[&str]
```

```rust
pub const fn capture_quantifiers(&self, index: usize) -> &[CaptureQuantifier]
```

```rust
pub fn capture_index_for_name(&self, name: &str) -> Option<u32>
```

```rust
pub const fn property_predicates( &self, index: usize, ) -> &[(QueryProperty, bool)]
```

```rust
pub const fn property_settings(&self, index: usize) -> &[QueryProperty]
```

```rust
pub const fn general_predicates(&self, index: usize) -> &[QueryPredicate]
```

```rust
pub fn disable_capture(&mut self, name: &str)
```

```rust
pub fn disable_pattern(&mut self, index: usize)
```

```rust
pub fn is_pattern_rooted(&self, index: usize) -> bool
```

```rust
pub fn is_pattern_non_local(&self, index: usize) -> bool
```

```rust
pub fn is_pattern_guaranteed_at_step(&self, byte_offset: usize) -> bool
```

--------------------------------

### ts_node_start_point

Source: https://docs.rs/tree-sitter/latest/tree_sitter/ffi/fn.ts_node_start_point.html

Retrieves the start position of a node in terms of rows and columns.

```APIDOC
## ts_node_start_point

### Description
Get the node's start position in terms of rows and columns.

### Signature
`pub unsafe extern "C" fn ts_node_start_point(self_: TSNode) -> TSPoint`

### Parameters
- **self_** (TSNode) - The node for which to retrieve the start position.

### Returns
- **TSPoint** - The starting row and column position of the node.
```

--------------------------------

### Configure Parse and Query Options

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html

Methods for creating and reborrowing options for parsers and query cursors, including progress callback support.

```rust
impl<'a> ParseOptions<'a> {
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    #[must_use]
    pub fn progress_callback<F: FnMut(&ParseState) -> ControlFlow<()>>(
        mut self,
        callback: &'a mut F,
    ) -> Self {
        self.progress_callback = Some(callback);
        self
    }

    #[must_use]
    pub fn reborrow(&mut self) -> ParseOptions {
        ParseOptions {
            progress_callback: match &mut self.progress_callback {
                Some(cb) => Some(*cb),
                None => None,
            },
        }
    }
}
```

```rust
impl<'a> QueryCursorOptions<'a> {
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    #[must_use]
    pub fn progress_callback<F: FnMut(&QueryCursorState) -> ControlFlow<()>>(
        mut self,
        callback: &'a mut F,
    ) -> Self {
        self.progress_callback = Some(callback);
        self
    }

    #[must_use]
    pub fn reborrow(&mut self) -> QueryCursorOptions {
        QueryCursorOptions {
            progress_callback: match &mut self.progress_callback {
                Some(cb) => Some(*cb),
                None => None,
            },
        }
    }
}
```

--------------------------------

### ts_parser_reset

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/tree-sitter/a65eccf90197d882/out/bindings.rs.html?search=

Resets the parser state to start a new parse from the beginning.

```APIDOC
## ts_parser_reset

### Description
Instruct the parser to start the next parse from the beginning, clearing any state from previous failed parses.

### Signature
`void ts_parser_reset(self_: *mut TSParser)`

### Parameters
- **self_** (*mut TSParser) - The parser instance.
```

--------------------------------

### Parser::new

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=std%3A%3Avec

Creates a new parser instance.

```APIDOC
### Method
`pub fn new() -> Self`

### Description
Creates a new instance of a Tree-sitter parser.
```

--------------------------------

### Configure QueryCursorOptions

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=u32+-%3E+bool

Methods for creating and reborrowing query cursor options with progress callbacks.

```rust
impl<'a> QueryCursorOptions<'a> {
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    #[must_use]
    pub fn progress_callback<F: FnMut(&QueryCursorState) -> ControlFlow<()>>(
        mut self,
        callback: &'a mut F,
    ) -> Self {
        self.progress_callback = Some(callback);
        self
    }

    #[must_use]
    pub fn reborrow(&mut self) -> QueryCursorOptions {
        QueryCursorOptions {
            progress_callback: match &mut self.progress_callback {
                Some(cb) => Some(*cb),
                None => None,
            },
        }
    }
}
```

--------------------------------

### Get Root Node

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=std%3A%3Avec

Retrieves the root node of the syntax tree.

```rust
pub fn root_node(&self) -> Node {
        Node::new(unsafe { ffi::ts_tree_root_node(self.0.as_ptr()) }).unwrap()
    }
```

--------------------------------

### Parser State Transition Macros

Source: https://docs.rs/tree-sitter/latest/tree_sitter/constant.PARSER_HEADER.html?search=std%3A%3Avec

Macros for managing lexer state transitions and token acceptance during parsing.

```c
\
  next_state:                   \
  lexer->advance(lexer, skip);  \
  start:                        \
  skip = false;                 \
  lookahead = lexer->lookahead;

#define ADVANCE(state_value) \
  {                          \
    state = state_value;     \
    goto next_state;         \
  }

#define ADVANCE_MAP(...)                                              \
  {                                                                   \
    static const uint16_t map[] = { __VA_ARGS__ };                    \
    for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) {  \
      if (map[i] == lookahead) {                                      \
        state = map[i + 1];                                           \
        goto next_state;                                              \
      }                                                               \
    }                                                                 \
  }

#define SKIP(state_value) \
  {                       \
    skip = true;          \
    state = state_value;  \
    goto next_state;      \
  }

#define ACCEPT_TOKEN(symbol_value)     \
  result = true;                       \
  lexer->result_symbol = symbol_value; \
  lexer->mark_end(lexer);

#define END_STATE() return result;
```

--------------------------------

### ts_node_child_by_field_name

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/tree-sitter/a65eccf90197d882/out/bindings.rs.html

Get the node's child with the given field name.

```APIDOC
## ts_node_child_by_field_name

### Description
Retrieves a child node by its field name string.

### Signature
`TSNode ts_node_child_by_field_name(TSNode self, const char* name, uint32_t name_length)`
```

--------------------------------

### Define Library Constants and Modules

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=

Initial configuration for the library, including feature flags and module declarations.

```rust
1#![cfg_attr(not(any(test, doctest)), doc = include_str!("./README.md"))]
2#![cfg_attr(not(feature = "std"), no_std)]
3#![cfg_attr(docsrs, feature(doc_cfg))]
4
5pub mod ffi;
6mod util;
```

--------------------------------

### ts_tree_cursor_reset

Source: https://docs.rs/tree-sitter/latest/tree_sitter/ffi/fn.ts_tree_cursor_reset.html?search=

Re-initialize a tree cursor to start at the original node that the cursor was constructed with.

```APIDOC
## ts_tree_cursor_reset

### Description
Re-initialize a tree cursor to start at the original node that the cursor was constructed with.

### Signature
`pub unsafe extern "C" fn ts_tree_cursor_reset(self_: *mut TSTreeCursor, node: TSNode)`

### Parameters
- **self_** (*mut TSTreeCursor) - A pointer to the TSTreeCursor to be reset.
- **node** (TSNode) - The node to reset the cursor to.
```

--------------------------------

### Implement Language Metadata and Inspection Methods

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html

Methods for retrieving language metadata, ABI versions, and node type information from a Language instance.

```rust
impl Language {
    #[must_use]
    pub fn new(builder: LanguageFn) -> Self {
        Self(unsafe { builder.into_raw()().cast() })
    }

    /// Get the name of this language. This returns `None` in older parsers.
    #[doc(alias = "ts_language_name")]
    #[must_use]
    pub fn name(&self) -> Option<&'static str> {
        let ptr = unsafe { ffi::ts_language_name(self.0) };
        (!ptr.is_null()).then(|| unsafe { CStr::from_ptr(ptr) }.to_str().unwrap())
    }

    /// Get the ABI version number that indicates which version of the
    /// Tree-sitter CLI that was used to generate this [`Language`].
    #[doc(alias = "ts_language_abi_version")]
    #[must_use]
    pub fn abi_version(&self) -> usize {
        unsafe { ffi::ts_language_abi_version(self.0) as usize }
    }

    /// Get the metadata for this language. This information is generated by the
    /// CLI, and relies on the language author providing the correct metadata in
    /// the language's `tree-sitter.json` file.
    ///
    /// See also [`LanguageMetadata`].
    #[doc(alias = "ts_language_metadata")]
    #[must_use]
    pub fn metadata(&self) -> Option<LanguageMetadata> {
        unsafe {
            let ptr = ffi::ts_language_metadata(self.0);
            (!ptr.is_null()).then(|| (*ptr).into())
        }
    }

    /// Get the number of distinct node types in this language.
    #[doc(alias = "ts_language_symbol_count")]
    #[must_use]
    pub fn node_kind_count(&self) -> usize {
        unsafe { ffi::ts_language_symbol_count(self.0) as usize }
    }

    /// Get the number of valid states in this language.
    #[doc(alias = "ts_language_state_count")]
    #[must_use]
    pub fn parse_state_count(&self) -> usize {
        unsafe { ffi::ts_language_state_count(self.0) as usize }
    }

    /// Get a list of all supertype symbols for the language.
    #[doc(alias = "ts_language_supertypes")]
    #[must_use]
    pub fn supertypes(&self) -> &[u16] {
        let mut length = 0u32;
        unsafe {
            let ptr = ffi::ts_language_supertypes(self.0, core::ptr::addr_of_mut!(length));
            if length == 0 {
                &[]
            } else {
                slice::from_raw_parts(ptr.cast_mut(), length as usize)
            }
        }
    }

    /// Get a list of all subtype symbols for a given supertype symbol.
    #[doc(alias = "ts_language_supertype_map")]
    #[must_use]
    pub fn subtypes_for_supertype(&self, supertype: u16) -> &[u16] {
        unsafe {
            let mut length = 0u32;
            let ptr = ffi::ts_language_subtypes(self.0, supertype, core::ptr::addr_of_mut!(length));
            if length == 0 {
                &[]
            } else {
                slice::from_raw_parts(ptr.cast_mut(), length as usize)
            }
        }
    }

    /// Get the name of the node kind for the given numerical id.
    #[doc(alias = "ts_language_symbol_name")]
    #[must_use]
    pub fn node_kind_for_id(&self, id: u16) -> Option<&'static str> {
        let ptr = unsafe { ffi::ts_language_symbol_name(self.0, id) };
```

--------------------------------

### Option::as_ref Usage

Source: https://docs.rs/tree-sitter/latest/tree_sitter/ffi/type.TSDecodeFunction.html?search=u32+-%3E+bool

Converting an Option to a reference.

```rust
let text: Option<String> = Some("Hello, world!".to_string());
// First, cast `Option<String>` to `Option<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `text` on the stack.
let text_length: Option<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {text:?}");
```

--------------------------------

### ts_node_start_byte function signature

Source: https://docs.rs/tree-sitter/latest/tree_sitter/ffi/fn.ts_node_start_byte.html

The function signature for retrieving the start byte of a TSNode.

```rust
pub unsafe extern "C" fn ts_node_start_byte(self_: TSNode) -> u32
```

--------------------------------

### Point Structure Methods

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Constructor and display formatting for the Point structure.

```rust
impl Point {
    #[must_use]
    pub const fn new(row: usize, column: usize) -> Self {
        Self { row, column }
    }
}

impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "({}, {})", self.row, self.column)
    }
}
```

--------------------------------

### Execute Query with Options

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=u32+-%3E+bool

Executes a query with optional progress tracking, allowing for interruption via ControlFlow.

```rust
pub fn captures_with_options<
        'query,
        'cursor: 'query,
        'tree,
        T: TextProvider<I>,
        I: AsRef<[u8]>,
    >(
        &'cursor mut self,
        query: &'query Query,
        node: Node<'tree>,
        text_provider: T,
        options: QueryCursorOptions,
    ) -> QueryCaptures<'query, 'tree, T, I> {
        unsafe extern "C" fn progress(state: *mut ffi::TSQueryCursorState) -> bool {
            let callback = (*state)
                .payload
                .cast::<QueryProgressCallback>()
                .as_mut()
                .unwrap();
            match callback(&QueryCursorState::from_raw(state)) {
                ControlFlow::Continue(()) => false,
                ControlFlow::Break(()) => true,
            }
        }

        let query_options = options.progress_callback.map(|cb| {
            QueryCursorOptionsDrop(Box::into_raw(Box::new(ffi::TSQueryCursorOptions {
                payload: Box::into_raw(Box::new(cb)).cast::<c_void>(),
                progress_callback: Some(progress),
            })))
        });

        let ptr = self.ptr.as_ptr();
        unsafe {
            ffi::ts_query_cursor_exec_with_options(
                ptr,
                query.ptr.as_ptr(),
                node.0,
                query_options.as_ref().map_or(ptr::null_mut(), |q| q.0),
            );
        }
        QueryCaptures {
            ptr,
            query,
            text_provider,
            buffer1: Vec::default(),
            buffer2: Vec::default(),
            current_match: None,
            _options: query_options,
            _phantom: PhantomData,
        }
    }
```

--------------------------------

### Parser State and Action Macros

Source: https://docs.rs/tree-sitter/latest/tree_sitter/constant.PARSER_HEADER.html?search=u32+-%3E+bool

Macros for defining lexer state transitions, token acceptance, and parse table actions.

```c
\
  next_state:                   \
  lexer->advance(lexer, skip);  \
  start:                        \
  skip = false;                 \
  lookahead = lexer->lookahead;

#define ADVANCE(state_value) \
  {                          \
    state = state_value;     \
    goto next_state;         \
  }

#define ADVANCE_MAP(...)                                              \
  {                                                                   \
    static const uint16_t map[] = { __VA_ARGS__ };                    \
    for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) {  \
      if (map[i] == lookahead) {                                      \
        state = map[i + 1];                                           \
        goto next_state;                                              \
      }                                                               \
    }                                                                 \
  }

#define SKIP(state_value) \
  {                       \
    skip = true;          \
    state = state_value;  \
    goto next_state;      \
  }

#define ACCEPT_TOKEN(symbol_value)     \
  result = true;                       \
  lexer->result_symbol = symbol_value; \
  lexer->mark_end(lexer);

#define END_STATE() return result;

/*
 *  Parse Table Macros
 */

#define SMALL_STATE(id) ((id) - LARGE_STATE_COUNT)

#define STATE(id) id

#define ACTIONS(id) id

#define SHIFT(state_value)            \
  {{                                  \
    .shift = {                        \
      .type = TSParseActionTypeShift, \
      .state = (state_value)          \
    }                                 \
  }}

#define SHIFT_REPEAT(state_value)     \
  {{                                  \
    .shift = {                        \
      .type = TSParseActionTypeShift, \
      .state = (state_value),         \
      .repetition = true              \
    }                                 \
  }}

#define SHIFT_EXTRA()                 \
  {{                                  \
    .shift = {                        \
      .type = TSParseActionTypeShift, \
      .extra = true                   \
    }                                 \
  }}

#define REDUCE(symbol_name, children, precedence, prod_id) \
  {{                                                       \
    .reduce = {                                            \
      .type = TSParseActionTypeReduce,                     \
      .symbol = symbol_name,                               \
      .child_count = children,                             \
      .dynamic_precedence = precedence,                    \
      .production_id = prod_id                             \
    },                                                     \
  }}

#define RECOVER()                    \
  {{                                 \
    .type = TSParseActionTypeRecover \
  }}

#define ACCEPT_INPUT()              \
  {{                                \
    .type = TSParseActionTypeAccept \
  }}

#ifdef __cplusplus
}
#endif

#endif  // TREE_SITTER_PARSER_H_
```

--------------------------------

### ts_node_descendant_count

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/tree-sitter/a65eccf90197d882/out/bindings.rs.html?search=std%3A%3Avec

Get the node's number of descendants, including one for the node itself.

```APIDOC
## ts_node_descendant_count

### Description
Get the node's number of descendants, including one for the node itself.

### Signature
`pub fn ts_node_descendant_count(self_: TSNode) -> u32;`
```

--------------------------------

### Lexer State Transition Macros

Source: https://docs.rs/tree-sitter/latest/tree_sitter/constant.PARSER_HEADER.html?search=

Macros for controlling lexer state transitions and token skipping.

```c
      \
  next_state:                   \
  lexer->advance(lexer, skip);  \
  start:                        \
  skip = false;                 \
  lookahead = lexer->lookahead;

#define ADVANCE(state_value) \
  {                          \
    state = state_value;     \
    goto next_state;         \
  }

#define ADVANCE_MAP(...)                                              \
  {                                                                   \
    static const uint16_t map[] = { __VA_ARGS__ };                    \
    for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) {  \
      if (map[i] == lookahead) {                                      \
        state = map[i + 1];                                           \
        goto next_state;                                              \
      }                                                               \
    }                                                                 \
  }

#define SKIP(state_value) \
  {                       \
    skip = true;          \
    state = state_value;  \
    goto next_state;      \
  }

#define ACCEPT_TOKEN(symbol_value)     \
  result = true;                       \
  lexer->result_symbol = symbol_value; \
  lexer->mark_end(lexer);

#define END_STATE() return result;
```

--------------------------------

### ts_node_end_point

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/tree-sitter/a65eccf90197d882/out/bindings.rs.html

Get the node's end position in terms of rows and columns.

```APIDOC
## ts_node_end_point

### Description
Retrieves the end position of the node as a TSPoint (rows and columns).

### Signature
`TSPoint ts_node_end_point(TSNode self)`
```

--------------------------------

### Option::into_flat_iter Usage

Source: https://docs.rs/tree-sitter/latest/tree_sitter/ffi/type.TSDecodeFunction.html?search=u32+-%3E+bool

Example of using into_flat_iter to transform an optional iterator.

```rust
#![feature(option_into_flat_iter)]

let o1 = Some([1, 2]);
let o2 = None::<&[usize]>;

assert_eq!(o1.into_flat_iter().collect::<Vec<_>>(), [1, 2]);
assert_eq!(o2.into_flat_iter().collect::<Vec<_>>(), Vec::<&usize>::new());
```

--------------------------------

### Lexer State Transition Macros

Source: https://docs.rs/tree-sitter/latest/tree_sitter/constant.PARSER_HEADER.html

Macros for controlling lexer state transitions and token acceptance during parsing.

```c
\
  goto start;                   \
  next_state:                   \
  lexer->advance(lexer, skip);  \
  start:                        \
  skip = false;                 \
  lookahead = lexer->lookahead;
```

```c
#define ADVANCE(state_value) \
  {                          \
    state = state_value;     \
    goto next_state;         \
  }
```

```c
#define ADVANCE_MAP(...)                                              \
  {                                                                   \
    static const uint16_t map[] = { __VA_ARGS__ };                    \
    for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) {  \
      if (map[i] == lookahead) {                                      \
        state = map[i + 1];                                           \
        goto next_state;                                              \
      }                                                               \
    }                                                                 \
  }
```

```c
#define SKIP(state_value) \
  {                       \
    skip = true;          \
    state = state_value;  \
    goto next_state;      \
  }
```

```c
#define ACCEPT_TOKEN(symbol_value)     \
  result = true;                       \
  lexer->result_symbol = symbol_value; \
  lexer->mark_end(lexer);
```

```c
#define END_STATE() return result;
```

--------------------------------

### ts_query_cursor_set_max_start_depth function signature

Source: https://docs.rs/tree-sitter/latest/tree_sitter/ffi/fn.ts_query_cursor_set_max_start_depth.html

The function signature for setting the maximum start depth on a TSQueryCursor.

```rust
pub unsafe extern "C" fn ts_query_cursor_set_max_start_depth(
    self_: *mut TSQueryCursor,
    max_start_depth: u32,
)
```

--------------------------------

### Option::xor usage

Source: https://docs.rs/tree-sitter/latest/tree_sitter/ffi/type.TSDecodeFunction.html?search=u32+-%3E+bool

Demonstrates the xor method which returns Some if exactly one of the options is Some.

```rust
let x = Some(2);
let y: Option<u32> = None;
assert_eq!(x.xor(y), Some(2));

let x: Option<u32> = None;
let y = Some(2);
assert_eq!(x.xor(y), Some(2));

let x = Some(2);
let y = Some(2);
assert_eq!(x.xor(y), None);

let x: Option<u32> = None;
let y: Option<u32> = None;
assert_eq!(x.xor(y), None);
```

--------------------------------

### take

Source: https://docs.rs/tree-sitter/latest/tree_sitter/trait.StreamingIterator.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates an iterator which only returns the first n elements.

```APIDOC
## fn take(self, n: usize) -> Take<Self>

### Description
Creates an iterator which only returns the first `n` elements.
```

--------------------------------

### ts_node_descendant_for_point_range

Source: https://docs.rs/tree-sitter/latest/tree_sitter/ffi/fn.ts_node_descendant_for_point_range.html?search=

Retrieves the smallest node that contains the range of points defined by start and end.

```APIDOC
## ts_node_descendant_for_point_range

### Description
Retrieves the smallest node within the tree that spans the specified start and end points.

### Signature
`pub unsafe extern "C" fn ts_node_descendant_for_point_range(self_: TSNode, start: TSPoint, end: TSPoint) -> TSNode`

### Parameters
- **self_** (TSNode) - The parent node to search within.
- **start** (TSPoint) - The starting point of the range.
- **end** (TSPoint) - The ending point of the range.

### Returns
- **TSNode** - The smallest node that contains the specified range.
```

--------------------------------

### start_byte_for_pattern

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=

Retrieves the byte offset where a specific pattern starts within the query source.

```APIDOC
### Method
`start_byte_for_pattern(&self, pattern_index: usize) -> usize`

### Description
Returns the byte offset where the given pattern starts in the query's source. The `pattern_index` must be less than the total number of patterns in the query.
```

--------------------------------

### QueryCursorOptions Methods

Source: https://docs.rs/tree-sitter/latest/tree_sitter/struct.QueryCursorOptions.html

Methods for initializing and configuring QueryCursorOptions, including reborrowing for repeated use.

```rust
pub fn new() -> Self
```

```rust
pub fn progress_callback<F: FnMut(&QueryCursorState) -> ControlFlow<()>>( self, callback: &'a mut F, ) -> Self
```

```rust
pub fn reborrow(&mut self) -> QueryCursorOptions<'_>
```

--------------------------------

### WasmStore::new

Source: https://docs.rs/tree-sitter/latest/tree_sitter/struct.WasmStore.html

Creates a new instance of WasmStore associated with the provided Engine.

```APIDOC
### pub fn new(engine: &Engine) -> Result<Self, WasmError>

Creates a new WasmStore instance using the specified Engine. Returns a Result containing the WasmStore or a WasmError if initialization fails.
```

--------------------------------

### first_child_for_byte

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=std%3A%3Avec

Finds the first child node that contains or starts after a specific byte offset.

```APIDOC
## pub fn first_child_for_byte(&self, byte: usize) -> Option<Self>

### Description
Returns the first child node that contains or starts after the given byte offset.
```

--------------------------------

### Initialize Node

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=

Creates a new Node instance from an FFI TSNode.

```rust
fn new(node: ffi::TSNode) -> Option<Self> {
        (!node.id.is_null()).then_some(Node(node, PhantomData))
    }
```

--------------------------------

### ts_node_first_child_for_byte

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/tree-sitter/a65eccf90197d882/out/bindings.rs.html?search=

Retrieves the first child of a node that contains or starts after a specific byte offset.

```APIDOC
## ts_node_first_child_for_byte

### Description
Get the node's first child that contains or starts after the given byte offset.

### Signature
`TSNode ts_node_first_child_for_byte(TSNode self_, u32 byte)`
```

--------------------------------

### Get Included Ranges

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=std%3A%3Avec

Retrieves the current ranges of text that the parser is configured to include.

```rust
pub fn included_ranges(&self) -> Vec<Range> {
        let mut count = 0u32;
        unsafe {
            let ptr =
                ffi::ts_parser_included_ranges(self.0.as_ptr(), core::ptr::addr_of_mut!(count));
            let ranges = slice::from_raw_parts(ptr, count as usize);
            let result = ranges.iter().copied().map(Into::into).collect();
            result
        }
    }
```

--------------------------------

### Create Query Property

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html

Constructor for creating a new QueryProperty instance.

```rust
3393impl QueryProperty {
3394    #[must_use]
3395    pub fn new(key: &str, value: Option<&str>, capture_id: Option<usize>) -> Self {
3396        Self {
3397            capture_id,
3398            key: key.to_string().into(),
3399            value: value.map(|s| s.to_string().into()),
3400        }
3401    }
3402}
```

--------------------------------

### Get Parser Language and Logger

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=std%3A%3Avec

Retrieves the current language or logger associated with the parser.

```rust
pub fn language(&self) -> Option<LanguageRef<'_>> {
    let ptr = unsafe { ffi::ts_parser_language(self.0.as_ptr()) };
    (!ptr.is_null()).then_some(LanguageRef(ptr, PhantomData))
}

#[must_use]
pub fn logger(&self) -> Option<&Logger> {
    let logger = unsafe { ffi::ts_parser_logger(self.0.as_ptr()) };
    unsafe { logger.payload.cast::<Logger>().as_ref() }
}
```

--------------------------------

### QueryCursorOptions

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Configuration options for query execution, including support for progress callbacks.

```APIDOC
## QueryCursorOptions

### Description
Configuration structure for query cursor operations. Allows setting a progress callback to monitor query execution state.

### Methods
- **new()** -> QueryCursorOptions: Creates a default instance.
- **progress_callback<F>(callback: &'a mut F)** -> QueryCursorOptions: Sets a progress callback that receives a `QueryCursorState`.
- **reborrow()** -> QueryCursorOptions: Creates a new instance with a shorter lifetime, useful for reusing options.
```

--------------------------------

### TreeCursor::goto_first_child_for_byte

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=u32+-%3E+bool

Moves the cursor to the first child that contains or starts after the given byte offset.

```APIDOC
## pub fn goto_first_child_for_byte(&mut self, index: usize) -> Option<usize>

### Description
Move this cursor to the first child of its current node that contains or starts after the given byte offset.

### Parameters
- **index** (usize) - The byte offset to search from.

### Returns
- **Option<usize>** - The index of the child node if one was found, otherwise None.
```

--------------------------------

### Query::new

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=

Creates a new query from a source string.

```APIDOC
## fn new(language: &Language, source: &str) -> Result<Self, QueryError>

### Description
Create a new query from a string containing one or more S-expression patterns. The query is associated with a particular language and can only be run on syntax nodes parsed with that language.

### Parameters
- **language** (&Language) - Required - The language associated with the query.
- **source** (&str) - Required - The S-expression source string.

### Returns
- **Result<Self, QueryError>** - A new Query instance or a QueryError if compilation fails.
```

--------------------------------

### Parser::reset

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=u32+-%3E+bool

Instructs the parser to start the next parse from the beginning, clearing any previous state.

```APIDOC
## pub fn reset(&mut self)

### Description
Instructs the parser to start the next parse from the beginning. If the parser previously failed because of a callback, it will resume where it left off by default; calling this method ensures the parser starts fresh.
```

--------------------------------

### Execute Query Captures with Options

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=std%3A%3Avec

Executes a query with specific options, such as a progress callback.

```rust
    pub fn captures_with_options<
        'query,
        'cursor: 'query,
        'tree,
        T: TextProvider<I>,
        I: AsRef<[u8]>,
    >(
        &'cursor mut self,
        query: &'query Query,
        node: Node<'tree>,
        text_provider: T,
        options: QueryCursorOptions,
    ) -> QueryCaptures<'query, 'tree, T, I> {
        unsafe extern "C" fn progress(state: *mut ffi::TSQueryCursorState) -> bool {
            let callback = (*state)
                .payload
                .cast::<QueryProgressCallback>()
                .as_mut()
                .unwrap();
            match callback(&QueryCursorState::from_raw(state)) {
                ControlFlow::Continue(()) => false,
                ControlFlow::Break(()) => true,
            }
        }

        let query_options = options.progress_callback.map(|cb| {
            QueryCursorOptionsDrop(Box::into_raw(Box::new(ffi::TSQueryCursorOptions {
                payload: Box::into_raw(Box::new(cb)).cast::<c_void>(),
                progress_callback: Some(progress),
            })))
        });

        let ptr = self.ptr.as_ptr();
        unsafe {
            ffi::ts_query_cursor_exec_with_options(
                ptr,
                query.ptr.as_ptr(),
                node.0,
                query_options.as_ref().map_or(ptr::null_mut(), |q| q.0),
            );
        }
        QueryCaptures {
            ptr,
            query,
            text_provider,
            buffer1: Vec::default(),
            buffer2: Vec::default(),
            current_match: None,
            _options: query_options,
            _phantom: PhantomData,
        }
    }
```

--------------------------------

### Configure ParseOptions

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=u32+-%3E+bool

Methods for creating and reborrowing parse options with progress callbacks.

```rust
impl<'a> ParseOptions<'a> {
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    #[must_use]
    pub fn progress_callback<F: FnMut(&ParseState) -> ControlFlow<()>>(
        mut self,
        callback: &'a mut F,
    ) -> Self {
        self.progress_callback = Some(callback);
        self
    }

    #[must_use]
    pub fn reborrow(&mut self) -> ParseOptions {
        ParseOptions {
            progress_callback: match &mut self.progress_callback {
                Some(cb) => Some(*cb),
                None => None,
            },
        }
    }
}
```

--------------------------------

### Get TSQueryCursor match limit

Source: https://docs.rs/tree-sitter/latest/tree_sitter/ffi/fn.ts_query_cursor_match_limit.html

Retrieves the current match limit for the specified query cursor.

```rust
pub unsafe extern "C" fn ts_query_cursor_match_limit(
    self_: *const TSQueryCursor,
) -> u32
```

--------------------------------

### Query Cursor State and Options

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/tree-sitter/a65eccf90197d882/out/bindings.rs.html

Structures for managing query cursor state and optional progress callbacks.

```rust
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct TSQueryCursorState {
    pub payload: *mut ::core::ffi::c_void,
    pub current_byte_offset: u32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct TSQueryCursorOptions {
    pub payload: *mut ::core::ffi::c_void,
    pub progress_callback:
        ::core::option::Option<unsafe extern "C" fn(state: *mut TSQueryCursorState) -> bool>,
}
```

--------------------------------

### Get the language of a lookahead iterator

Source: https://docs.rs/tree-sitter/latest/tree_sitter/ffi/fn.ts_lookahead_iterator_language.html?search=

Retrieves the current TSLanguage associated with the provided TSLookaheadIterator pointer.

```rust
pub unsafe extern "C" fn ts_lookahead_iterator_language(
    self_: *const TSLookaheadIterator,
) -> *const TSLanguage
```

--------------------------------

### Debug and TextProvider Implementations

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Formatting and text retrieval traits for query matches and text providers.

```rust
impl fmt::Debug for QueryMatch<'_, '_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "QueryMatch {{ id: {}, pattern_index: {}, captures: {:?} }}",
            self.id, self.pattern_index, self.captures
        )
    }
}

impl<F, R, I> TextProvider<I> for F
where
    F: FnMut(Node) -> R,
    R: Iterator<Item = I>,
    I: AsRef<[u8]>,
{
    type I = R;

    fn text(&mut self, node: Node) -> Self::I {
        (self)(node)
    }
}

impl<'a> TextProvider<&'a [u8]> for &'a [u8] {
    type I = iter::Once<&'a [u8]>;

    fn text(&mut self, node: Node) -> Self::I {
        iter::once(&self[node.byte_range()])
    }
}
```

--------------------------------

### Retrieve Node Kind ID

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=std%3A%3Avec

Get the numeric identifier for a specific node kind string.

```rust
pub fn id_for_node_kind(&self, kind: &str, named: bool) -> u16 {
    unsafe {
        ffi::ts_language_symbol_for_name(
            self.0,
            kind.as_bytes().as_ptr().cast::<c_char>(),
            kind.len() as u32,
            named,
        )
    }
}
```

--------------------------------

### Implement TextProvider for byte slices

Source: https://docs.rs/tree-sitter/latest/tree_sitter/trait.TextProvider.html

Implementation of TextProvider for references to byte slices.

```rust
impl<'a> TextProvider<&'a [u8]> for &'a [u8]
Source§
#### type I = Once<&'a [u8]>
Source§
#### fn text(&mut self, node: Node<'_>) -> Self::I
```

--------------------------------

### Retrieve Node Range and Position

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/lib.rs.html?search=u32+-%3E+bool

Methods to get the byte range and row/column coordinates of a node.

```rust
pub fn range(&self) -> Range {
    Range {
        start_byte: self.start_byte(),
        end_byte: self.end_byte(),
        start_point: self.start_position(),
        end_point: self.end_position(),
    }
}
```

```rust
pub fn start_position(&self) -> Point {
    let result = unsafe { ffi::ts_node_start_point(self.0) };
    result.into()
}
```

```rust
pub fn end_position(&self) -> Point {
    let result = unsafe { ffi::ts_node_end_point(self.0) };
    result.into()
}
```

--------------------------------

### Context Trait Implementation

Source: https://docs.rs/tree-sitter/latest/tree_sitter/ffi/type.TSDecodeFunction.html?search=u32+-%3E+bool

Example of using the Context trait with Option to provide error context.

```rust
use anyhow::{Context, Result};

fn maybe_get() -> Option<T> {
    ...
}

fn demo() -> Result<()> {
    let t = maybe_get().context("there is no T")?;
    ...
}
```

--------------------------------

### Create a new query cursor

Source: https://docs.rs/tree-sitter/latest/src/tree_sitter/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/tree-sitter/a65eccf90197d882/out/bindings.rs.html?search=std%3A%3Avec

Initializes a new cursor for executing queries on syntax nodes.

```rust
pub fn ts_query_cursor_new() -> *mut TSQueryCursor;
```

--------------------------------

### Define Language Dependencies

Source: https://docs.rs/tree-sitter/latest/index.html

Add the required language crates to your Cargo.toml file.

```toml
[dependencies]
tree-sitter = "0.24"
tree-sitter-rust = "0.23"
```

--------------------------------

### edit_range

Source: https://docs.rs/tree-sitter/latest/tree_sitter/struct.InputEdit.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Updates a range's start and end positions to keep it in-sync with source code that has been edited.

```APIDOC
## pub fn edit_range(&self, range: &mut Range)

### Description
Edit a range to keep it in-sync with source code that has been edited. This function updates a range’s start and end positions based on this edit operation.

### Parameters
- **range** (&mut Range) - The range to update.
```

--------------------------------

### ts_query_start_byte_for_pattern Function Signature

Source: https://docs.rs/tree-sitter/latest/tree_sitter/ffi/fn.ts_query_start_byte_for_pattern.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The FFI function signature for retrieving the start byte offset of a pattern in a TSQuery.

```rust
pub unsafe extern "C" fn ts_query_start_byte_for_pattern(
    self_: *const TSQuery,
    pattern_index: u32,
) -> u32
```
Tokens:
Raw