Enum NodeKind 

pub enum NodeKind {
    Block,
    LetBinding,
    Semi,
    Paren,
    Literal(LiteralKind),
    Placeholder(PlaceholderKind, usize),
    BinaryOp(BinOpKind),
    UnaryOp(UnOpKind),
    Range,
    Call,
    MethodCall,
    FieldAccess,
    Index,
    Path,
    Closure,
    FnSignature,
    Return,
    Break,
    Continue,
    Assign,
    Reference {
        mutable: bool,
    },
    Tuple,
    Array,
    Repeat,
    Cast,
    StructInit,
    Await,
    Try,
    If,
    Match,
    MatchArm,
    Loop,
    While,
    ForLoop,
    LetExpr,
    PatWild,
    PatPlaceholder(PlaceholderKind, usize),
    PatTuple,
    PatStruct,
    PatOr,
    PatLiteral,
    PatReference {
        mutable: bool,
    },
    PatSlice,
    PatRest,
    PatRange,
    TypePlaceholder(PlaceholderKind, usize),
    TypeReference {
        mutable: bool,
    },
    TypeTuple,
    TypeSlice,
    TypeArray,
    TypePath,
    TypeImplTrait,
    TypeInfer,
    TypeUnit,
    TypeNever,
    FieldValue,
    MacroCall {
        name: String,
    },
    Opaque,
    None,
}

The kind of a normalized AST node. Carries only non-child data (operator kinds, literal kinds, placeholder indices, mutability flags, macro names).

Variants

Block

LetBinding

Semi

Paren

Literal(LiteralKind)

Placeholder(PlaceholderKind, usize)

BinaryOp(BinOpKind)

UnaryOp(UnOpKind)

Range

Call

MethodCall

FieldAccess

Index

Path

Closure

FnSignature

Return

Break

Continue

Assign

Reference

Fields

mutable: bool

Tuple

Array

Repeat

Cast

StructInit

Await

Try

If

Match

MatchArm

Loop

While

ForLoop

LetExpr

PatWild

PatPlaceholder(PlaceholderKind, usize)

PatTuple

PatStruct

PatOr

PatLiteral

PatReference

Fields

mutable: bool

PatSlice

PatRest

PatRange

TypePlaceholder(PlaceholderKind, usize)

TypeReference

Fields

mutable: bool

TypeTuple

TypeSlice

TypeArray

TypePath

TypeImplTrait

TypeInfer

TypeUnit

TypeNever

FieldValue

MacroCall

Fields

name: String

Opaque

None

Sentinel for absent optional children, ensuring fixed child positions for correct zip alignment in similarity comparison.

Trait Implementations

impl Clone for NodeKind

fn clone(&self) -> NodeKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeKind

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

Formats the value using the given formatter.

impl Hash for NodeKind

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

where __H: Hasher,

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 NodeKind

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

impl StructuralPartialEq for NodeKind