Trait Node 

pub trait Node<'tree>:
    Debug
    + Clone
    + Copy
    + PartialEq
    + Eq
    + Hash {
    type WithLifetime<'a>: Node<'a>;

    const KIND: &'static str;

    // Required methods
    fn try_from_raw(node: Node<'tree>) -> NodeResult<'tree, Self>;
    fn raw(&self) -> &Node<'tree>;
    fn raw_mut(&mut self) -> &mut Node<'tree>;
    fn into_raw(self) -> Node<'tree>;

    // Provided methods
    unsafe fn from_raw_unchecked(node: Node<'tree>) -> Self { ... }
    fn upcast(self) -> UntypedNode<'tree> { ... }
    fn utf8_text<'a>(&self, source: &'a [u8]) -> Result<&'a str, Utf8Error> { ... }
    fn utf16_text<'a>(&self, source: &'a [u16]) -> &'a [u16] { ... }
    fn prefixes(&self) -> impl Iterator<Item = UntypedNode<'tree>> { ... }
    fn suffixes(&self) -> impl Iterator<Item = UntypedNode<'tree>> { ... }
    fn walk(&self) -> TreeCursor<'tree> { ... }
    fn parent(&self) -> Option<UntypedNode<'tree>> { ... }
    fn next_named_sibling(&self) -> Option<UntypedNode<'tree>> { ... }
    fn prev_named_sibling(&self) -> Option<UntypedNode<'tree>> { ... }
    fn named_child_count(&self) -> usize { ... }
    fn to_sexp(&self) -> String { ... }
    fn kind(&self) -> &'static str { ... }
    fn is_named(&self) -> bool { ... }
    fn has_changes(&self) -> bool { ... }
    fn has_error(&self) -> bool { ... }
    fn start_byte(&self) -> usize { ... }
    fn end_byte(&self) -> usize { ... }
    fn start_position(&self) -> Point { ... }
    fn end_position(&self) -> Point { ... }
    fn range(&self) -> Range { ... }
    fn byte_range(&self) -> Range<usize> { ... }
    fn edit(&mut self, edit: &InputEdit) { ... }
}

Typed node wrapper.

This implements TryFrom<tree_sitter::Node<'tree>>, which will succeed iff the node is of the correct type. That is how you convert untyped nodes into types nodes. If you’re absolutely sure the node is correct, you may also use Node::from_raw_unchecked, though it’s honestly probably not worth the possible performance gain.

You can get extra nodes (e.g. comments) that are before and after this node with prefixes and suffixes.

Required Associated Constants

const KIND: &'static str

Kind of nodes this wraps.

For nodes that map directly to tree-sitter nodes, this is the tree-sitter node’s name. For nodes like unions, UntypedNode, or NodeResults, which don’t have a simple kind (especially static), this is {...}.

Required Associated Types

type WithLifetime<'a>: Node<'a>

The same type, but with a different lifetime.

Required Methods

fn try_from_raw(node: Node<'tree>) -> NodeResult<'tree, Self>

Check that the tree-sitter node is the correct kind, and if it is, wrap.

Returns Err if the node is not of the correct kind.

fn raw(&self) -> &Node<'tree>

The wrapped tree-sitter node.

Note that most methods you should call on this struct directly.

fn raw_mut(&mut self) -> &mut Node<'tree>

The wrapped tree-sitter node (mutable reference, rarely needed).

Note that most methods you should call on this struct directly.

fn into_raw(self) -> Node<'tree>

Destruct into the wrapped tree-sitter node.

Note that most methods you should call on this struct directly.

Provided Methods

unsafe fn from_raw_unchecked(node: Node<'tree>) -> Self

Assume that tree-sitter node is the correct kind and wrap.

Safety

The node must be of the correct kind.

fn upcast(self) -> UntypedNode<'tree>

Upcast into an untyped node.

The inverse is UntypedNode::downcast.

fn utf8_text<'a>(&self, source: &'a [u8]) -> Result<&'a str, Utf8Error>

See tree-sitter’s Node::utf8_text

fn utf16_text<'a>(&self, source: &'a [u16]) -> &'a [u16]

See tree-sitter’s Node::utf16_text

fn prefixes(&self) -> impl Iterator<Item = UntypedNode<'tree>>

Returns any extra nodes before this one, e.g., comments.

Nodes are iterated first to last (by source location).

fn suffixes(&self) -> impl Iterator<Item = UntypedNode<'tree>>

Returns any extra nodes after this one, e.g., comments.

Nodes are iterated first to last (by source location).

fn walk(&self) -> TreeCursor<'tree>

Get a cursor for this node

fn parent(&self) -> Option<UntypedNode<'tree>>

Get the node’s immediate parent

fn next_named_sibling(&self) -> Option<UntypedNode<'tree>>

Get the node’s immediate named next sibling

fn prev_named_sibling(&self) -> Option<UntypedNode<'tree>>

Get the node’s immediate named previous sibling

fn named_child_count(&self) -> usize

Get the number of named children

fn to_sexp(&self) -> String

Print the node as an s-expression

fn kind(&self) -> &'static str

Get this node’s tree-sitter name. See tree-sitter’s Node::kind

fn is_named(&self) -> bool

Check if this node is named. See tree-sitter’s Node::is_named

fn has_changes(&self) -> bool

Check if this node has been edited

fn has_error(&self) -> bool

Check if this node represents a syntax error or contains any syntax errors anywhere within it

fn start_byte(&self) -> usize

Get the byte offset where this node starts

fn end_byte(&self) -> usize

Get the byte offset where this node ends

fn start_position(&self) -> Point

Get the row and column where this node starts

fn end_position(&self) -> Point

Get the row and column where this node ends

fn range(&self) -> Range

Get the byte range and row and column range where this node is located

fn byte_range(&self) -> Range<usize>

Get the byte range where this node is located

fn edit(&mut self, edit: &InputEdit)

Edit this node to keep it in-sync with source code that has been edited. See tree-sitter’s Node::edit

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'tree> Node<'tree> for Error<'tree>

const KIND: &'static str = "{error}"

type WithLifetime<'a> = Error<'a>

impl<'tree> Node<'tree> for Extra<'tree>

const KIND: &'static str = "{extra}"

type WithLifetime<'a> = Extra<'a>

impl<'tree> Node<'tree> for Missing<'tree>

const KIND: &'static str = "{missing}"

type WithLifetime<'a> = Missing<'a>

impl<'tree> Node<'tree> for UntypedNamedNode<'tree>

const KIND: &'static str = "{untyped named}"

type WithLifetime<'a> = UntypedNamedNode<'a>

impl<'tree> Node<'tree> for UntypedNode<'tree>

const KIND: &'static str = "{untyped}"

type WithLifetime<'a> = UntypedNode<'a>

impl<'tree, T: Node<'tree>> Node<'tree> for NodeResult<'tree, T>

const KIND: &'static str = "{result}"

type WithLifetime<'a> = Result<<T as Node<'tree>>::WithLifetime<'a>, IncorrectKind<'a>>