Enum Expr 

pub enum Expr {
    Literal(Literal),
    Variable(VariableExpr),
    Reference(ReferenceExpr),
    Dict(Dict),
    List(List),
    Tuple(Tuple),
    Spread(SpreadExpr),
    Comprehension(Comprehension),
    Binary(BinaryExpr),
    Unary(UnaryExpr),
    Ternary(TernaryExpr),
    Call(CallExpr),
    FString(FString),
    Type(TypeNode),
    Wildcard(Wildcard),
    Where(WhereExpr),
    Match(MatchExpr),
    Closure(Closure),
    VariantCtor(VariantCtor),
    Error(ErrorNode),
}

Typed view over any expression-shaped CST node. Returned by Expr::cast.

Note the variant naming follows the CST kinds, not the legacy crate::Expr enum — Literal covers true / false / numeric / string atoms uniformly, plus the removed null spelling for diagnostics. The legacy enum split them into Bool / Int / Float / String plus internal Missing. Downstream callers that need the specific literal type read it from Literal::kind / Literal::value_text.

Variants

Literal(Literal)

Variable(VariableExpr)

Reference(ReferenceExpr)

Dict(Dict)

List(List)

Tuple(Tuple)

Spread(SpreadExpr)

Comprehension(Comprehension)

Binary(BinaryExpr)

Unary(UnaryExpr)

Ternary(TernaryExpr)

Call(CallExpr)

FString(FString)

Type(TypeNode)

Wildcard(Wildcard)

Where(WhereExpr)

Match(MatchExpr)

Closure(Closure)

VariantCtor(VariantCtor)

Error(ErrorNode)

New variant introduced by the CST rewrite — spans bytes the parser couldn’t fit into any production. Downstream callers must handle it (typically by skipping or surfacing a diagnostic).

Implementations

impl Expr

pub fn cast(node: SyntaxNode) -> Option<Self>

Wrap node if it names an expression-shaped CST kind. Returns None for non-expression nodes (DICT_FIELD, CLOSURE_PARAM, etc.) — those have their own typed wrappers.

pub fn syntax(&self) -> &SyntaxNode

Borrow the underlying SyntaxNode regardless of variant.

pub fn text(&self) -> String

Verbatim source text. Convenience over self.syntax().text().

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Eq for Expr

impl Hash for Expr

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 Expr

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