Enum SyntaxStablePtr 

pub enum SyntaxStablePtr<'a> {
    Root(FileId<'a>, GreenId<'a>),
    Child {
        parent: SyntaxStablePtrId<'a>,
        kind: SyntaxKind,
        key_fields: Box<[GreenId<'a>]>,
        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<'a>, GreenId<'a>)

The root node of the tree.

Child

A child node.

Fields

parent: SyntaxStablePtrId<'a>

The parent of the node.

kind: SyntaxKind

The SyntaxKind of the node.

key_fields: Box<[GreenId<'a>]>

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).

Trait Implementations

impl<'a> Clone for SyntaxStablePtr<'a>

fn clone(&self) -> SyntaxStablePtr<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for SyntaxStablePtr<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for SyntaxStablePtr<'a>

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<'db> Intern<'db, SyntaxStablePtrId<'db>> for SyntaxStablePtr<'db>

fn intern(self, db: &'db dyn Database) -> SyntaxStablePtrId<'db>

impl<'a> PartialEq for SyntaxStablePtr<'a>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> Eq for SyntaxStablePtr<'a>

impl<'a> StructuralPartialEq for SyntaxStablePtr<'a>