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

pub enum Expr {
    ArrowExpr(ArrowExpr),
    Literal(Literal),
    Template(Template),
    NameRef(NameRef),
    ThisExpr(ThisExpr),
    ArrayExpr(ArrayExpr),
    ObjectExpr(ObjectExpr),
    GroupingExpr(GroupingExpr),
    BracketExpr(BracketExpr),
    DotExpr(DotExpr),
    NewExpr(NewExpr),
    CallExpr(CallExpr),
    UnaryExpr(UnaryExpr),
    BinExpr(BinExpr),
    CondExpr(CondExpr),
    AssignExpr(AssignExpr),
    SequenceExpr(SequenceExpr),
    FnExpr(FnExpr),
    ClassExpr(ClassExpr),
    NewTarget(NewTarget),
    ImportMeta(ImportMeta),
    SuperCall(SuperCall),
    ImportCall(ImportCall),
    YieldExpr(YieldExpr),
    AwaitExpr(AwaitExpr),
}

Variants

ArrowExpr(ArrowExpr)

Literal(Literal)

Template(Template)

NameRef(NameRef)

ThisExpr(ThisExpr)

ArrayExpr(ArrayExpr)

ObjectExpr(ObjectExpr)

GroupingExpr(GroupingExpr)

BracketExpr(BracketExpr)

DotExpr(DotExpr)

NewExpr(NewExpr)

CallExpr(CallExpr)

UnaryExpr(UnaryExpr)

BinExpr(BinExpr)

CondExpr(CondExpr)

AssignExpr(AssignExpr)

SequenceExpr(SequenceExpr)

FnExpr(FnExpr)

ClassExpr(ClassExpr)

NewTarget(NewTarget)

ImportMeta(ImportMeta)

SuperCall(SuperCall)

ImportCall(ImportCall)

YieldExpr(YieldExpr)

AwaitExpr(AwaitExpr)

Implementations

`impl Expr`[src]

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

Whether this is an optional chain expression.

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]

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

`fn range(&self) -> TextRange`[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<ArrowExpr> for Expr`[src]

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

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

`fn from(node: AssignExpr) -> 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<BracketExpr> for Expr`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn from(node: YieldExpr) -> 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<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> Erasable for T`

`unsafe fn unerase(this: NonNull<Erased>) -> NonNull<T>`

`const ACK_1_1_0: bool`

`fn erase(this: NonNull<Self>) -> NonNull<Erased>`

`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]