[−][src]Enum ra_ap_syntax::ast::Expr

pub enum Expr {
    ArrayExpr(ArrayExpr),
    AwaitExpr(AwaitExpr),
    BinExpr(BinExpr),
    BlockExpr(BlockExpr),
    BoxExpr(BoxExpr),
    BreakExpr(BreakExpr),
    CallExpr(CallExpr),
    CastExpr(CastExpr),
    ClosureExpr(ClosureExpr),
    ContinueExpr(ContinueExpr),
    EffectExpr(EffectExpr),
    FieldExpr(FieldExpr),
    ForExpr(ForExpr),
    IfExpr(IfExpr),
    IndexExpr(IndexExpr),
    Literal(Literal),
    LoopExpr(LoopExpr),
    MacroCall(MacroCall),
    MatchExpr(MatchExpr),
    MethodCallExpr(MethodCallExpr),
    ParenExpr(ParenExpr),
    PathExpr(PathExpr),
    PrefixExpr(PrefixExpr),
    RangeExpr(RangeExpr),
    RecordExpr(RecordExpr),
    RefExpr(RefExpr),
    ReturnExpr(ReturnExpr),
    TryExpr(TryExpr),
    TupleExpr(TupleExpr),
    WhileExpr(WhileExpr),
}

Variants

ArrayExpr(ArrayExpr)

AwaitExpr(AwaitExpr)

BinExpr(BinExpr)

BlockExpr(BlockExpr)

BoxExpr(BoxExpr)

BreakExpr(BreakExpr)

CallExpr(CallExpr)

CastExpr(CastExpr)

ClosureExpr(ClosureExpr)

ContinueExpr(ContinueExpr)

EffectExpr(EffectExpr)

FieldExpr(FieldExpr)

ForExpr(ForExpr)

IfExpr(IfExpr)

IndexExpr(IndexExpr)

Literal(Literal)

LoopExpr(LoopExpr)

MacroCall(MacroCall)

MatchExpr(MatchExpr)

MethodCallExpr(MethodCallExpr)

ParenExpr(ParenExpr)

PathExpr(PathExpr)

PrefixExpr(PrefixExpr)

RangeExpr(RangeExpr)

RecordExpr(RecordExpr)

RefExpr(RefExpr)

ReturnExpr(ReturnExpr)

TryExpr(TryExpr)

TupleExpr(TupleExpr)

WhileExpr(WhileExpr)

Implementations

`impl Expr`[src]

`pub fn is_block_like(&self) -> bool`[src]

`impl Expr`[src]

`pub fn parse(text: &str) -> Result<Self, ()>`[src]

Returns text, parsed as an expression, but only if it has no errors.

Trait Implementations

`impl AstNode for Expr`[src]

`fn can_cast(kind: SyntaxKind) -> bool`[src]

`fn cast(syntax: SyntaxNode) -> Option<Self>`[src]

`fn syntax(&self) -> &SyntaxNode`[src]

`impl AttrsOwner for Expr`[src]

`fn attrs(&self) -> AstChildren<Attr>ⓘNotable traits for AstChildren<N> impl<N: AstNode> Iterator for AstChildren<N> type Item = N;`[src]

`fn has_atom_attr(&self, atom: &str) -> bool`[src]

`impl Clone for Expr`[src]

