Enum AstNodeType 

pub enum AstNodeType {
    Function,
    Parameter,
    Return,
    Variable,
    Assignment,
    BinaryOp,
    UnaryOp,
    Conditional,
    Loop,
    Call,
    Literal,
    Index,
    FieldAccess,
    Block,
    TypeAnnotation,
    Generic,
    Match,
    MatchArm,
    Struct,
    Enum,
    Trait,
    Impl,
    Module,
    Import,
}

Types of AST nodes for code analysis

Variants

Function

Function or method definition

Parameter

Function/method parameter

Return

Return statement or expression

Variable

Variable declaration

Assignment

Assignment expression

BinaryOp

Binary operation (e.g., +, -, *, /)

UnaryOp

Unary operation (e.g., !, -)

Conditional

If/else conditional

Loop

Loop construct (for, while, loop)

Call

Function call expression

Literal

Literal value (number, string, bool)

Index

Array/vector access

FieldAccess

Field access (e.g., obj.field)

Block

Block of statements

TypeAnnotation

Type annotation

Generic

Generic type parameter

Match

Match/switch expression

MatchArm

Match arm

Struct

Struct definition

Enum

Enum definition

Trait

Trait/interface definition

Impl

Implementation block

Module

Module declaration

Import

Import/use statement

Trait Implementations

impl Clone for AstNodeType

fn clone(&self) -> AstNodeType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AstNodeType

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

Formats the value using the given formatter.

impl Display for AstNodeType

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

Formats the value using the given formatter.

impl Hash for AstNodeType

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 AstNodeType

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

impl Eq for AstNodeType

impl StructuralPartialEq for AstNodeType