swc-project/swc
1
1
Fork 0
mirror of https://github.com/swc-project/swc.git synced 2024-10-04 12:18:08 +03:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

refactor(es): Improve ast apis (#3690)

Browse Source
This commit is contained in:
Donny/강동윤 2022-02-23 14:37:07 +09:00 committed by GitHub
parent d603473ee4
commit 135acf3b42
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
24 changed files with 141 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
crates/swc_ecma_ast/src/expr.rs
View File

@ -18,7 +18,7 @@ use crate::{
TsAsExpr, TsConstAssertion, TsInstantiation, TsNonNullExpr, TsTypeAnn, TsTypeAssertion,
TsTypeParamDecl, TsTypeParamInstantiation,
},
ComputedPropName, Invalid,
ComputedPropName, Id, Invalid,
};
#[ast_node]
@ -166,6 +166,8 @@ impl Take for Expr {
}
}
bridge_expr_from!(Ident, Id);
#[ast_node("ThisExpression")]
#[derive(Eq, Hash, Copy, EqIgnoreSpan)]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]

12
crates/swc_ecma_ast/src/ident.rs
View File

@ -99,6 +99,18 @@ pub struct Ident {
pub optional: bool,
}
impl From<Id> for Ident {
fn from(id: Id) -> Self {
Ident::new(id.0, DUMMY_SP.with_ctxt(id.1))
}
}
impl From<Ident> for Id {
fn from(i: Ident) -> Self {
(i.sym, i.span.ctxt)
}
}
impl Ident {
/// Returns true if `c` is a valid character for an identifier start.
pub fn is_valid_start(c: char) -> bool {

4
crates/swc_ecma_transforms_classes/src/super_field.rs
View File

@ -159,12 +159,12 @@ impl<'a> SuperFieldAccessFolder<'a> {
let ident = quote_ident!(DUMMY_SP.apply_mark(mark), "_this").as_arg();
// in constant super, call will be the only place where a assert is needed
if self.constant_super {
Expr::Call(CallExpr {
CallExpr {
span: DUMMY_SP,
callee: helper!(assert_this_initialized, "assertThisInitialized"),
args: vec![ident],
type_args: Default::default(),
})
}
.as_arg()
} else {
ident

20
crates/swc_ecma_transforms_compat/src/bugfixes/template_literal_caching.rs
View File

@ -1,6 +1,6 @@
use swc_common::DUMMY_SP;
use swc_ecma_ast::*;
use swc_ecma_utils::{prepend, private_ident};
use swc_ecma_utils::{prepend, private_ident, ExprFactory};
use swc_ecma_visit::{noop_fold_type, Fold, FoldWith};
// Converts destructured parameters with default values to non-shorthand syntax.
@ -117,19 +117,11 @@ impl Fold for TemplateLiteralCaching {
// tag(_t || (_t = Object`a${0}`), 'hello')
Expr::Call(CallExpr {
span: DUMMY_SP,
callee: Callee::Expr(n.tag),
args: vec![ExprOrSpread {
expr: Box::new(inline_cache),
spread: None,
}]
.into_iter()
.chain(
n.tpl
.exprs
.into_iter()
.map(|expr| ExprOrSpread { expr, spread: None }),
)
.collect(),
callee: n.tag.as_callee(),
args: vec![inline_cache.as_arg()]
.into_iter()
.chain(n.tpl.exprs.into_iter().map(|expr| expr.as_arg()))
.collect(),
type_args: None,
})
}

10
crates/swc_ecma_transforms_compat/src/es2015/block_scoping.rs
View File

@ -238,10 +238,7 @@ impl BlockScoping {
args: args
.iter()
.cloned()
.map(|i| ExprOrSpread {
spread: None,
expr: Box::new(Expr::Ident(Ident::new(i.0, DUMMY_SP.with_ctxt(i.1)))),
})
.map(|i| Ident::new(i.0, DUMMY_SP.with_ctxt(i.1)).as_arg())
.collect(),
type_args: None,
};
@ -281,10 +278,7 @@ impl BlockScoping {
Expr::Call(CallExpr {
span: Default::default(),
callee,
args: vec![ExprOrSpread {
spread: None,
expr: Box::new(ret.clone().into()),
}],
args: vec![ret.clone().as_arg()],
type_args: None,
})
.into()

4
crates/swc_ecma_transforms_compat/src/es2015/destructuring.rs
View File

@ -243,10 +243,10 @@ impl AssignFolder {
.clone()
.make_member(quote_ident!("slice"))
.as_callee(),
args: vec![Lit::Num(Number {
args: vec![Number {
value: i as f64,
span: dot3_token,
})
}
.as_arg()],
type_args: Default::default(),
}))),

2
crates/swc_ecma_transforms_compat/src/es2015/object_super.rs
View File

@ -398,7 +398,7 @@ impl SuperReplacer {
op: op!("="),
right: prop.take(),
});
Box::new(Expr::Ident(ref_ident)).as_arg()
ref_ident.as_arg()
} else {
prop.clone().as_arg()
},

57
crates/swc_ecma_transforms_compat/src/es2015/regenerator/case.rs
View File

@ -130,24 +130,19 @@ impl CaseHandler<'_> {
let elems = locs
.into_iter()
.map(|loc| {
loc.map(|loc| ExprOrSpread {
spread: None,
expr: Box::new(loc.to_stmt_index()),
})
})
.map(|loc| loc.map(|loc| loc.to_stmt_index().as_arg()))
.collect::<Vec<_>>();
if elems.is_empty() {
return None;
}
Some(ExprOrSpread {
spread: None,
expr: Box::new(Expr::Array(ArrayLit {
Some(
ArrayLit {
span: DUMMY_SP,
elems,
})),
})
}
.as_arg(),
)
})
.collect(),
})
@ -421,16 +416,15 @@ impl CaseHandler<'_> {
me.prop
};
Callee::Expr(Box::new(
MemberExpr {
span: me.span,
obj,
prop,
}
.make_member(quote_ident!("call")),
))
MemberExpr {
span: me.span,
obj,
prop,
}
.make_member(quote_ident!("call"))
.as_callee()
} else {
Callee::Expr(Box::new(self.explode_expr(Expr::Member(me), false)))
self.explode_expr(Expr::Member(me), false).as_callee()
}
}
@ -453,7 +447,7 @@ impl CaseHandler<'_> {
// by using the (0, object.property)(...) trick; otherwise, it
// will receive the object of the MemberExpression as its `this`
// object.
Callee::Expr(Box::new(Expr::Seq(SeqExpr {
SeqExpr {
span: DUMMY_SP,
exprs: vec![
Box::new(
@ -465,9 +459,10 @@ impl CaseHandler<'_> {
),
Box::new(callee),
],
})))
}
.as_callee()
}
_ => Callee::Expr(Box::new(callee)),
_ => callee.as_callee(),
}
}
Callee::Import(..) => callee,
@ -788,13 +783,7 @@ impl CaseHandler<'_> {
.as_callee(),
args: vec![
arg.unwrap().as_arg(),
Lit::Str(Str {
span: DUMMY_SP,
value: name,
has_escape: false,
kind: Default::default(),
})
.as_arg(),
name.as_arg(),
after.to_stmt_index().as_arg(),
],
type_args: Default::default(),
@ -919,13 +908,7 @@ impl CaseHandler<'_> {
.make_member(quote_ident!("abrupt"))
.as_callee(),
args: {
let ty_arg = Lit::Str(Str {
span: DUMMY_SP,
value: ty.into(),
has_escape: false,
kind: Default::default(),
})
.as_arg();
let ty_arg = ty.as_arg();
if ty == "break" || ty == "continue" {
if let Some(arg) = target {

10
crates/swc_ecma_transforms_compat/src/es2015/regenerator/mod.rs
View File

@ -56,9 +56,7 @@ fn require_rt(global_mark: Mark, rt: Ident, src: Option<JsWord>) -> Stmt {
init: Some(Box::new(Expr::Call(CallExpr {
span: DUMMY_SP,
callee: quote_ident!(DUMMY_SP.apply_mark(global_mark), "require").as_callee(),
args: vec![
quote_str!(src.unwrap_or_else(|| "regenerator-runtime".into())).as_arg(),
],
args: vec![src.unwrap_or_else(|| "regenerator-runtime".into()).as_arg()],
type_args: Default::default(),
}))),
definite: false,
@ -458,7 +456,7 @@ impl Regenerator {
.make_member(quote_ident!("wrap"))
.as_callee(),
args: {
let mut args = vec![Expr::Fn(FnExpr {
let mut args = vec![FnExpr {
ident: Some(inner_name),
function: Function {
params: vec![Param {
@ -477,7 +475,7 @@ impl Regenerator {
type_params: None,
return_type: None,
},
})
}
.as_arg()];
if f.is_generator {
@ -494,7 +492,7 @@ impl Regenerator {
if uses_this {
args.push(ThisExpr { span: DUMMY_SP }.as_arg())
} else if try_locs_list.is_some() {
args.push(Lit::Null(Null { span: DUMMY_SP }).as_arg());
args.push(Null { span: DUMMY_SP }.as_arg());
}
if let Some(try_locs_list) = try_locs_list {

10
crates/swc_ecma_transforms_compat/src/es2015/spread.rs
View File

@ -232,7 +232,7 @@ impl Spread {
match first_arr {
Some(_) => {
if !elems.is_empty() {
buf.push(Expr::Array(ArrayLit { span, elems }).as_arg());
buf.push(ArrayLit { span, elems }.as_arg());
}
}
None => {
@ -273,13 +273,13 @@ impl Spread {
return *expr;
}
} else {
Expr::Call(CallExpr {
CallExpr {
span,
callee: member_expr!(DUMMY_SP, Array.prototype.slice.call)
.as_callee(),
args: vec![expr.as_arg()],
type_args: Default::default(),
})
}
.as_arg()
}
}
@ -326,12 +326,12 @@ impl Spread {
};
}
Expr::Call(CallExpr {
CallExpr {
span,
callee: helper!(to_consumable_array, "toConsumableArray"),
args: vec![expr.as_arg()],
type_args: Default::default(),
})
}
.as_arg()
}
});

22
crates/swc_ecma_transforms_compat/src/es2015/template_literal.rs
View File

@ -189,17 +189,18 @@ impl VisitMut for TemplateLiteral {
} else {
Box::new(Expr::Call(CallExpr {
span: span.with_hi(expr_span.hi() + BytePos(1)),
callee: Callee::Expr(Box::new(Expr::Member(MemberExpr {
callee: MemberExpr {
span: DUMMY_SP,
obj,
prop: MemberProp::Ident(Ident::new(
js_word!("concat"),
expr_span,
)),
}))),
}
.as_callee(),
args: mem::take(&mut args)
.into_iter()
.map(|expr| ExprOrSpread { expr, spread: None })
.map(|expr| expr.as_arg())
.collect(),
type_args: Default::default(),
}))
@ -229,17 +230,18 @@ impl VisitMut for TemplateLiteral {
} else {
Box::new(Expr::Call(CallExpr {
span: span.with_hi(expr_span.hi() + BytePos(1)),
callee: Callee::Expr(Box::new(Expr::Member(MemberExpr {
callee: MemberExpr {
span: DUMMY_SP,
obj,
prop: MemberProp::Ident(Ident::new(
js_word!("concat"),
expr_span,
)),
}))),
}
.as_callee(),
args: mem::take(&mut args)
.into_iter()
.map(|expr| ExprOrSpread { expr, spread: None })
.map(|expr| expr.as_arg())
.collect(),
type_args: Default::default(),
}))
@ -300,7 +302,7 @@ impl VisitMut for TemplateLiteral {
elems: quasis
.iter()
.cloned()
.map(|elem| Lit::Str(elem.raw).as_arg())
.map(|elem| elem.raw.as_arg())
.map(Some)
.collect(),
}
@ -317,7 +319,7 @@ impl VisitMut for TemplateLiteral {
.take()
.into_iter()
.map(|elem| match elem.cooked {
Some(cooked) => Lit::Str(cooked).as_arg(),
Some(cooked) => cooked.as_arg(),
None => undefined(DUMMY_SP).as_arg(),
})
.map(Some)
@ -390,12 +392,12 @@ impl VisitMut for TemplateLiteral {
span: DUMMY_SP,
callee: tag.take().as_callee(),
args: iter::once(
Expr::Call(CallExpr {
CallExpr {
span: DUMMY_SP,
callee: fn_ident.as_callee(),
args: vec![],
type_args: Default::default(),
})
}
.as_arg(),
)
.chain(exprs.take().into_iter().map(|e| e.as_arg()))

2
crates/swc_ecma_transforms_compat/src/es2020/opt_chaining.rs
View File

@ -242,7 +242,7 @@ impl OptChaining {
return Ok(CondExpr {
span: DUMMY_SP,
alt: Box::new(Expr::Call(CallExpr {
callee: Callee::Expr(expr.alt),
callee: expr.alt.as_callee(),
..e.take()
})),
..expr

4
crates/swc_ecma_transforms_compat/src/es2022/class_properties/class_name_tdz.rs
View File

@ -23,14 +23,14 @@ impl<'a> VisitMut for ClassNameTdzFolder<'a> {
Box::new(Expr::Call(CallExpr {
span: DUMMY_SP,
callee: helper!(class_name_tdz_error, "classNameTDZError"),
args: vec![Lit::Str(Str {
args: vec![Str {
span: i.span,
value: i.sym.clone(),
has_escape: false,
kind: StrKind::Normal {
contains_quote: false,
},
})
}
.as_arg()],
type_args: Default::default(),

11
crates/swc_ecma_transforms_compat/src/es2022/class_properties/private_field.rs
View File

@ -471,7 +471,7 @@ impl<'a> VisitMut for PrivateAccessVisitor<'a> {
} else {
*e = Expr::Call(CallExpr {
span: *span,
callee: Callee::Expr(Box::new(expr)),
callee: expr.as_callee(),
args: args.take(),
type_args: type_args.take(),
});
@ -492,15 +492,16 @@ impl<'a> VisitMut for PrivateAccessVisitor<'a> {
let args = iter::once(this.as_arg()).chain(call.args.take()).collect();
*e = Expr::Call(CallExpr {
span: *span,
callee: Callee::Expr(Box::new(Expr::OptChain(OptChainExpr {
question_dot_token: *question_dot_token,
callee: OptChainExpr {
span: *span,
question_dot_token: *question_dot_token,
base: OptChainBase::Member(MemberExpr {
obj: Box::new(expr),
span: call.span,
obj: Box::new(expr),
prop: MemberProp::Ident(quote_ident!("call")),
}),
}))),
}
.as_callee(),
args,
type_args: call.type_args.take(),
});

6
crates/swc_ecma_transforms_compat/src/es2022/static_blocks.rs
View File

@ -1,6 +1,7 @@
use swc_atoms::JsWord;
use swc_common::{collections::AHashSet, util::take::Take, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_utils::ExprFactory;
use swc_ecma_visit::{as_folder, noop_visit_mut_type, Fold, VisitMut, VisitMutWith};
struct ClassStaticBlock;
@ -64,7 +65,7 @@ impl ClassStaticBlock {
},
value: Some(Box::new(Expr::Call(CallExpr {
span: DUMMY_SP,
callee: Callee::Expr(Box::new(Expr::Arrow(ArrowExpr {
callee: ArrowExpr {
span: DUMMY_SP,
params: Vec::new(),
is_async: false,
@ -72,7 +73,8 @@ impl ClassStaticBlock {
type_params: None,
return_type: None,
body: BlockStmtOrExpr::BlockStmt(static_block.body),
}))),
}
.as_callee(),
args: Vec::new(),
type_args: None,
}))),

8
crates/swc_ecma_transforms_module/src/amd.rs
View File

@ -472,9 +472,7 @@ where
let scope = &mut *scope_ref_mut;
let mut factory_params = Vec::with_capacity(scope.imports.len() + 1);
if has_export {
define_deps_arg
.elems
.push(Some(Lit::Str(quote_str!("exports")).as_arg()));
define_deps_arg.elems.push(Some("exports".as_arg()));
factory_params.push(Param {
span: DUMMY_SP,
decorators: Default::default(),
@ -557,9 +555,7 @@ where
None => src.clone(),
};
define_deps_arg
.elems
.push(Some(Lit::Str(quote_str!(src)).as_arg()));
define_deps_arg.elems.push(Some(src.as_arg()));
}
factory_params.push(Param {
span: DUMMY_SP,

2
crates/swc_ecma_transforms_module/src/common_js.rs
View File

@ -691,7 +691,7 @@ where
// export { foo as bar }
// -> 'bar'
let i = exported.unwrap_or(orig).clone();
Lit::Str(quote_str!(i.span, i.sym)).as_arg()
quote_str!(i.span, i.sym).as_arg()
},
make_descriptor(value).as_arg(),
])

2
crates/swc_ecma_transforms_module/src/umd.rs
View File

@ -441,7 +441,7 @@ where
// export { foo as bar }
// -> 'bar'
let i = exported.unwrap_or(orig);
Lit::Str(quote_str!(i.span, i.sym)).as_arg()
quote_str!(i.span, i.sym).as_arg()
},
make_descriptor(value).as_arg(),
])

2
crates/swc_ecma_transforms_module/src/util.rs
View File

@ -558,7 +558,7 @@ impl Scope {
} else {
*expr.fold_with(folder)
};
Callee::Expr(Box::new(callee))
callee.as_callee()
} else {
callee.fold_with(folder)
};

21
crates/swc_ecma_transforms_react/src/jsx/mod.rs
View File

@ -505,7 +505,7 @@ where
key = attr
.value
.and_then(jsx_attr_value_to_expr)
.map(|expr| ExprOrSpread { expr, spread: None });
.map(|expr| expr.as_arg());
assert_ne!(
key, None,
"value of property 'key' should not be empty"
@ -523,7 +523,7 @@ where
source_props = attr
.value
.and_then(jsx_attr_value_to_expr)
.map(|expr| ExprOrSpread { expr, spread: None });
.map(|expr| expr.as_arg());
assert_ne!(
source_props, None,
"value of property '__source' should not be empty"
@ -541,7 +541,7 @@ where
self_props = attr
.value
.and_then(jsx_attr_value_to_expr)
.map(|expr| ExprOrSpread { expr, spread: None });
.map(|expr| expr.as_arg());
assert_ne!(
self_props, None,
"value of property '__self' should not be empty"
@ -663,28 +663,19 @@ where
// set undefined literal to key if key is None
let key = match key {
Some(key) => key,
None => ExprOrSpread {
spread: None,
expr: undefined(DUMMY_SP),
},
None => undefined(DUMMY_SP).as_arg(),
};
// set undefined literal to __source if __source is None
let source_props = match source_props {
Some(source_props) => source_props,
None => ExprOrSpread {
spread: None,
expr: undefined(DUMMY_SP),
},
None => undefined(DUMMY_SP).as_arg(),
};
// set undefined literal to __self if __self is None
let self_props = match self_props {
Some(self_props) => self_props,
None => ExprOrSpread {
spread: None,
expr: undefined(DUMMY_SP),
},
None => undefined(DUMMY_SP).as_arg(),
};
args.chain(once(key))
.chain(once(

14
crates/swc_ecma_transforms_react/src/refresh/hook.rs
View File

@ -18,7 +18,7 @@ use crate::RefreshOptions;
// function that use hooks
struct HookSig {
handle: Ident,
// need to add an extra register, or alreay inlined
// need to add an extra register, or already inlined
hooks: Vec<Hook>,
}
@ -157,17 +157,17 @@ impl<'a> HookRegister<'a> {
let elems = custom_hook_in_scope
.into_iter()
.map(|hook| {
Some(ExprOrSpread {
spread: None,
expr: Box::new(match hook {
Some(
match hook {
HookCall::Ident(ident) => Expr::Ident(ident),
HookCall::Member(obj, prop) => Expr::Member(MemberExpr {
span: DUMMY_SP,
obj: Box::new(obj),
prop: MemberProp::Ident(prop),
}),
}),
})
}
.as_arg(),
)
})
.collect();
args.push(
@ -199,7 +199,7 @@ impl<'a> HookRegister<'a> {
Expr::Call(CallExpr {
span: DUMMY_SP,
callee: Callee::Expr(Box::new(Expr::Ident(handle))),
callee: handle.as_callee(),
args,
type_args: None,
})

25
crates/swc_ecma_transforms_react/src/refresh/mod.rs
View File

@ -5,7 +5,7 @@ use swc_common::{
Span, Spanned, SyntaxContext, DUMMY_SP,
};
use swc_ecma_ast::*;
use swc_ecma_utils::{ident::IdentLike, private_ident, quote_ident, quote_str, Id};
use swc_ecma_utils::{ident::IdentLike, private_ident, quote_ident, quote_str, ExprFactory, Id};
use swc_ecma_visit::{as_folder, Fold, Visit, VisitMut, VisitMutWith};
use self::{
@ -178,10 +178,7 @@ impl<C: Comments> Refresh<C> {
let mut first = first_arg.take();
if let Some(HocHook { callee, rest_arg }) = &hoc.hook {
let span = first.span();
let mut args = vec![ExprOrSpread {
spread: None,
expr: first,
}];
let mut args = vec![first.as_arg()];
args.extend(rest_arg.clone());
first = Box::new(Expr::Call(CallExpr {
span,
@ -472,17 +469,8 @@ impl<C: Comments> VisitMut for Refresh<C> {
span: DUMMY_SP,
expr: Box::new(Expr::Call(CallExpr {
span: DUMMY_SP,
callee: Callee::Expr(Box::new(Expr::Ident(quote_ident!(refresh_reg)))),
args: vec![
ExprOrSpread {
spread: None,
expr: Box::new(Expr::Ident(handle)),
},
ExprOrSpread {
spread: None,
expr: Box::new(Expr::Lit(Lit::Str(quote_str!(persistent_id.0)))),
},
],
callee: quote_ident!(refresh_reg).as_callee(),
args: vec![handle.as_arg(), quote_str!(persistent_id.0).as_arg()],
type_args: None,
})),
})));
@ -496,10 +484,7 @@ impl<C: Comments> VisitMut for Refresh<C> {
fn make_hook_reg(expr: &mut Expr, mut hook: HocHook) {
let span = expr.span();
let mut args = vec![ExprOrSpread {
spread: None,
expr: Box::new(expr.take()),
}];
let mut args = vec![expr.take().as_arg()];
args.append(&mut hook.rest_arg);
*expr = Expr::Call(CallExpr {
span,

3
crates/swc_ecma_transforms_react/src/refresh/util.rs
View File

@ -2,6 +2,7 @@ use indexmap::IndexSet;
use swc_atoms::JsWord;
use swc_common::{collections::AHashSet, Spanned, SyntaxContext, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_utils::ExprFactory;
use swc_ecma_visit::{noop_visit_type, Visit, VisitWith};
pub trait CollectIdent {
@ -192,7 +193,7 @@ pub fn make_call_stmt(handle: Ident) -> Stmt {
pub fn make_call_expr(handle: Ident) -> Expr {
Expr::Call(CallExpr {
span: DUMMY_SP,
callee: Callee::Expr(Box::new(Expr::Ident(handle))),
callee: handle.as_callee(),
args: Vec::new(),
type_args: None,
})

50
crates/swc_ecma_utils/src/factory.rs
View File

@ -5,8 +5,24 @@ use swc_common::{Span, Spanned, DUMMY_SP};
use swc_ecma_ast::*;
/// Extension methods for [Expr].
///
/// Note that many types implements `Into<Expr>` and you can do like
///
/// ```rust
/// use swc_ecma_utils::ExprFactory;
///
/// let _args = vec![0f64.as_arg()];
/// ```
///
/// to create literals. Almost all rust core types implements `Into<Expr>`.
#[allow(clippy::wrong_self_convention)]
pub trait ExprFactory: Into<Expr> {
/// Creates an [ExprOrSpread] using the given [Expr].
///
/// This is recommended way to create [ExprOrSpread].
///
/// # Example
///
/// ```rust
/// use swc_common::DUMMY_SP;
/// use swc_ecma_ast::*;
@ -18,7 +34,7 @@ pub trait ExprFactory: Into<Expr> {
/// });
/// let _args = vec![first.as_arg()];
/// ```
#[inline]
#[cfg_attr(not(debug_assertions), inline(always))]
fn as_arg(self) -> ExprOrSpread {
ExprOrSpread {
expr: Box::new(self.into()),
@ -27,7 +43,7 @@ pub trait ExprFactory: Into<Expr> {
}
/// Creates an expression statement with `self`.
#[inline]
#[cfg_attr(not(debug_assertions), inline(always))]
fn into_stmt(self) -> Stmt {
Stmt::Expr(ExprStmt {
span: DUMMY_SP,
@ -35,12 +51,12 @@ pub trait ExprFactory: Into<Expr> {
})
}
#[inline]
#[cfg_attr(not(debug_assertions), inline(always))]
fn as_callee(self) -> Callee {
Callee::Expr(Box::new(self.into()))
}
#[inline]
#[cfg_attr(not(debug_assertions), inline(always))]
fn as_iife(self) -> CallExpr {
CallExpr {
span: DUMMY_SP,
@ -50,6 +66,7 @@ pub trait ExprFactory: Into<Expr> {
}
}
#[cfg_attr(not(debug_assertions), inline(always))]
fn apply(self, span: Span, this: Box<Expr>, args: Vec<ExprOrSpread>) -> Expr {
let apply = self.make_member(Ident::new(js_word!("apply"), span));
@ -61,29 +78,29 @@ pub trait ExprFactory: Into<Expr> {
})
}
#[inline]
#[cfg_attr(not(debug_assertions), inline(always))]
fn call_fn(self, span: Span, args: Vec<ExprOrSpread>) -> Expr {
Expr::Call(CallExpr {
span,
args,
callee: Callee::Expr(Box::new(
self.make_member(Ident::new(js_word!("call"), span)),
)),
callee: self
.make_member(Ident::new(js_word!("call"), span))
.as_callee(),
type_args: None,
})
}
#[inline]
#[cfg_attr(not(debug_assertions), inline(always))]
fn as_call(self, span: Span, args: Vec<ExprOrSpread>) -> Expr {
Expr::Call(CallExpr {
span,
args,
callee: Callee::Expr(Box::new(self.into())),
callee: self.as_callee(),
type_args: None,
})
}
#[inline]
#[cfg_attr(not(debug_assertions), inline(always))]
fn wrap_with_paren(self) -> Expr {
let expr = Box::new(self.into());
let span = expr.span();
@ -91,7 +108,7 @@ pub trait ExprFactory: Into<Expr> {
}
/// Creates a binary expr `$self === `
#[inline]
#[cfg_attr(not(debug_assertions), inline(always))]
fn make_eq<T>(self, right: T) -> Expr
where
T: Into<Expr>,
@ -100,7 +117,7 @@ pub trait ExprFactory: Into<Expr> {
}
/// Creates a binary expr `$self $op $rhs`
#[inline]
#[cfg_attr(not(debug_assertions), inline(always))]
fn make_bin<T>(self, op: BinaryOp, right: T) -> Expr
where
T: Into<Expr>,
@ -115,7 +132,7 @@ pub trait ExprFactory: Into<Expr> {
})
}
#[inline]
#[cfg_attr(not(debug_assertions), inline(always))]
fn make_member<T>(self, prop: T) -> Expr
where
T: Into<Ident>,
@ -127,7 +144,7 @@ pub trait ExprFactory: Into<Expr> {
})
}
#[inline]
#[cfg_attr(not(debug_assertions), inline(always))]
fn computed_member<T>(self, prop: T) -> Expr
where
T: Into<Expr>,
@ -146,12 +163,13 @@ pub trait ExprFactory: Into<Expr> {
impl<T: Into<Expr>> ExprFactory for T {}
pub trait IntoIndirectCall: Into<CallExpr> {
#[cfg_attr(not(debug_assertions), inline(always))]
fn into_indirect(self) -> CallExpr {
let s = self.into();
let callee = Callee::Expr(Box::new(Expr::Seq(SeqExpr {
span: DUMMY_SP,
exprs: vec![Box::new(0_f64.into()), s.callee.expect_expr()],
exprs: vec![0f64.into(), s.callee.expect_expr()],
})));
CallExpr { callee, ..s }