#[cfg(allocative)]
use rspack_util::rspack_allocative;
use swc_next_ecma_ast::{
AssignmentExpression, AwaitExpression, BinaryExpression, CallExpression, ChainExpression, Class,
ClassElement, ConditionalExpression, ExportDefaultDeclarationKind, Expr, ForOfStatement,
IfStatement, ImportDeclaration, ImportExpression, LogicalExpression, MemberExpression,
NewExpression, Program, Span, Stmt, ThisExpression, UnaryExpression, UnaryOperator,
VariableDeclaration, VariableDeclarator,
};
use super::{BoxJavascriptParserPlugin, JavascriptParserPlugin, JavascriptParserPluginHook};
use crate::{
Atom,
utils::eval::BasicEvaluatedExpression,
visitors::{
DestructuringAssignmentProperty, ExportDefaultDeclaration, ExportImport, ExportLocal,
ExportedVariableInfo, ExpressionExpressionInfo, HookMemberExpression, JavascriptParser,
PatternIdentifier,
},
};
const PLUGIN_BITMASK_BITS: usize = u64::BITS as usize;
#[cfg_attr(allocative, derive(rspack_allocative::Allocative))]
pub struct JavaScriptParserPluginDrive {
plugins: Vec<BoxJavascriptParserPlugin>,
plugins_by_hook: [u64; JavascriptParserPluginHook::COUNT],
}
struct PluginBitmaskIter<'a> {
plugins: &'a [BoxJavascriptParserPlugin],
plugin_bitmask: u64,
}
impl<'a> Iterator for PluginBitmaskIter<'a> {
type Item = &'a BoxJavascriptParserPlugin;
fn next(&mut self) -> Option<Self::Item> {
if self.plugin_bitmask != 0 {
let idx = self.plugin_bitmask.trailing_zeros() as usize;
self.plugin_bitmask &= self.plugin_bitmask - 1;
return Some(unsafe { self.plugins.get_unchecked(idx) });
}
None
}
}
impl JavaScriptParserPluginDrive {
pub fn new(plugins: Vec<BoxJavascriptParserPlugin>) -> Self {
assert!(
plugins.len() <= PLUGIN_BITMASK_BITS,
"JavaScript parser plugin bitmask supports at most {PLUGIN_BITMASK_BITS} parser plugins"
);
let mut plugins_by_hook = [0; JavascriptParserPluginHook::COUNT];
for (idx, plugin) in plugins.iter().enumerate() {
let plugin_bit = 1u64 << idx;
let mut implemented_hooks = plugin.implemented_hooks().bits();
while implemented_hooks != 0 {
let hook_idx = implemented_hooks.trailing_zeros() as usize;
implemented_hooks &= implemented_hooks - 1;
plugins_by_hook[hook_idx] |= plugin_bit;
}
}
Self {
plugins,
plugins_by_hook,
}
}
#[inline]
fn plugins_for(&self, hook: JavascriptParserPluginHook) -> PluginBitmaskIter<'_> {
let hook_idx = hook as usize;
PluginBitmaskIter {
plugins: &self.plugins,
plugin_bitmask: unsafe { *self.plugins_by_hook.get_unchecked(hook_idx) },
}
}
}
impl<'p: 'a, 'a> JavascriptParserPlugin<'p, 'a> for JavaScriptParserPluginDrive {
fn top_level_await_expr(&self, parser: &mut JavascriptParser<'p>, expr: AwaitExpression) {
for plugin in self.plugins_for(JavascriptParserPluginHook::TopLevelAwaitExpr) {
plugin.top_level_await_expr(parser, expr);
}
}
fn top_level_for_of_await_stmt(&self, parser: &mut JavascriptParser<'p>, stmt: ForOfStatement) {
for plugin in self.plugins_for(JavascriptParserPluginHook::TopLevelForOfAwaitStmt) {
plugin.top_level_for_of_await_stmt(parser, stmt);
}
}
fn program(&self, parser: &mut JavascriptParser<'p>, ast: Program) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::Program) {
let res = plugin.program(parser, ast);
if res.is_some() {
return res;
}
}
None
}
fn finish(&self, parser: &mut JavascriptParser<'p>) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::Finish) {
let res = plugin.finish(parser);
if res.is_some() {
return res;
}
}
None
}
fn block_pre_module_declaration(
&self,
parser: &mut JavascriptParser<'p>,
decl: Stmt,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::BlockPreModuleDeclaration) {
let res = plugin.block_pre_module_declaration(parser, decl);
if res.is_some() {
return res;
}
}
None
}
fn module_declaration(&self, parser: &mut JavascriptParser<'p>, decl: Stmt) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::ModuleDeclaration) {
let res = plugin.module_declaration(parser, decl);
if res.is_some() {
return res;
}
}
None
}
fn call(
&self,
parser: &mut JavascriptParser<'p>,
expr: CallExpression,
name: &str,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::Call) {
let res = plugin.call(parser, expr, name);
if res.is_some() {
return res;
}
}
None
}
fn member(
&self,
parser: &mut JavascriptParser<'p>,
expr: HookMemberExpression,
for_name: &str,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::Member) {
let res = plugin.member(parser, expr, for_name);
if res.is_some() {
return res;
}
}
None
}
fn member_chain(
&self,
parser: &mut JavascriptParser<'p>,
expr: HookMemberExpression,
for_name: &str,
members: &[Atom],
members_optionals: &[bool],
member_ranges: &[Span],
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::MemberChain) {
let res = plugin.member_chain(
parser,
expr,
for_name,
members,
members_optionals,
member_ranges,
);
if res.is_some() {
return res;
}
}
None
}
fn call_member_chain(
&self,
parser: &mut JavascriptParser<'p>,
expr: CallExpression,
for_name: &str,
members: &[Atom],
members_optionals: &[bool],
member_ranges: &[Span],
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::CallMemberChain) {
let res = plugin.call_member_chain(
parser,
expr,
for_name,
members,
members_optionals,
member_ranges,
);
if res.is_some() {
return res;
}
}
None
}
fn is_pure(&self, parser: &mut JavascriptParser<'p>, expr: Expr) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::IsPure) {
let res = plugin.is_pure(parser, expr);
if res.is_some() {
return res;
}
}
None
}
fn member_chain_of_call_member_chain(
&self,
parser: &mut JavascriptParser<'p>,
member_expr: MemberExpression,
callee_members: &[Atom],
call_expr: CallExpression,
members: &[Atom],
member_ranges: &[Span],
for_name: &str,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::MemberChainOfCallMemberChain) {
let res = plugin.member_chain_of_call_member_chain(
parser,
member_expr,
callee_members,
call_expr,
members,
member_ranges,
for_name,
);
if res.is_some() {
return res;
}
}
None
}
fn call_member_chain_of_call_member_chain(
&self,
parser: &mut JavascriptParser<'p>,
call_expr: CallExpression,
callee_members: &[Atom],
inner_call_expr: CallExpression,
members: &[Atom],
member_ranges: &[Span],
for_name: &str,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::CallMemberChainOfCallMemberChain) {
let res = plugin.call_member_chain_of_call_member_chain(
parser,
call_expr,
callee_members,
inner_call_expr,
members,
member_ranges,
for_name,
);
if res.is_some() {
return res;
}
}
None
}
fn assign(
&self,
parser: &mut JavascriptParser<'p>,
expr: AssignmentExpression,
span: Span,
for_name: &str,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::Assign) {
let res = plugin.assign(parser, expr, span, for_name);
if res.is_some() {
return res;
}
}
None
}
fn assign_member_chain(
&self,
parser: &mut JavascriptParser<'p>,
expr: AssignmentExpression,
members: &[Atom],
member_ranges: &[Span],
for_name: &str,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::AssignMemberChain) {
let res = plugin.assign_member_chain(parser, expr, members, member_ranges, for_name);
if res.is_some() {
return res;
}
}
None
}
fn r#typeof(
&self,
parser: &mut JavascriptParser<'p>,
expr: UnaryExpression,
for_name: &str,
) -> Option<bool> {
assert!(expr.operator(parser.ast.ast) == UnaryOperator::Typeof);
for plugin in self.plugins_for(JavascriptParserPluginHook::Typeof) {
let res = plugin.r#typeof(parser, expr, for_name);
if res.is_some() {
return res;
}
}
None
}
fn expression_logical_operator(
&self,
parser: &mut JavascriptParser<'p>,
expr: LogicalExpression,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::ExpressionLogicalOperator) {
let res = plugin.expression_logical_operator(parser, expr);
if res.is_some() {
return res;
}
}
None
}
fn binary_expression(
&self,
parser: &mut JavascriptParser<'p>,
expr: BinaryExpression,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::BinaryExpression) {
let res = plugin.binary_expression(parser, expr);
if res.is_some() {
return res;
}
}
None
}
fn statement(&self, parser: &mut JavascriptParser<'p>, stmt: Stmt) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::Statement) {
let res = plugin.statement(parser, stmt);
if res.is_some() {
return res;
}
}
None
}
fn unused_statement(&self, parser: &mut JavascriptParser<'p>, stmt: Stmt) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::UnusedStatement) {
let res = plugin.unused_statement(parser, stmt);
if res.is_some() {
return res;
}
}
None
}
fn statement_if(&self, parser: &mut JavascriptParser<'p>, expr: IfStatement) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::StatementIf) {
let res = plugin.statement_if(parser, expr);
if res.is_some() {
return res;
}
}
None
}
fn declarator(
&self,
parser: &mut JavascriptParser<'p>,
expr: VariableDeclarator,
stmt: VariableDeclaration,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::Declarator) {
let res = plugin.declarator(parser, expr, stmt);
if res.is_some() {
return res;
}
}
None
}
fn new_expression(
&self,
parser: &mut JavascriptParser<'p>,
expr: NewExpression,
for_name: &str,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::NewExpression) {
let res = plugin.new_expression(parser, expr, for_name);
if res.is_some() {
return res;
}
}
None
}
fn identifier(
&self,
parser: &mut JavascriptParser<'p>,
span: Span,
for_name: &str,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::Identifier) {
let res = plugin.identifier(parser, span, for_name);
if res.is_some() {
return res;
}
}
None
}
fn class_extends_expression(
&self,
parser: &mut JavascriptParser<'p>,
super_class: Expr,
class: Class,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::ClassExtendsExpression) {
let res = plugin.class_extends_expression(parser, super_class, class);
if res.is_some() {
return res;
}
}
None
}
fn class_body_element(
&self,
parser: &mut JavascriptParser<'p>,
member: ClassElement,
class: Class,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::ClassBodyElement) {
let res = plugin.class_body_element(parser, member, class);
if res.is_some() {
return res;
}
}
None
}
fn class_body_value(
&self,
parser: &mut JavascriptParser<'p>,
element: ClassElement,
expr_span: Span,
class: Class,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::ClassBodyValue) {
let res = plugin.class_body_value(parser, element, expr_span, class);
if res.is_some() {
return res;
}
}
None
}
fn this(
&self,
parser: &mut JavascriptParser<'p>,
expr: ThisExpression,
for_name: &str,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::This) {
let res = plugin.this(parser, expr, for_name);
if res.is_some() {
return res;
}
}
None
}
fn evaluate(
&self,
parser: &mut JavascriptParser<'p>,
expr: Expr,
) -> Option<BasicEvaluatedExpression<'p>> {
for plugin in self.plugins_for(JavascriptParserPluginHook::Evaluate) {
let res = plugin.evaluate(parser, expr);
if res.is_some() {
return res;
}
}
None
}
fn evaluate_typeof(
&self,
parser: &mut JavascriptParser<'p>,
expr: UnaryExpression,
for_name: &str,
) -> Option<BasicEvaluatedExpression<'p>> {
for plugin in self.plugins_for(JavascriptParserPluginHook::EvaluateTypeof) {
let res = plugin.evaluate_typeof(parser, expr, for_name);
if res.is_some() {
return res;
}
}
None
}
fn evaluate_binary_expression(
&self,
parser: &mut JavascriptParser<'p>,
expr: BinaryExpression,
left: &BasicEvaluatedExpression<'p>,
) -> Option<BasicEvaluatedExpression<'p>> {
for plugin in self.plugins_for(JavascriptParserPluginHook::EvaluateBinaryExpression) {
let res = plugin.evaluate_binary_expression(parser, expr, left);
if res.is_some() {
return res;
}
}
None
}
fn evaluate_call_expression(
&self,
parser: &mut JavascriptParser<'p>,
name: &str,
expr: CallExpression,
) -> Option<BasicEvaluatedExpression<'p>> {
for plugin in self.plugins_for(JavascriptParserPluginHook::EvaluateCallExpression) {
let res = plugin.evaluate_call_expression(parser, name, expr);
if res.is_some() {
return res;
}
}
None
}
fn evaluate_call_expression_member(
&self,
parser: &mut JavascriptParser<'p>,
property: &str,
expr: CallExpression,
param: &BasicEvaluatedExpression<'p>,
) -> Option<BasicEvaluatedExpression<'p>> {
for plugin in self.plugins_for(JavascriptParserPluginHook::EvaluateCallExpressionMember) {
let res = plugin.evaluate_call_expression_member(parser, property, expr, param);
if res.is_some() {
return res;
}
}
None
}
fn evaluate_identifier(
&self,
parser: &mut JavascriptParser<'p>,
for_name: &str,
member_expr_info: Option<&ExpressionExpressionInfo>,
start: u32,
end: u32,
) -> Option<BasicEvaluatedExpression<'p>> {
for plugin in self.plugins_for(JavascriptParserPluginHook::EvaluateIdentifier) {
let res = plugin.evaluate_identifier(parser, for_name, member_expr_info, start, end);
if res.is_some() {
return res;
}
}
None
}
fn can_collect_destructuring_assignment_properties(
&self,
parser: &mut JavascriptParser<'p>,
expr: Expr,
) -> Option<bool> {
for plugin in
self.plugins_for(JavascriptParserPluginHook::CanCollectDestructuringAssignmentProperties)
{
let res = plugin.can_collect_destructuring_assignment_properties(parser, expr);
if res.is_some() {
return res;
}
}
None
}
fn pattern(
&self,
parser: &mut JavascriptParser<'p>,
ident: PatternIdentifier,
for_name: &str,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::Pattern) {
let res = plugin.pattern(parser, ident, for_name);
if res.is_some() {
return res;
}
}
None
}
fn pre_declarator(
&self,
parser: &mut JavascriptParser<'p>,
declarator: VariableDeclarator,
declaration: VariableDeclaration,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::PreDeclarator) {
let res = plugin.pre_declarator(parser, declarator, declaration);
if res.is_some() {
return res;
}
}
None
}
fn can_rename(&self, parser: &mut JavascriptParser<'p>, str: &str) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::CanRename) {
let res = plugin.can_rename(parser, str);
if res.is_some() {
return res;
}
}
None
}
fn rename(&self, parser: &mut JavascriptParser<'p>, expr: Expr, str: &str) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::Rename) {
let res = plugin.rename(parser, expr, str);
if res.is_some() {
return res;
}
}
None
}
fn pre_statement(&self, parser: &mut JavascriptParser<'p>, stmt: Stmt) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::PreStatement) {
let res = plugin.pre_statement(parser, stmt);
if res.is_some() {
return res;
}
}
None
}
fn block_pre_statement(&self, parser: &mut JavascriptParser<'p>, stmt: Stmt) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::BlockPreStatement) {
let res = plugin.block_pre_statement(parser, stmt);
if res.is_some() {
return res;
}
}
None
}
fn import_call(
&self,
parser: &mut JavascriptParser<'p>,
expr: ImportExpression,
import_then: Option<CallExpression>,
members: Option<(&[Atom], bool /* is_call */)>,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::ImportCall) {
let res = plugin.import_call(parser, expr, import_then, members);
if res.is_some() {
return res;
}
}
None
}
fn meta_property(
&self,
parser: &mut JavascriptParser<'p>,
root_name: &str,
span: Span,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::MetaProperty) {
let res = plugin.meta_property(parser, root_name, span);
if res.is_some() {
return res;
}
}
None
}
fn unhandled_expression_member_chain(
&self,
parser: &mut JavascriptParser<'p>,
root_info: &ExportedVariableInfo,
expr: HookMemberExpression,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::UnhandledExpressionMemberChain) {
let res = plugin.unhandled_expression_member_chain(parser, root_info, expr);
if res.is_some() {
return res;
}
}
None
}
fn import(
&self,
parser: &mut JavascriptParser<'p>,
statement: ImportDeclaration,
source: &str,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::Import) {
let res = plugin.import(parser, statement, source);
if res.is_some() {
return res;
}
}
None
}
fn import_specifier(
&self,
parser: &mut JavascriptParser<'p>,
statement: ImportDeclaration,
source: &rspack_intern::Atom,
export_name: Option<&Atom>,
identifier_name: &Atom,
identifier: swc_next_ecma_ast::BindingIdentifier,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::ImportSpecifier) {
let res = plugin.import_specifier(
parser,
statement,
source,
export_name,
identifier_name,
identifier,
);
if res.is_some() {
return res;
}
}
None
}
fn export_import(
&self,
parser: &mut JavascriptParser<'p>,
statement: ExportImport,
source: &Atom,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::ExportImport) {
let res = plugin.export_import(parser, statement, source);
if res.is_some() {
return res;
}
}
None
}
fn export(&self, parser: &mut JavascriptParser<'p>, statement: ExportLocal) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::Export) {
let res = plugin.export(parser, statement);
if res.is_some() {
return res;
}
}
None
}
fn export_import_specifier(
&self,
parser: &mut JavascriptParser<'p>,
statement: ExportImport,
source: &Atom,
local_id: Option<&Atom>,
export_name: Option<&Atom>,
export_name_span: Option<Span>,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::ExportImportSpecifier) {
let res = plugin.export_import_specifier(
parser,
statement,
source,
local_id,
export_name,
export_name_span,
);
if res.is_some() {
return res;
}
}
None
}
fn export_specifier(
&self,
parser: &mut JavascriptParser<'p>,
statement: ExportLocal,
local_id: &Atom,
export_name: &Atom,
export_name_span: Span,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::ExportSpecifier) {
let res = plugin.export_specifier(parser, statement, local_id, export_name, export_name_span);
if res.is_some() {
return res;
}
}
None
}
fn export_expression(
&self,
parser: &mut JavascriptParser<'p>,
statement: ExportDefaultDeclaration,
expr: ExportDefaultDeclarationKind,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::ExportExpression) {
let res = plugin.export_expression(parser, statement, expr);
if res.is_some() {
return res;
}
}
None
}
fn optional_chaining(
&self,
parser: &mut JavascriptParser<'p>,
expr: ChainExpression,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::OptionalChaining) {
let res = plugin.optional_chaining(parser, expr);
if res.is_some() {
return res;
}
}
None
}
fn expression_conditional_operation(
&self,
parser: &mut JavascriptParser<'p>,
expr: ConditionalExpression,
) -> Option<bool> {
for plugin in self.plugins_for(JavascriptParserPluginHook::ExpressionConditionalOperation) {
let res = plugin.expression_conditional_operation(parser, expr);
if res.is_some() {
return res;
}
}
None
}
fn import_meta_property_in_destructuring(
&self,
parser: &mut JavascriptParser<'p>,
property: &DestructuringAssignmentProperty,
) -> Option<String> {
for plugin in self.plugins_for(JavascriptParserPluginHook::ImportMetaPropertyInDestructuring) {
let res = plugin.import_meta_property_in_destructuring(parser, property);
if res.is_some() {
return res;
}
}
None
}
}