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 precedence(&self) -> ExprPrecedence

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.

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

Returns true if self would need to be wrapped in parentheses if it replaces place_of given that place_of’s parent is parent.

fn needs_parens_in_expr(&self, parent: &Expr, place_of: &SyntaxNode) -> bool

fn needs_parens_in_stmt(&self, stmt: Option<&Stmt>) -> bool

fn binding_power(&self) -> (u8, u8)

Returns left and right so-called “binding powers” of this expression.

fn is_paren_like(&self) -> bool

fn is_prefix(&self) -> bool

fn is_postfix(&self) -> bool

fn requires_semi_to_be_stmt(&self) -> bool

Returns true if this expression can’t be a standalone statement.

fn trailing_brace(self) -> Option<Expr>

If an expression ends with }, returns the innermost expression ending in this }.

fn contains_exterior_struct_lit(&self) -> bool

Expressions that syntactically contain an “exterior” struct literal i.e., not surrounded by any parens or other delimiters, e.g., X { y: 1 }, X { y: 1 }.method(), foo == X { y: 1 } and X { y: 1 } == foo all do, but (X { y: 1 }) == foo does not.

pub fn is_ret_like_with_no_value(&self) -> bool

Returns true if self is one of return, break, continue or yield with no associated value.

fn is_ordered_before_parent_in_place_of( &self, parent: &Expr, place_of: &SyntaxNode, ) -> bool

fn child_is_followed_by_a_block(&self) -> bool

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 kind() -> SyntaxKind

where Self: Sized,

This panics if the SyntaxKind is not statically known.

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 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 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 inner_attributes_node(&self) -> Option<SyntaxNode>

This may return the same node as called with (with SourceFile). The caller has the responsibility to avoid duplicate attributes.

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