Enum cairo_lang_syntax::node::stable_ptr::SyntaxStablePtr

pub enum SyntaxStablePtr {
    Root(FileId, GreenId),
    Child {
        parent: SyntaxStablePtrId,
        kind: SyntaxKind,
        key_fields: Vec<GreenId>,
        index: usize,
    },
}

Stable pointer to a node in the syntax tree. Has enough information to uniquely define a node in the AST, given the tree. Has undefined behavior when used with the wrong tree. This is not a real pointer in the low-level sense, just a representation of the path from the root to the node. Stable means that when the AST is changed, pointers of unchanged items tend to stay the same. For example, if a function is changed, the pointer of an unrelated function in the AST should remain the same, as much as possible.

Variants

Root(FileId, GreenId)

The root node of the tree.

Child

Fields

parent: SyntaxStablePtrId

The parent of the node.

kind: SyntaxKind

The SyntaxKind of the node.

key_fields: Vec<GreenId>

A list of field values for this node, to index by. Which fields are used is determined by each SyntaxKind. For example, a function item might use the name of the function.

index: usize

Chronological index among all nodes with the same (parent, kind, key_fields).

A child node.

Trait Implementations

impl Clone for SyntaxStablePtr

fn clone(&self) -> SyntaxStablePtr

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SyntaxStablePtr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for SyntaxStablePtr

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SyntaxStablePtr

fn eq(&self, other: &SyntaxStablePtr) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for SyntaxStablePtr

impl StructuralPartialEq for SyntaxStablePtr