Enum Expr 

pub enum Expr<'de> {
    Lit(ExprLit<'de>),
    Ident(ExprIdent<'de>),
    Path(ExprPath<'de>),
    Paren(ExprParen<'de>),
    Bool(ExprBool<'de>),
    Nullptr(ExprNullptr<'de>),
    This(ExprThis<'de>),
    Unary(ExprUnary<'de>),
    Binary(ExprBinary<'de>),
    Conditional(ExprConditional<'de>),
    Call(ExprCall<'de>),
    MethodCall(ExprMethodCall<'de>),
    Index(ExprIndex<'de>),
    Field(ExprField<'de>),
    Cast(ExprCast<'de>),
    CStyleCast(ExprCStyleCast<'de>),
    Sizeof(ExprSizeof<'de>),
    Alignof(ExprAlignof<'de>),
    New(ExprNew<'de>),
    Delete(ExprDelete<'de>),
    Throw(ExprThrow<'de>),
    Lambda(ExprLambda<'de>),
    Typeid(ExprTypeid<'de>),
    InitList(ExprInitList<'de>),
}

A C++ expression, analogous to syn::Expr.

Variants

Lit(ExprLit<'de>)

Literal value: 42, 3.14, "hello", 'a'

Ident(ExprIdent<'de>)

Simple identifier: foo

Path(ExprPath<'de>)

Qualified path: std::cout, ::global

Paren(ExprParen<'de>)

Parenthesized expression: (expr)

Bool(ExprBool<'de>)

Boolean literal: true / false

Nullptr(ExprNullptr<'de>)

nullptr

This(ExprThis<'de>)

this

Unary(ExprUnary<'de>)

Unary expression: -x, !flag, *ptr, ++i, i++

Binary(ExprBinary<'de>)

Binary expression: a + b, x = 1

Conditional(ExprConditional<'de>)

Ternary conditional: a ? b : c

Call(ExprCall<'de>)

Function call: foo(a, b)

MethodCall(ExprMethodCall<'de>)

Method call: obj.method(a, b)

Index(ExprIndex<'de>)

Array subscript: arr[i]

Field(ExprField<'de>)

Member access: obj.field

Cast(ExprCast<'de>)

C++ named cast: static_cast<int>(x)

CStyleCast(ExprCStyleCast<'de>)

C-style cast: (int)x

Sizeof(ExprSizeof<'de>)

sizeof(expr) or sizeof expr

Alignof(ExprAlignof<'de>)

alignof(type)

New(ExprNew<'de>)

new expression: new int(42)

Delete(ExprDelete<'de>)

delete expression: delete ptr

Throw(ExprThrow<'de>)

throw expression: throw runtime_error("...")

Lambda(ExprLambda<'de>)

Lambda expression: [captures](params) { body }

Typeid(ExprTypeid<'de>)

typeid(expr) or typeid(type)

InitList(ExprInitList<'de>)

Braced initializer list: {1, 2, 3}

Trait Implementations

impl<'de> Clone for Expr<'de>

fn clone(&self) -> Expr<'de>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'de> Debug for Expr<'de>

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

Formats the value using the given formatter.

impl<'de> PartialEq for Expr<'de>

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