Enum 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

A child node.

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

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<'a> Intern<'a, dyn SyntaxGroup + 'a, SyntaxStablePtrId> for SyntaxStablePtr

fn intern( self, db: &(impl Upcast<dyn SyntaxGroup + 'a> + ?Sized), ) -> SyntaxStablePtrId

impl<'a> LookupIntern<'a, dyn SyntaxGroup + 'a, SyntaxStablePtr> for SyntaxStablePtrId

fn lookup_intern( &self, db: &(impl Upcast<dyn SyntaxGroup + 'a> + ?Sized), ) -> SyntaxStablePtr

impl PartialEq for SyntaxStablePtr

fn eq(&self, other: &SyntaxStablePtr) -> 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 Eq for SyntaxStablePtr

impl StructuralPartialEq for SyntaxStablePtr