Enum Expr

pub enum Expr {
    ArrayExpr(ArrayExpr),
    AsmExpr(AsmExpr),
    AwaitExpr(AwaitExpr),
    BecomeExpr(BecomeExpr),
    BinExpr(BinExpr),
    BlockExpr(BlockExpr),
    BreakExpr(BreakExpr),
    CallExpr(CallExpr),
    CastExpr(CastExpr),
    ClosureExpr(ClosureExpr),
    ContinueExpr(ContinueExpr),
    FieldExpr(FieldExpr),
    ForExpr(ForExpr),
    FormatArgsExpr(FormatArgsExpr),
    IfExpr(IfExpr),
    IndexExpr(IndexExpr),
    LetExpr(LetExpr),
    Literal(Literal),
    LoopExpr(LoopExpr),
    MacroExpr(MacroExpr),
    MatchExpr(MatchExpr),
    MethodCallExpr(MethodCallExpr),
    OffsetOfExpr(OffsetOfExpr),
    ParenExpr(ParenExpr),
    PathExpr(PathExpr),
    PrefixExpr(PrefixExpr),
    RangeExpr(RangeExpr),
    RecordExpr(RecordExpr),
    RefExpr(RefExpr),
    ReturnExpr(ReturnExpr),
    TryExpr(TryExpr),
    TupleExpr(TupleExpr),
    UnderscoreExpr(UnderscoreExpr),
    WhileExpr(WhileExpr),
    YeetExpr(YeetExpr),
    YieldExpr(YieldExpr),
}

Variants

ArrayExpr(ArrayExpr)

AsmExpr(AsmExpr)

AwaitExpr(AwaitExpr)

BecomeExpr(BecomeExpr)

BinExpr(BinExpr)

BlockExpr(BlockExpr)

BreakExpr(BreakExpr)

CallExpr(CallExpr)

CastExpr(CastExpr)

ClosureExpr(ClosureExpr)

ContinueExpr(ContinueExpr)

FieldExpr(FieldExpr)

ForExpr(ForExpr)

FormatArgsExpr(FormatArgsExpr)

IfExpr(IfExpr)

IndexExpr(IndexExpr)

LetExpr(LetExpr)

Literal(Literal)

LoopExpr(LoopExpr)

MacroExpr(MacroExpr)

MatchExpr(MatchExpr)

MethodCallExpr(MethodCallExpr)

OffsetOfExpr(OffsetOfExpr)

ParenExpr(ParenExpr)

PathExpr(PathExpr)

PrefixExpr(PrefixExpr)

RangeExpr(RangeExpr)

RecordExpr(RecordExpr)

RefExpr(RefExpr)

ReturnExpr(ReturnExpr)

TryExpr(TryExpr)

TupleExpr(TupleExpr)

UnderscoreExpr(UnderscoreExpr)

WhileExpr(WhileExpr)

YeetExpr(YeetExpr)

YieldExpr(YieldExpr)

Implementations

impl Expr

pub fn is_block_like(&self) -> bool

impl Expr

pub fn needs_parens_in(&self, parent: SyntaxNode) -> bool

Returns true if self would need to be wrapped in parentheses given that its parent is parent.

impl Expr

pub fn parse(text: &str, edition: Edition) -> Parse<Expr>

Parses an ast::Expr from text.

Note that if the parsed root node is not a valid expression, Parse::tree will panic. For example:

ast::Expr::parse("let fail = true;", Edition::CURRENT).tree();

Trait Implementations

impl AstNode for Expr

fn can_cast(kind: SyntaxKind) -> bool

fn cast(syntax: SyntaxNode) -> Option<Self>

fn syntax(&self) -> &SyntaxNode

fn clone_for_update(&self) -> Self

where Self: Sized,

fn clone_subtree(&self) -> Self

where Self: Sized,

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy 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 Display for Expr

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

Formats the value using the given formatter.

impl From<ArrayExpr> for Expr

fn from(node: ArrayExpr) -> Expr

Converts to this type from the input type.

impl From<AsmExpr> for Expr

fn from(node: AsmExpr) -> Expr

Converts to this type from the input type.

impl From<AwaitExpr> for Expr

fn from(node: AwaitExpr) -> Expr

Converts to this type from the input type.

impl From<BecomeExpr> for Expr