`fn clone(&self) -> Expr`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl Debug for Expr`[src]

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

`impl Display for Expr`[src]

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

`impl Eq for Expr`[src]

`impl From<ArrayExpr> for Expr`[src]

`fn from(node: ArrayExpr) -> Expr`[src]

`impl From<AwaitExpr> for Expr`[src]

`fn from(node: AwaitExpr) -> Expr`[src]

`impl From<BinExpr> for Expr`[src]

`fn from(node: BinExpr) -> Expr`[src]

`impl From<BlockExpr> for Expr`[src]

`fn from(node: BlockExpr) -> Expr`[src]

`impl From<BoxExpr> for Expr`[src]

`fn from(node: BoxExpr) -> Expr`[src]

`impl From<BreakExpr> for Expr`[src]

`fn from(node: BreakExpr) -> Expr`[src]

`impl From<CallExpr> for Expr`[src]

`fn from(node: CallExpr) -> Expr`[src]

`impl From<CastExpr> for Expr`[src]

`fn from(node: CastExpr) -> Expr`[src]

`impl From<ClosureExpr> for Expr`[src]

`fn from(node: ClosureExpr) -> Expr`[src]

`impl From<ContinueExpr> for Expr`[src]

`fn from(node: ContinueExpr) -> Expr`[src]

`impl From<EffectExpr> for Expr`[src]

`fn from(node: EffectExpr) -> Expr`[src]

`impl From<FieldExpr> for Expr`[src]

`fn from(node: FieldExpr) -> Expr`[src]

`impl From<ForExpr> for Expr`[src]

`fn from(node: ForExpr) -> Expr`[src]

`impl From<IfExpr> for Expr`[src]

`fn from(node: IfExpr) -> Expr`[src]

`impl From<IndexExpr> for Expr`[src]

`fn from(node: IndexExpr) -> Expr`[src]

`impl From<Literal> for Expr`[src]

`fn from(node: Literal) -> Expr`[src]

`impl From<LoopExpr> for Expr`[src]

`fn from(node: LoopExpr) -> Expr`[src]

`impl From<MacroCall> for Expr`[src]

`fn from(node: MacroCall) -> Expr`[src]

`impl From<MatchExpr> for Expr`[src]

`fn from(node: MatchExpr) -> Expr`[src]

`impl From<MethodCallExpr> for Expr`[src]

`fn from(node: MethodCallExpr) -> Expr`[src]

`impl From<ParenExpr> for Expr`[src]

`fn from(node: ParenExpr) -> Expr`[src]

`impl From<PathExpr> for Expr`[src]

`fn from(node: PathExpr) -> Expr`[src]

`impl From<PrefixExpr> for Expr`[src]

`fn from(node: PrefixExpr) -> Expr`[src]

`impl From<RangeExpr> for Expr`[src]

`fn from(node: RangeExpr) -> Expr`[src]

`impl From<RecordExpr> for Expr`[src]

`fn from(node: RecordExpr) -> Expr`[src]

`impl From<RefExpr> for Expr`[src]

`fn from(node: RefExpr) -> Expr`[src]

`impl From<ReturnExpr> for Expr`[src]

`fn from(node: ReturnExpr) -> Expr`[src]

`impl From<TryExpr> for Expr`[src]

`fn from(node: TryExpr) -> Expr`[src]

`impl From<TupleExpr> for Expr`[src]

`fn from(node: TupleExpr) -> Expr`[src]

`impl From<WhileExpr> for Expr`[src]

`fn from(node: WhileExpr) -> Expr`[src]

`impl Hash for Expr`[src]

`fn hash<H: Hasher>(&self, state: &mut H)`[src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` 1.3.0[src]

`impl PartialEq<Expr> for Expr`[src]

`fn eq(&self, other: &Expr) -> bool`[src]

`fn ne(&self, other: &Expr) -> bool`[src]

`impl StructuralEq for Expr`[src]

`impl StructuralPartialEq for Expr`[src]

Auto Trait Implementations

`impl !RefUnwindSafe for Expr`

`impl !Send for Expr`

`impl !Sync for Expr`

`impl Unpin for Expr`

`impl !UnwindSafe for Expr`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<N> AstNodeEdit for N where N: AstNode + Clone,` [src]

`#[must_use]fn insert_children( &self, position: InsertPosition<SyntaxElement>, to_insert: impl IntoIterator<Item = SyntaxElement> ) -> Self`[src]

`#[must_use]fn replace_children( &self, to_replace: RangeInclusive<SyntaxElement>, to_insert: impl IntoIterator<Item = SyntaxElement> ) -> Self`[src]

`#[must_use]fn replace_descendant<D: AstNode>(&self, old: D, new: D) -> Self`[src]

`#[must_use]fn replace_descendants<D: AstNode>( &self, replacement_map: impl IntoIterator<Item = (D, D)> ) -> Self`[src]

`fn indent_level(&self) -> IndentLevel`[src]

`#[must_use]fn indent(&self, level: IndentLevel) -> Self`[src]

`#[must_use]fn dedent(&self, level: IndentLevel) -> Self`[src]

`#[must_use]fn reset_indent(&self) -> Self`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into<U> for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T> ToString for T where T: Display + ?Sized,` [src]

`default fn to_string(&self) -> String`[src]

`impl<T, U> TryFrom<U> for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

`impl<T, U> TryInto<U> for T where U: TryFrom<T>,` [src]

`type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]