Trait swc_ecma_utils::ExprFactory

source · [−]
pub trait ExprFactory: Into<Expr> {

Show 22 methods    fn as_arg(self) -> ExprOrSpread { ... }
    fn as_pat_or_expr(self) -> PatOrExpr { ... }
    fn into_stmt(self) -> Stmt { ... }
    fn into_return_stmt(self) -> ReturnStmt { ... }
    fn as_callee(self) -> Callee { ... }
    fn as_iife(self) -> CallExpr { ... }
    fn into_lazy_arrow(self, params: Vec<Pat>) -> ArrowExpr { ... }
    fn into_lazy_fn(self, params: Vec<Param>) -> Function { ... }
    fn into_lazy_auto(self, params: Vec<Pat>, support_arrow: bool) -> Expr { ... }
    fn into_var_decl(self, kind: VarDeclKind, name: Pat) -> VarDecl { ... }
    fn into_new_expr(self, span: Span, args: Option<Vec<ExprOrSpread>>) -> NewExpr { ... }
    fn apply(self, span: Span, this: Box<Expr>, args: Vec<ExprOrSpread>) -> Expr { ... }
    fn call_fn(self, span: Span, args: Vec<ExprOrSpread>) -> Expr { ... }
    fn as_call(self, span: Span, args: Vec<ExprOrSpread>) -> Expr { ... }
    fn as_fn_decl(self) -> Option<FnDecl> { ... }
    fn as_class_decl(self) -> Option<ClassDecl> { ... }
    fn wrap_with_paren(self) -> Expr { ... }
    fn make_eq<T>(self, right: T) -> Expr
    where
        T: Into<Expr>,
    { ... }
    fn make_bin<T>(self, op: BinaryOp, right: T) -> Expr
    where
        T: Into<Expr>,
    { ... }
    fn make_assign_to(self, op: AssignOp, left: PatOrExpr) -> Expr { ... }
    fn make_member<T>(self, prop: T) -> Expr
    where
        T: Into<Ident>,
    { ... }
    fn computed_member<T>(self, prop: T) -> Expr
    where
        T: Into<Expr>,
    { ... }

}
Expand description

Extension methods for Expr.

Note that many types implements Into<Expr> and you can do like

use swc_ecma_utils::ExprFactory;

let _args = vec![0f64.as_arg()];

to create literals. Almost all rust core types implements Into<Expr>.

Provided Methods

Creates an ExprOrSpread using the given Expr.

This is recommended way to create ExprOrSpread.

Example
use swc_common::DUMMY_SP;
use swc_ecma_ast::*;
use swc_ecma_utils::ExprFactory;

let first = Lit::Num(Number {
    span: DUMMY_SP,
    value: 0.0,
    raw: None,
});
let _args = vec![first.as_arg()];

Creates an expression statement with self.

Creates a statement whcih return self.

create a ArrowExpr which return self

  • (params) => $self

create a Function which return self

  • function(params) { return $self; }

create a var declartor using self as init

  • var name = expr

Creates a binary expr $self ===

Creates a binary expr $self $op $rhs

Creates a assign expr $lhs $op $self

Implementors