fn from(node: BecomeExpr) -> Expr

Converts to this type from the input type.

impl From<BinExpr> for Expr

fn from(node: BinExpr) -> Expr

Converts to this type from the input type.

impl From<BlockExpr> for Expr

fn from(node: BlockExpr) -> Expr

Converts to this type from the input type.

impl From<BreakExpr> for Expr

fn from(node: BreakExpr) -> Expr

Converts to this type from the input type.

impl From<CallExpr> for Expr

fn from(node: CallExpr) -> Expr

Converts to this type from the input type.

impl From<CastExpr> for Expr

fn from(node: CastExpr) -> Expr

Converts to this type from the input type.

impl From<ClosureExpr> for Expr

fn from(node: ClosureExpr) -> Expr

Converts to this type from the input type.

impl From<ContinueExpr> for Expr

fn from(node: ContinueExpr) -> Expr

Converts to this type from the input type.

impl From<FieldExpr> for Expr

fn from(node: FieldExpr) -> Expr

Converts to this type from the input type.

impl From<ForExpr> for Expr

fn from(node: ForExpr) -> Expr

Converts to this type from the input type.

impl From<FormatArgsExpr> for Expr

fn from(node: FormatArgsExpr) -> Expr

Converts to this type from the input type.

impl From<IfExpr> for Expr

fn from(node: IfExpr) -> Expr

Converts to this type from the input type.

impl From<IndexExpr> for Expr

fn from(node: IndexExpr) -> Expr

Converts to this type from the input type.

impl From<LetExpr> for Expr

fn from(node: LetExpr) -> Expr

Converts to this type from the input type.

impl From<Literal> for Expr

fn from(node: Literal) -> Expr

Converts to this type from the input type.

impl From<LoopExpr> for Expr

fn from(node: LoopExpr) -> Expr

Converts to this type from the input type.

impl From<MacroExpr> for Expr

fn from(node: MacroExpr) -> Expr

Converts to this type from the input type.

impl From<MatchExpr> for Expr

fn from(node: MatchExpr) -> Expr

Converts to this type from the input type.

impl From<MethodCallExpr> for Expr

fn from(node: MethodCallExpr) -> Expr

Converts to this type from the input type.

impl From<OffsetOfExpr> for Expr

fn from(node: OffsetOfExpr) -> Expr

Converts to this type from the input type.

impl From<ParenExpr> for Expr

fn from(node: ParenExpr) -> Expr

Converts to this type from the input type.

impl From<PathExpr> for Expr

fn from(node: PathExpr) -> Expr

Converts to this type from the input type.

impl From<PrefixExpr> for Expr

fn from(node: PrefixExpr) -> Expr

Converts to this type from the input type.

impl From<RangeExpr> for Expr

fn from(node: RangeExpr) -> Expr

Converts to this type from the input type.

impl From<RecordExpr> for Expr

fn from(node: RecordExpr) -> Expr

Converts to this type from the input type.

impl From<RefExpr> for Expr

fn from(node: RefExpr) -> Expr

Converts to this type from the input type.

impl From<ReturnExpr> for Expr

fn from(node: ReturnExpr) -> Expr

Converts to this type from the input type.

impl From<TryExpr> for Expr

fn from(node: TryExpr) -> Expr

Converts to this type from the input type.

impl From<TupleExpr> for Expr

fn from(node: TupleExpr) -> Expr

Converts to this type from the input type.

impl From<UnderscoreExpr> for Expr

fn from(node: UnderscoreExpr) -> Expr

Converts to this type from the input type.

impl From<WhileExpr> for Expr

fn from(node: WhileExpr) -> Expr

Converts to this type from the input type.

impl From<YeetExpr> for Expr

fn from(node: YeetExpr) -> Expr

Converts to this type from the input type.

impl From<YieldExpr> for Expr

fn from(node: YieldExpr) -> Expr

Converts to this type from the input type.

impl HasAttrs for Expr

fn attrs(&self) -> AstChildren<Attr>

fn has_atom_attr(&self, atom: &str) -> bool

fn attrs_including_inner(self) -> impl Iterator<Item = Attr>

where Self: Sized,

Returns all attributes of this node, including inner attributes that may not be directly under this node but under a child.

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 Eq for Expr

impl StructuralPartialEq for Expr