use rspack_intern::AtomRef;
use rspack_util::{
SpanExt,
swc::{AstSubRangeExt, PropertyKeyValue, classify_property_key},
};
use smallvec::SmallVec;
use swc_next_ecma_ast::*;
use super::{
AllowedMemberTypes, CallHooksName, ExpressionExpressionInfo, JavascriptParser,
MemberExpressionInfo, PatRef, RootName, ScopeTerminated, TopLevelScope,
estree::{
ExportDefaultDeclaration, formal_parameter_patterns, formal_parameter_patterns_with_defaults,
formal_parameters_are_simple_identifiers, simple_assignment_target_identifier,
},
object_and_members_to_name,
};
use crate::{
Atom,
dependency::DependencyBranchGuard,
parser_plugin::{
CREATE_REQUIRE_EVALUATED_TAG, CREATE_REQUIRE_SPECIFIER_TAG, CREATED_REQUIRE_IDENTIFIER_TAG,
CreatedRequireTagData, JavascriptParserPlugin, is_create_require_namespace_member,
},
utils::eval::{BasicEvaluatedExpression, eval_member_expression_with_info},
visitors::{
AtomMembers, ExportedVariableInfo, PatternIdentifier, VariableInfo, VariableInfoFlags,
},
};
fn is_create_require_tag(tag: &str, include_create_require_fn: bool) -> bool {
tag == CREATED_REQUIRE_IDENTIFIER_TAG
|| (include_create_require_fn
&& (tag == CREATE_REQUIRE_SPECIFIER_TAG || tag == CREATE_REQUIRE_EVALUATED_TAG))
}
impl JavascriptParser<'_> {
pub(crate) fn in_semantic_scope<T>(&mut self, node: NodeId, f: impl FnOnce(&mut Self) -> T) -> T {
let db = &mut self.definitions_db;
let previous = db.semantic_context.scope;
if let Some(scope) = self.ast.semantic.scope_of(node) {
db.semantic_context.scope = scope;
}
let result = f(self);
self.definitions_db.semantic_context.scope = previous;
result
}
fn in_block_scope<F>(&mut self, in_executed_path: bool, f: F)
where
F: FnOnce(&mut Self),
{
let old_top_level_scope = self.top_level_scope;
let old_in_tagged_template_tag = self.in_tagged_template_tag;
let old_in_try = self.in_try;
let old_terminated = self.terminated;
self.in_tagged_template_tag = false;
let definitions = self
.definitions_db
.create_child(self.definitions_db.current_scope());
f(self);
let terminated = self.terminated;
self.definitions_db.exit_scope(definitions);
self.top_level_scope = old_top_level_scope;
self.in_tagged_template_tag = old_in_tagged_template_tag;
self.in_try = old_in_try;
self.terminated = old_terminated;
if in_executed_path && let Some(t) = terminated {
self.terminated = Some(t);
}
}
pub fn in_class_scope<I, F>(&mut self, has_this: bool, params: I, f: F)
where
F: FnOnce(&mut Self),
I: Iterator<Item = PatRef>,
{
let old_in_try = self.in_try;
let old_top_level_scope = self.top_level_scope;
let old_in_tagged_template_tag = self.in_tagged_template_tag;
let old_terminated = self.terminated;
self.in_try = false;
self.in_tagged_template_tag = false;
self.terminated = None;
let definitions = self
.definitions_db
.create_child(self.definitions_db.current_scope());
self.definitions_db.initialize_scope_bindings();
if has_this {
self.undefined_variable(&"this".into());
}
self.enter_patterns(params, |_, _, _| {});
f(self);
self.in_try = old_in_try;
self.definitions_db.exit_scope(definitions);
self.top_level_scope = old_top_level_scope;
self.in_tagged_template_tag = old_in_tagged_template_tag;
self.terminated = old_terminated;
}
pub(crate) fn in_function_scope<I, F>(&mut self, has_this: bool, params: I, f: F)
where
F: FnOnce(&mut Self),
I: Iterator<Item = PatRef>,
{
let old_top_level_scope = self.top_level_scope;
let old_in_tagged_template_tag = self.in_tagged_template_tag;
let old_terminated = self.terminated;
let definitions = self
.definitions_db
.create_child(self.definitions_db.current_scope());
self.definitions_db.initialize_scope_bindings();
self.in_tagged_template_tag = false;
self.terminated = None;
if has_this {
self.undefined_variable(&"this".into());
}
self.enter_patterns(params, |_, _, _| {});
f(self);
self.definitions_db.exit_scope(definitions);
self.top_level_scope = old_top_level_scope;
self.in_tagged_template_tag = old_in_tagged_template_tag;
self.terminated = old_terminated;
}
pub fn walk_module_items(&mut self, statements: SubRange<Stmt>) {
let ast = self.ast.ast;
for statement in ast.nodes(statements) {
self.walk_module_item(statement);
}
}
fn walk_module_item(&mut self, statement: Stmt) {
let ast = self.ast.ast;
match ast.stmt_data(statement) {
StmtData::ImportDeclaration(_)
| StmtData::ExportNamedDeclaration(_)
| StmtData::ExportDefaultDeclaration(_)
| StmtData::ExportAllDeclaration(_)
| StmtData::TsExportAssignment(_)
| StmtData::TsNamespaceExportDeclaration(_) => {
let drive = self.plugin_drive();
self.enter_statement(
statement.span(ast),
statement,
|parser, node| drive.module_declaration(parser, node).unwrap_or_default(),
|parser, node| match parser.ast.ast.stmt_data(node) {
StmtData::ExportDefaultDeclaration(declaration) => {
parser.walk_export_default_declaration(ExportDefaultDeclaration(declaration))
}
StmtData::ExportNamedDeclaration(declaration) => {
if let Some(declaration) = declaration.declaration(parser.ast.ast) {
parser.walk_statement(Stmt::Declaration(declaration));
}
}
_ => (),
},
);
}
_ => self.walk_statement(statement),
}
}
fn walk_export_default_declaration(&mut self, declaration: ExportDefaultDeclaration) {
let ast = self.ast.ast;
match ast.export_default_declaration_kind_data(declaration.0.declaration(ast)) {
ExportDefaultDeclarationKindData::Class(class) => {
self.walk_statement(Stmt::Declaration(Decl::Class(class)))
}
ExportDefaultDeclarationKindData::Function(function) => {
self.walk_statement(Stmt::Declaration(Decl::Function(function)))
}
ExportDefaultDeclarationKindData::Expr(expression) => self.walk_expression(expression),
_ => (),
}
}
pub fn walk_statements(&mut self, statements: SubRange<Stmt>) {
let ast = self.ast.ast;
let mut only_function_declaration = false;
for statement in ast.nodes(statements) {
if only_function_declaration
&& !matches!(
ast.kind_data(statement.node_id()),
NodeKindData::Function(_)
)
&& self
.plugin_drive()
.unused_statement(self, statement)
.unwrap_or(false)
{
continue;
}
self.walk_statement(statement);
if self.terminated.is_some() {
only_function_declaration = true;
}
}
}
pub(crate) fn walk_statement(&mut self, statement: Stmt) {
let drive = self.plugin_drive();
self.enter_statement(
statement.span(self.ast.ast),
statement,
|parser, _| drive.statement(parser, statement).unwrap_or_default(),
|parser, _| match parser.ast.ast.kind_data(statement.node_id()) {
NodeKindData::BlockStatement(stmt) => parser.in_semantic_scope(stmt.node_id(), |parser| {
parser.walk_block_statement(stmt);
}),
NodeKindData::Class(decl) => parser.walk_class_declaration(decl),
NodeKindData::Function(decl) => parser.in_semantic_scope(decl.node_id(), |parser| {
parser.walk_function_declaration(decl);
}),
NodeKindData::VariableDeclaration(decl) => parser.walk_variable_declaration(decl),
NodeKindData::DoWhileStatement(stmt) => parser.walk_do_while_statement(stmt),
NodeKindData::ExpressionStatement(stmt) => {
let old = parser.statement_path.pop().expect("should in statement");
parser
.statement_path
.push(stmt.expression(parser.ast.ast).span(parser.ast.ast).into());
parser.walk_expression_statement(stmt);
parser.statement_path.pop();
parser.statement_path.push(old);
}
NodeKindData::ForInStatement(stmt) => parser.in_semantic_scope(stmt.node_id(), |parser| {
parser.walk_for_in_statement(stmt);
}),
NodeKindData::ForOfStatement(stmt) => parser.in_semantic_scope(stmt.node_id(), |parser| {
parser.walk_for_of_statement(stmt);
}),
NodeKindData::ForStatement(stmt) => parser.in_semantic_scope(stmt.node_id(), |parser| {
parser.walk_for_statement(stmt);
}),
NodeKindData::IfStatement(stmt) => parser.walk_if_statement(stmt),
NodeKindData::LabeledStatement(stmt) => parser.walk_labeled_statement(stmt),
NodeKindData::ReturnStatement(stmt) => parser.walk_return_statement(stmt),
NodeKindData::SwitchStatement(stmt) => parser.walk_switch_statement(stmt),
NodeKindData::ThrowStatement(stmt) => parser.walk_throw_stmt(stmt),
NodeKindData::TryStatement(stmt) => parser.walk_try_statement(stmt),
NodeKindData::WhileStatement(stmt) => parser.walk_while_statement(stmt),
NodeKindData::WithStatement(stmt) => parser.walk_with_statement(stmt),
_ => (),
},
);
}
fn walk_with_statement(&mut self, stmt: WithStatement) {
self.in_block_scope(true, |this| {
this.walk_expression(stmt.object(this.ast.ast));
this.in_semantic_scope(stmt.node_id(), |this| {
this.walk_nested_statement(stmt.body(this.ast.ast));
});
});
}
fn walk_while_statement(&mut self, stmt: WhileStatement) {
self.in_block_scope(false, |this| {
this.walk_expression(stmt.test(this.ast.ast));
this.walk_nested_statement(stmt.body(this.ast.ast));
});
}
fn walk_try_statement(&mut self, stmt: TryStatement) {
let ast = self.ast.ast;
let block = stmt.block(ast);
let was_in_try = self.in_try;
if self.in_try {
self.walk_statement(Stmt::BlockStatement(block));
} else {
self.in_try = true;
self.walk_statement(Stmt::BlockStatement(block));
self.in_try = false;
}
let try_terminated = self.terminated;
self.terminated = None;
let mut handler_terminated = None;
if let Some(handler) = stmt.handler(ast) {
self.in_semantic_scope(handler.node_id(), |this| this.walk_catch_clause(handler));
handler_terminated = self.terminated;
self.terminated = None;
}
let mut finalizer_terminated = None;
if let Some(finalizer) = stmt.finalizer(ast) {
self.walk_statement(Stmt::BlockStatement(finalizer));
finalizer_terminated = self.terminated;
self.terminated = None;
}
if let Some(t) = finalizer_terminated {
self.terminated = Some(t);
} else if let Some(t) = try_terminated
&& (stmt.handler(ast).is_none() || handler_terminated.is_some())
{
self.terminated = handler_terminated.or(Some(t));
}
self.in_try = was_in_try;
}
fn walk_catch_clause(&mut self, catch_clause: CatchClause) {
self.in_block_scope(true, |this| {
this.definitions_db.initialize_scope_bindings();
let ast = this.ast.ast;
if let Some(param) = catch_clause.param(ast) {
this.enter_pattern(PatRef::Borrowed(param), |_, _, _| {});
this.walk_pattern(param)
}
let body = catch_clause.body(ast);
this.walk_statement(Stmt::BlockStatement(body));
})
}
fn walk_switch_statement(&mut self, stmt: SwitchStatement) {
let ast = self.ast.ast;
self.walk_expression(stmt.discriminant(ast));
self.in_semantic_scope(stmt.node_id(), |this| {
this.walk_switch_cases(stmt.cases(ast))
});
}
fn walk_switch_cases(&mut self, cases: SubRange<SwitchCase>) {
self.in_block_scope(false, |this| {
this.definitions_db.initialize_scope_bindings();
let ast = this.ast.ast;
for case in ast.nodes(cases) {
let consequent = case.consequent(ast);
if !consequent.is_empty() {
let prev = this.prev_statement;
this.block_pre_walk_statements(consequent);
this.prev_statement = prev;
}
}
for case in ast.nodes(cases) {
if let Some(test) = case.test(ast) {
this.walk_expression(test);
}
this.walk_statements(case.consequent(ast));
this.terminated = None;
}
})
}
fn walk_return_statement(&mut self, stmt: ReturnStatement) {
if let Some(arg) = stmt.argument(self.ast.ast) {
self.walk_expression(arg);
}
if self.is_top_level_scope() {
return;
}
self.terminated = Some(ScopeTerminated::Return);
}
fn walk_throw_stmt(&mut self, stmt: ThrowStatement) {
self.walk_expression(stmt.argument(self.ast.ast));
if self.is_top_level_scope() {
return;
}
self.terminated = Some(ScopeTerminated::Throw);
}
fn walk_labeled_statement(&mut self, stmt: LabeledStatement) {
self.in_block_scope(false, |this| {
this.walk_nested_statement(stmt.body(this.ast.ast));
});
}
fn walk_if_statement(&mut self, stmt: IfStatement) {
if let Some(result) = self.plugin_drive().statement_if(self, stmt) {
if result {
self.walk_nested_statement(stmt.consequent(self.ast.ast));
} else if let Some(alt) = stmt.alternate(self.ast.ast) {
self.walk_nested_statement(alt);
}
} else {
let guard = self.collect_dependencies_in_branch_guard(|parser| {
parser.walk_expression(stmt.test(parser.ast.ast));
let deps_in_guard = parser.dependencies_in_branch_guard.as_ref()?;
if deps_in_guard.is_empty() {
return None;
}
let evaluated = parser.evaluate_expression(stmt.test(parser.ast.ast));
if evaluated.is_dependency() {
return Some(evaluated.into_dependency());
}
None
});
if let Some(guard) = &guard {
self.with_branch_guard(DependencyBranchGuard::new(guard.clone()), |this| {
this.walk_nested_statement(stmt.consequent(this.ast.ast))
});
} else {
self.walk_nested_statement(stmt.consequent(self.ast.ast));
}
let consequent_terminated = self.terminated;
self.terminated = None;
if let Some(alt) = stmt.alternate(self.ast.ast) {
if let Some(guard) = guard {
self.with_branch_guard(DependencyBranchGuard::new(guard.not()), |this| {
this.walk_nested_statement(alt)
});
} else {
self.walk_nested_statement(alt);
}
}
let alternate_terminated = self.terminated;
self.terminated = if consequent_terminated.is_some() && alternate_terminated.is_some() {
alternate_terminated
} else {
None
};
}
}
fn walk_for_statement(&mut self, stmt: ForStatement) {
self.in_block_scope(false, |this| {
this.definitions_db.initialize_scope_bindings();
let ast = this.ast.ast;
if let Some(init) = stmt.init(ast) {
match ast.for_statement_init_data(init) {
ForStatementInitData::VariableDeclaration(decl) => {
this.block_pre_walk_variable_declaration(decl);
this.prev_statement = None;
this.walk_variable_declaration(decl);
}
ForStatementInitData::Expr(expr) => this.walk_expression(expr),
}
}
if let Some(test) = stmt.test(ast) {
this.walk_expression(test)
}
if let Some(update) = stmt.update(ast) {
this.walk_expression(update)
}
this.walk_loop_body(stmt.body(ast));
});
}
fn walk_for_of_statement(&mut self, stmt: ForOfStatement) {
self.in_block_scope(false, |this| {
this.definitions_db.initialize_scope_bindings();
let ast = this.ast.ast;
let left = stmt.left(ast);
this.walk_for_head(left);
this.walk_expression(stmt.right(ast));
if this.javascript_options.is_create_require_enabled() {
this.clear_created_require_tags_in_for_head(left);
}
this.walk_loop_body(stmt.body(ast));
});
}
fn walk_for_in_statement(&mut self, stmt: ForInStatement) {
self.in_block_scope(false, |this| {
this.definitions_db.initialize_scope_bindings();
let ast = this.ast.ast;
let left = stmt.left(ast);
this.walk_for_head(left);
this.walk_expression(stmt.right(ast));
if this.javascript_options.is_create_require_enabled() {
this.clear_created_require_tags_in_for_head(left);
}
this.walk_loop_body(stmt.body(ast));
});
}
#[inline]
fn walk_loop_body(&mut self, body: Stmt) {
let ast = self.ast.ast;
if let Some(body) = body.as_block_statement(ast) {
let statements = body.body(ast);
self.in_semantic_scope(body.node_id(), |this| {
this.definitions_db.initialize_scope_bindings();
let prev = this.prev_statement;
this.block_pre_walk_statements(statements);
this.prev_statement = prev;
this.walk_statements(statements);
});
} else {
self.walk_nested_statement(body);
}
}
fn walk_for_head(&mut self, for_head: ForStatementLeft) {
match self.ast.ast.for_statement_left_data(for_head) {
ForStatementLeftData::VariableDeclaration(decl) => {
self.block_pre_walk_variable_declaration(decl);
self.walk_variable_declaration(decl);
}
ForStatementLeftData::AssignmentTarget(target) => {
self.enter_assignment_target(target, |_, _| {});
self.walk_assignment_target(target);
}
}
}
fn clear_created_require_tags_in_for_head(&mut self, for_head: ForStatementLeft) {
let ast = self.ast.ast;
let ForStatementLeftData::AssignmentTarget(target) = ast.for_statement_left_data(for_head)
else {
return;
};
match ast.assignment_target_data(target) {
AssignmentTargetData::SimpleAssignmentTarget(target) => {
if let SimpleAssignmentTargetData::IdentifierReference(identifier) =
ast.simple_assignment_target_data(target)
{
self.clear_create_require_tag(ast.get_utf8(identifier.name(ast)));
}
}
AssignmentTargetData::ArrayAssignmentTarget(array) => {
self.clear_created_require_tags_in_pattern(BindingPattern::ArrayPattern(array));
}
AssignmentTargetData::ObjectAssignmentTarget(object) => {
self.clear_created_require_tags_in_pattern(BindingPattern::ObjectPattern(object));
}
}
}
fn walk_variable_declaration(&mut self, decl: VariableDeclaration) {
let drive = self.plugin_drive();
let ast = self.ast.ast;
for declarator in ast.nodes(decl.declarators(ast)) {
let init = declarator.init(ast);
let id = declarator.id(ast);
if self.javascript_options.is_create_require_enabled()
&& let Some(init) = init
&& let Some(assign) = init.as_assignment_expression(ast)
&& assign.operator(ast) == AssignmentOperator::Assign
&& let AssignmentTargetData::SimpleAssignmentTarget(simple) =
ast.assignment_target_data(assign.left(ast))
&& let SimpleAssignmentTargetData::IdentifierReference(target) =
ast.simple_assignment_target_data(simple)
&& let BindingPatternData::BindingIdentifier(binding) = ast.binding_pattern_data(id)
&& self
.try_walk_created_require_assignment(assign, target)
.unwrap_or_default()
{
self.copy_create_require_assignment_result(
ast.get_utf8(binding.name(ast)),
ast.get_utf8(target.name(ast)),
);
continue;
}
if let Some(init) = init
&& let Some(renamed_identifier) = self.get_rename_identifier(init)
&& let BindingPatternData::BindingIdentifier(ident) = ast.binding_pattern_data(id)
{
if self.javascript_options.is_create_require_enabled()
&& renamed_identifier == CREATE_REQUIRE_EVALUATED_TAG
&& !matches!(
ast.expr_data(init),
ExprData::CallExpression(_) | ExprData::NewExpression(_)
)
{
self.set_variable(
Atom::from(ast.get_utf8(ident.name(ast))),
ExportedVariableInfo::Name(renamed_identifier),
);
self.walk_expression(init);
continue;
}
if !(self.javascript_options.is_create_require_enabled()
&& renamed_identifier == CREATE_REQUIRE_EVALUATED_TAG
&& matches!(
ast.expr_data(init),
ExprData::CallExpression(_) | ExprData::NewExpression(_)
))
&& drive
.can_rename(self, &renamed_identifier)
.unwrap_or_default()
{
if !drive
.rename(self, init, &renamed_identifier)
.unwrap_or_default()
{
self.set_variable(
Atom::from(ast.get_utf8(ident.name(ast))),
ExportedVariableInfo::Name(renamed_identifier.clone()),
);
}
continue;
}
}
if !drive.declarator(self, declarator, decl).unwrap_or_default() {
self.walk_pattern(id);
if let Some(init) = init {
self.walk_expression(init);
}
}
}
}
fn walk_expression_statement(&mut self, stmt: ExpressionStatement) {
self.walk_expression(stmt.expression(self.ast.ast));
}
pub fn walk_expression(&mut self, expr: Expr) {
match self.ast.ast.expr_data(expr) {
ExprData::ArrayExpression(expr) => self.walk_array_expression(expr),
ExprData::ArrowFunctionExpression(expr) => self.in_semantic_scope(expr.node_id(), |this| {
this.walk_arrow_function_expression(expr);
}),
ExprData::AssignmentExpression(expr) => self.walk_assignment_expression(expr),
ExprData::AwaitExpression(expr) => self.walk_await_expression(expr),
ExprData::BinaryExpression(expr) => self.walk_binary_expression(expr),
ExprData::LogicalExpression(expr) => self.walk_logical_expression(expr),
ExprData::CallExpression(expr) => self.walk_call_expression(expr),
ExprData::Class(expr) => self.walk_class_expression(expr),
ExprData::ConditionalExpression(expr) => self.walk_conditional_expression(expr),
ExprData::Function(expr) => self.in_semantic_scope(expr.node_id(), |this| {
this.walk_function_expression(expr);
}),
ExprData::IdentifierReference(expr) => self.walk_identifier(expr),
ExprData::ImportExpression(expr) => self.walk_import_expression(expr),
ExprData::MetaProperty(expr) => self.walk_meta_property(expr),
ExprData::MemberExpression(expr) => self.walk_member_expression(expr),
ExprData::NewExpression(expr) => self.walk_new_expression(expr),
ExprData::ObjectExpression(expr) => self.walk_object_expression(expr),
ExprData::ChainExpression(expr) => self.walk_chain_expression(expr),
ExprData::SequenceExpression(expr) => self.walk_sequence_expression(expr),
ExprData::TaggedTemplateExpression(expr) => self.walk_tagged_template_expression(expr),
ExprData::TemplateLiteral(expr) => self.walk_template_expression(expr),
ExprData::ThisExpression(expr) => self.walk_this_expression(expr),
ExprData::UnaryExpression(expr) => self.walk_unary_expression(expr),
ExprData::UpdateExpression(expr) => self.walk_update_expression(expr),
ExprData::YieldExpression(expr) => self.walk_yield_expression(expr),
ExprData::JsxElement(element) => {
self.ensure_jsx_enabled();
self.walk_jsx_element(element);
}
ExprData::JsxFragment(fragment) => {
self.ensure_jsx_enabled();
self.walk_jsx_fragment(fragment);
}
ExprData::ParenthesizedExpression(_) => unreachable!(),
_ => (),
}
}
fn walk_yield_expression(&mut self, expr: YieldExpression) {
if let Some(argument) = expr.argument(self.ast.ast) {
self.walk_expression(argument);
}
}
fn walk_update_expression(&mut self, expr: UpdateExpression) {
let ast = self.ast.ast;
let argument = expr.argument(ast);
let updated_ident =
simple_assignment_target_identifier(ast, argument).map(|ident| ast.get_utf8(ident.name(ast)));
if let Some(name) = updated_ident {
self.mark_mutated_binding(Atom::from(name));
}
if !self.javascript_options.is_create_require_enabled() {
self.walk_simple_assign_target(argument);
return;
}
if let Some(name) = updated_ident {
self.clear_create_require_tag(name);
}
self.walk_simple_assign_target(argument);
if let Some(name) = updated_ident {
self.clear_create_require_tag(name);
}
}
fn clear_create_require_tag<'key>(&mut self, name: impl Into<AtomRef<'key>>) {
let name = name.into();
if let Some(variable_info) = self.get_variable_info(name) {
let declared_scope = variable_info.declared_scope;
let should_clear_name = variable_info.name.is_some_and(|name| {
name == CREATED_REQUIRE_IDENTIFIER_TAG
|| name == CREATE_REQUIRE_SPECIFIER_TAG
|| name == CREATE_REQUIRE_EVALUATED_TAG
});
let mut should_clear = should_clear_name;
let mut tag_info_id = variable_info.tag_info;
while let Some(id) = tag_info_id {
let tag_info = self.definitions_db.expect_get_tag_info(id);
if tag_info.tag == CREATED_REQUIRE_IDENTIFIER_TAG
|| tag_info.tag == CREATE_REQUIRE_SPECIFIER_TAG
|| tag_info.tag == CREATE_REQUIRE_EVALUATED_TAG
{
should_clear = true;
break;
}
tag_info_id = tag_info.next;
}
if should_clear {
let info = VariableInfo::create(
&mut self.definitions_db,
declared_scope,
None,
VariableInfoFlags::NORMAL,
None,
);
self
.definitions_db
.set(declared_scope, name.to_atom(), info);
}
}
}
fn has_create_require_tag<'key>(
&mut self,
name: impl Into<AtomRef<'key>>,
include_create_require_fn: bool,
) -> bool {
let Some(variable_info) = self.get_variable_info(name) else {
return false;
};
if variable_info
.name
.is_some_and(|name| is_create_require_tag(name, include_create_require_fn))
{
return true;
}
let mut tag_info_id = variable_info.tag_info;
while let Some(id) = tag_info_id {
let tag_info = self.definitions_db.expect_get_tag_info(id);
if is_create_require_tag(tag_info.tag, include_create_require_fn) {
return true;
}
tag_info_id = tag_info.next;
}
false
}
fn clear_created_require_tags_in_pattern(&mut self, pattern: BindingPattern) {
let ast = self.ast.ast;
match ast.binding_pattern_data(pattern) {
BindingPatternData::BindingIdentifier(identifier) => {
self.clear_create_require_tag(ast.get_utf8(identifier.name(ast)))
}
BindingPatternData::SimpleAssignmentTarget(target) => {
if let SimpleAssignmentTargetData::IdentifierReference(identifier) =
ast.simple_assignment_target_data(target)
{
self.clear_create_require_tag(ast.get_utf8(identifier.name(ast)));
}
}
BindingPatternData::AssignmentPattern(pattern) => {
self.clear_created_require_tags_in_pattern(pattern.left(ast));
}
BindingPatternData::BindingRestElement(rest) => {
self.clear_created_require_tags_in_pattern(rest.argument(ast));
}
BindingPatternData::ArrayPattern(array) => {
for element in ast.nodes(array.elements(ast)).flatten() {
self.clear_created_require_tags_in_pattern(element);
}
if let Some(rest) = array.rest(ast) {
self.clear_created_require_tags_in_pattern(rest.argument(ast));
}
}
BindingPatternData::ObjectPattern(object) => {
for property in ast.nodes(object.properties(ast)) {
self.clear_created_require_tags_in_pattern(property.value(ast));
}
if let Some(rest) = object.rest(ast) {
self.clear_created_require_tags_in_pattern(rest.argument(ast));
}
}
}
}
#[cold]
#[inline(never)]
fn try_walk_created_require_assignment(
&mut self,
expr: AssignmentExpression,
ident: IdentifierReference,
) -> Option<bool> {
let ast = self.ast.ast;
let ident_name = ast.get_utf8(ident.name(ast));
if matches!(
expr.operator(ast),
AssignmentOperator::LogicalOrAssign | AssignmentOperator::NullishAssign
) && self.has_create_require_tag(ident_name, true)
{
return Some(true);
}
if expr.operator(ast) != AssignmentOperator::Assign {
return None;
}
let right = expr.right(ast);
if let Some(variable) = right.as_identifier_reference(ast).and_then(|rhs| {
let rhs_name = ast.get_utf8(rhs.name(ast));
self
.has_create_require_tag(rhs_name, false)
.then(|| {
self
.get_variable_info(rhs_name)
.map(|info| info.binding_state())
})
.flatten()
}) {
self.set_variable(
ident_name.into(),
ExportedVariableInfo::VariableInfo(variable),
);
return Some(true);
}
if let Some(rename_identifier) = self.get_rename_identifier(right)
&& let Some(data) = self
.get_tag_data::<CreatedRequireTagData>(&rename_identifier, CREATED_REQUIRE_IDENTIFIER_TAG)
.cloned()
{
self.tag_variable(
ident_name.into(),
CREATED_REQUIRE_IDENTIFIER_TAG,
Some(CreatedRequireTagData {
side_effects: String::new(),
..data
}),
);
if !right.is_identifier_reference(ast) {
self.walk_expression(right);
}
return Some(true);
}
if is_create_require_namespace_member(self, right) {
self.tag_variable_without_data(ident_name.into(), CREATE_REQUIRE_SPECIFIER_TAG);
self.walk_expression(right);
return Some(true);
}
if let Some(rename_identifier) = self.get_rename_identifier(right)
&& rename_identifier == CREATE_REQUIRE_EVALUATED_TAG
{
self.set_variable(
ident_name.into(),
ExportedVariableInfo::Name(rename_identifier),
);
self.walk_expression(right);
return Some(true);
}
None
}
fn copy_create_require_assignment_result<'binding, 'target>(
&mut self,
binding: impl Into<AtomRef<'binding>>,
target: impl Into<AtomRef<'target>>,
) {
let binding = binding.into();
let target = target.into();
if let Some(data) = self
.get_tag_data::<CreatedRequireTagData>(target, CREATED_REQUIRE_IDENTIFIER_TAG)
.cloned()
{
self.tag_variable(
binding.to_atom(),
CREATED_REQUIRE_IDENTIFIER_TAG,
Some(CreatedRequireTagData {
side_effects: String::new(),
..data
}),
);
} else if let Some(info) = self.get_variable_info(target)
&& info
.name
.is_some_and(|name| name == CREATE_REQUIRE_EVALUATED_TAG)
{
self.set_variable(
binding.to_atom(),
ExportedVariableInfo::Name(CREATE_REQUIRE_EVALUATED_TAG.into()),
);
} else if self.has_create_require_tag(target, true) {
self.tag_variable_without_data(binding.to_atom(), CREATE_REQUIRE_SPECIFIER_TAG);
}
}
fn walk_unary_expression(&mut self, expr: UnaryExpression) {
let ast = self.ast.ast;
let argument = expr.argument(ast);
let drive = self.plugin_drive();
if expr.operator(ast) == UnaryOperator::Typeof
&& let Some(expr_info) =
self.get_member_expression_info_from_expr(argument, AllowedMemberTypes::Expression)
{
let MemberExpressionInfo::Expression(expr_info) = expr_info else {
unreachable!();
};
let handled = if expr_info.members.is_empty() {
expr_info
.root_info
.call_hooks_name(self, |this, for_name| drive.r#typeof(this, expr, for_name))
} else {
drive.r#typeof(self, expr, &expr_info.name)
};
if handled.unwrap_or_default() {
return;
}
};
self.walk_expression(argument)
}
fn walk_this_expression(&mut self, expr: ThisExpression) {
let drive = self.plugin_drive();
self.call_hooks_name("this", |this, for_name| drive.this(this, expr, for_name));
}
pub(crate) fn walk_template_expression(&mut self, expr: TemplateLiteral) {
let ast = self.ast.ast;
self.walk_expressions(ast.nodes(expr.expressions(ast)));
}
fn walk_tagged_template_expression(&mut self, expr: TaggedTemplateExpression) {
let ast = self.ast.ast;
self.in_tagged_template_tag = true;
self.walk_expression(expr.tag(ast));
self.in_tagged_template_tag = false;
self.walk_template_expression(expr.quasi(ast));
}
fn walk_sequence_expression(&mut self, expr: SequenceExpression) {
let ast = self.ast.ast;
let expressions = expr.expressions(ast);
if self.is_statement_level_expression(expr.span(ast))
&& let Some(old) = self.statement_path.pop()
{
let prev = self.prev_statement;
for expression in ast.nodes(expressions) {
self.statement_path.push(expression.span(ast).into());
self.walk_expression(expression);
self.prev_statement = self.statement_path.pop();
}
self.prev_statement = prev;
self.statement_path.push(old);
} else {
self.walk_expressions(ast.nodes(expressions));
}
}
fn ensure_jsx_enabled(&self) {
if !self.javascript_options.jsx.unwrap_or_default() {
unreachable!();
}
}
fn walk_jsx_element(&mut self, element: JsxElement) {
let ast = self.ast.ast;
let opening = element.opening_element(ast);
self.walk_jsx_element_name(opening.name(ast));
for attribute in ast.nodes(opening.attributes(ast)) {
self.walk_jsx_attr_or_spread(attribute);
}
for child in ast.nodes(element.children(ast)) {
self.walk_jsx_child(child);
}
if let Some(closing) = element.closing_element(ast) {
self.walk_jsx_element_name(closing.name(ast));
}
}
fn walk_jsx_fragment(&mut self, fragment: JsxFragment) {
let ast = self.ast.ast;
for child in ast.nodes(fragment.children(ast)) {
self.walk_jsx_child(child);
}
}
fn walk_jsx_child(&mut self, child: JsxChild) {
let ast = self.ast.ast;
match ast.jsx_child_data(child) {
JsxChildData::JsxElement(element) => self.walk_jsx_element(element),
JsxChildData::JsxFragment(fragment) => self.walk_jsx_fragment(fragment),
JsxChildData::JsxExpressionContainer(container) => self.walk_jsx_expr_container(container),
JsxChildData::JsxSpreadChild(spread) => self.walk_expression(spread.expression(ast)),
JsxChildData::JsxText(_) => (),
}
}
fn walk_jsx_expr_container(&mut self, container: JsxExpressionContainer) {
let ast = self.ast.ast;
match ast.jsx_expression_data(container.expression(ast)) {
JsxExpressionData::Expr(expression) => self.walk_expression(expression),
JsxExpressionData::JsxEmptyExpression(_) => (),
}
}
fn walk_jsx_attr_or_spread(&mut self, attribute: JsxAttributeItem) {
let ast = self.ast.ast;
match ast.jsx_attribute_item_data(attribute) {
JsxAttributeItemData::JsxAttribute(attribute) => self.walk_jsx_attr(attribute),
JsxAttributeItemData::JsxSpreadAttribute(spread) => {
self.walk_expression(spread.argument(ast));
}
}
}
fn walk_jsx_attr(&mut self, attribute: JsxAttribute) {
if let Some(value) = attribute.value(self.ast.ast) {
self.walk_jsx_attr_value(value);
}
}
fn walk_jsx_attr_value(&mut self, value: JsxAttributeValue) {
match self.ast.ast.jsx_attribute_value_data(value) {
JsxAttributeValueData::StringLiteral(_) => (),
JsxAttributeValueData::JsxExpressionContainer(container) => {
self.walk_jsx_expr_container(container);
}
JsxAttributeValueData::JsxElement(element) => self.walk_jsx_element(element),
JsxAttributeValueData::JsxFragment(fragment) => self.walk_jsx_fragment(fragment),
}
}
fn walk_jsx_element_name(&mut self, name: JsxElementName) {
match self.ast.ast.jsx_element_name_data(name) {
JsxElementNameData::JsxIdentifier(identifier) => self.walk_jsx_identifier(identifier),
JsxElementNameData::JsxMemberExpression(member) => self.walk_jsx_member_expr(member),
JsxElementNameData::JsxNamespacedName(namespaced) => {
self.walk_jsx_namespaced_name(namespaced);
}
}
}
fn walk_jsx_member_expr(&mut self, member: JsxMemberExpression) {
let ast = self.ast.ast;
let mut current = member;
let mut member_nodes = SmallVec::<[JsxMemberExpression; 2]>::new();
let root = loop {
let object = current.object(ast);
member_nodes.push(current);
match ast.jsx_member_expression_object_data(object) {
JsxMemberExpressionObjectData::JsxIdentifier(identifier) => break identifier,
JsxMemberExpressionObjectData::JsxMemberExpression(member) => current = member,
}
};
let root_name = ast.get_utf8(root.name(ast));
let Some(name_info) = self.get_name_info_from_variable(root_name) else {
self.walk_identifier_name(root_name, root.span(ast));
return;
};
let resolved_root = name_info.name;
let root_info = name_info.info.map_or_else(
|| ExportedVariableInfo::Name(root_name.into()),
|info| ExportedVariableInfo::VariableInfo(info.binding_state()),
);
let mut members: AtomMembers = member_nodes
.iter()
.map(|member| Atom::from(ast.get_utf8(member.property(ast).name(ast))))
.collect();
let name = object_and_members_to_name(resolved_root, &members);
members.reverse();
member_nodes.reverse();
let members_optionals = std::iter::repeat_n(false, member_nodes.len()).collect();
let member_ranges = member_nodes
.iter()
.map(|member| member.object(ast).span(ast))
.collect();
let expression_info = ExpressionExpressionInfo {
name,
root_info,
members,
members_optionals,
member_ranges,
};
let drive = self.plugin_drive();
if drive
.member(self, member.into(), &expression_info.name)
.unwrap_or_default()
{
return;
}
if expression_info
.root_info
.call_hooks_name(self, |this, for_name| {
drive.member_chain(
this,
member.into(),
for_name,
&expression_info.members,
&expression_info.members_optionals,
&expression_info.member_ranges,
)
})
.unwrap_or_default()
{
return;
}
let mut prefix_name = expression_info.name.as_str();
for index in (0..member_nodes.len().saturating_sub(1)).rev() {
let removed_member = &expression_info.members[index + 1];
prefix_name = &prefix_name[..prefix_name.len() - removed_member.len() - 1];
if drive
.member(self, member_nodes[index].into(), prefix_name)
.unwrap_or_default()
{
return;
}
}
if !drive
.unhandled_expression_member_chain(self, &expression_info.root_info, member.into())
.unwrap_or_default()
{
self.walk_identifier_name(root_name, root.span(ast));
}
}
fn walk_jsx_namespaced_name(&mut self, name: JsxNamespacedName) {
let ast = self.ast.ast;
self.walk_jsx_identifier(name.namespace(ast));
self.walk_jsx_identifier(name.name(ast));
}
fn walk_jsx_identifier(&mut self, identifier: JsxIdentifier) {
let ast = self.ast.ast;
let name = ast.get_utf8(identifier.name(ast));
if name.as_bytes().first().is_some_and(u8::is_ascii_lowercase) {
return;
}
self.walk_identifier_name(name, identifier.span(ast));
}
fn walk_object_expression(&mut self, expr: ObjectExpression) {
let ast = self.ast.ast;
for property in ast.nodes(expr.properties(ast)) {
match ast.object_property_kind_data(property) {
ObjectPropertyKindData::SpreadElement(spread) => {
self.walk_expression(spread.argument(ast));
}
ObjectPropertyKindData::ObjectProperty(property) => {
self.walk_object_property(property);
}
}
}
}
fn walk_object_property(&mut self, property: ObjectProperty) {
let ast = self.ast.ast;
if property.computed(ast) {
self.walk_property_key(property.key(ast));
}
if property.shorthand(ast) {
self.in_short_hand = true;
self.walk_expression(property.value(ast));
self.in_short_hand = false;
} else {
self.walk_expression(property.value(ast));
}
}
fn walk_property_key(&mut self, key: PropertyKey) {
if let PropertyKeyData::Expr(expression) = self.ast.ast.property_key_data(key) {
self.walk_expression(expression);
}
}
fn walk_new_expression(&mut self, expr: NewExpression) {
let ast = self.ast.ast;
let callee = expr.callee(ast);
if let Some(MemberExpressionInfo::Expression(info)) =
self.get_member_expression_info_from_expr(callee, AllowedMemberTypes::Expression)
{
let result = if info.members.is_empty() {
info.root_info.call_hooks_name(self, |parser, for_name| {
parser.plugin_drive().new_expression(parser, expr, for_name)
})
} else {
self.plugin_drive().new_expression(self, expr, &info.name)
};
if result.unwrap_or_default() {
return;
}
}
self.walk_expression(callee);
self.walk_arguments(ast.nodes(expr.arguments(ast)));
}
fn walk_meta_property(&mut self, expr: MetaProperty) {
let ast = self.ast.ast;
let Some(root_name) = expr.get_root_name(ast) else {
unreachable!()
};
self
.plugin_drive()
.meta_property(self, root_name, expr.span(ast));
}
fn walk_conditional_expression(&mut self, expr: ConditionalExpression) {
let ast = self.ast.ast;
let test = expr.test(ast);
let consequent = expr.consequent(ast);
let alternate = expr.alternate(ast);
let result = self
.plugin_drive()
.expression_conditional_operation(self, expr);
if let Some(result) = result {
if result {
self.walk_expression(consequent);
} else {
self.walk_expression(alternate);
}
} else {
let guard = self.collect_dependencies_in_branch_guard(|parser| {
parser.walk_expression(test);
let deps_in_guard = parser.dependencies_in_branch_guard.as_ref()?;
if deps_in_guard.is_empty() {
return None;
}
let evaluated = parser.evaluate_expression(test);
if evaluated.is_dependency() {
return Some(evaluated.into_dependency());
}
None
});
if let Some(guard) = &guard {
self.with_branch_guard(DependencyBranchGuard::new(guard.clone()), |this| {
this.walk_expression(consequent)
});
} else {
self.walk_expression(consequent);
}
if let Some(guard) = guard {
self.with_branch_guard(DependencyBranchGuard::new(guard.not()), |this| {
this.walk_expression(alternate)
});
} else {
self.walk_expression(alternate);
}
}
}
fn walk_class_expression(&mut self, expr: Class) {
self.walk_class(expr);
}
fn walk_chain_expression(&mut self, expr: ChainExpression) {
if self.plugin_drive().optional_chaining(self, expr).is_none() {
self.enter_optional_chain(
expr,
|parser, call| parser.walk_call_expression(call),
|parser, member| parser.walk_member_expression(member),
);
}
}
fn walk_member_expression(&mut self, expr: MemberExpression) {
let ast = self.ast.ast;
let drive = self.plugin_drive();
let (expr_info, await_import_member) = self.get_member_expression_info_and_await_import(expr);
if let Some(expr_info) = expr_info {
match expr_info {
MemberExpressionInfo::Expression(expr_info) => {
if drive
.member(self, expr.into(), &expr_info.name)
.unwrap_or_default()
{
return;
}
if expr_info
.root_info
.call_hooks_name(self, |this, for_name| {
drive.member_chain(
this,
expr.into(),
for_name,
&expr_info.members,
&expr_info.members_optionals,
&expr_info.member_ranges,
)
})
.unwrap_or_default()
{
return;
}
self.walk_member_expression_with_expression_name(
expr,
&expr_info.name,
&expr_info.members,
Some(|this: &mut Self| {
drive.unhandled_expression_member_chain(this, &expr_info.root_info, expr.into())
}),
);
return;
}
MemberExpressionInfo::Call(expr_info) => {
if expr_info
.root_info
.call_hooks_name(self, |this, for_name| {
drive.member_chain_of_call_member_chain(
this,
expr,
&expr_info.callee_members,
expr_info.call,
&expr_info.members,
&expr_info.member_ranges,
for_name,
)
})
.unwrap_or_default()
{
return;
}
self.walk_call_expression(expr_info.call);
return;
}
}
}
let object = expr.object(ast);
if object.is_meta_property(ast)
&& let Some(root_name) = object.get_root_name(ast)
{
let root_info = ExportedVariableInfo::Name(Atom::from(root_name));
if drive
.unhandled_expression_member_chain(self, &root_info, expr.into())
.unwrap_or_default()
{
if expr.computed(ast)
&& let PropertyKeyData::Expr(property) = ast.property_key_data(expr.property(ast))
{
self.walk_expression(property);
}
return;
}
}
if let Some((call, members, await_expr)) = await_import_member {
if self.is_top_level_scope() {
self.plugin_drive().top_level_await_expr(self, await_expr);
}
if self
.plugin_drive()
.import_call(self, call, None, Some((&members, false)))
.unwrap_or_default()
{
return;
}
}
self.member_expr_in_optional_chain = false;
self.walk_expression(object);
if expr.computed(ast)
&& let PropertyKeyData::Expr(property) = ast.property_key_data(expr.property(ast))
{
self.walk_expression(property)
}
}
fn walk_member_expression_with_expression_name<F>(
&mut self,
expr: MemberExpression,
name: &str,
members: &[Atom],
on_unhandled: Option<F>,
) where
F: FnOnce(&mut Self) -> Option<bool>,
{
let ast = self.ast.ast;
let drive = self.plugin_drive();
let object = expr.object(ast);
let member = match ast.expr_data(object) {
ExprData::MemberExpression(member) => Some(member),
ExprData::ChainExpression(chain) => chain.expression(ast).as_member_expression(ast),
_ => None,
};
if let Some(member) = member
&& let Some(property) = members.last()
{
let origin = name.len();
let name = &name[0..origin - 1 - property.len()];
if self
.call_hooks_name(name, |this, for_name| {
drive.member(this, member.into(), for_name)
})
.unwrap_or_default()
{
return;
}
self.walk_member_expression_with_expression_name(
member,
name,
&members[..members.len() - 1],
on_unhandled,
);
} else if on_unhandled.is_none() {
self.walk_expression(object);
} else if let Some(on_unhandled) = on_unhandled
&& !on_unhandled(self).unwrap_or_default()
{
self.walk_expression(object);
}
if expr.computed(ast)
&& let PropertyKeyData::Expr(property) = ast.property_key_data(expr.property(ast))
{
self.walk_expression(property)
}
}
fn property_key_name<'a>(ast: &'a Ast<'_>, key: PropertyKey) -> Option<&'a str> {
match classify_property_key(ast, key) {
PropertyKeyValue::IdentifierName(identifier) => Some(ast.get_utf8(identifier.name(ast))),
PropertyKeyValue::StringLiteral(literal) => ast.get_wtf8(literal.value(ast)).as_str(),
_ => None,
}
}
fn parameter_identifiers<'a>(
ast: &'a Ast<'_>,
params: FormalParameters,
) -> impl Iterator<Item = Option<BindingIdentifier>> + 'a {
formal_parameter_patterns(ast, params).map(move |pattern| pattern.as_binding_identifier(ast))
}
#[inline]
pub(crate) fn walk_function_expression_body(&mut self, function: Expr) {
let ast = self.ast.ast;
match ast.expr_data(function) {
ExprData::Function(function) => self.walk_function_body(function.body(ast)),
ExprData::ArrowFunctionExpression(arrow) => {
match ast.arrow_function_body_data(arrow.body(ast)) {
ArrowFunctionBodyData::FunctionBody(body) => self.walk_function_body(body),
ArrowFunctionBodyData::Expr(expression) => self.walk_expression(expression),
}
}
_ => unreachable!("expected a function or arrow expression"),
}
}
pub(crate) fn walk_function_body(&mut self, body: FunctionBody) {
self.in_semantic_scope(body.node_id(), |this| {
let db = &mut this.definitions_db;
if this.ast.semantic.scope_of(body.node_id()).is_some() {
db.initialize_scope_bindings();
}
let ast = this.ast.ast;
if !this.is_strict()
&& this
.ast
.semantic
.scope(this.definitions_db.semantic_context.scope)
.flags
.strict
{
for directive in ast.nodes(body.directives(ast)) {
if ast.get_utf8(directive.value(ast)) == "use strict" {
this.set_strict(true);
break;
}
}
}
let statements = body.body(ast);
let prev = this.prev_statement;
this.pre_walk_statements(statements);
this.prev_statement = prev;
this.block_pre_walk_statements(statements);
this.prev_statement = prev;
this.walk_statements(statements);
});
}
fn walk_import_expression(&mut self, expr: ImportExpression) {
if self
.plugin_drive()
.import_call(self, expr, None, None)
.unwrap_or_default()
{
return;
}
let ast = self.ast.ast;
self.walk_expression(expr.source(ast));
if let Some(options) = expr.options(ast) {
self.walk_expression(options);
}
}
fn _walk_iife(
&mut self,
expr: Expr,
args: impl Iterator<Item = Argument>,
current_this: Option<Argument>,
) {
fn get_var_name(parser: &mut JavascriptParser, expr: Expr) -> Option<ExportedVariableInfo> {
if let Some(rename_identifier) = parser.get_rename_identifier(expr)
&& let drive = parser.plugin_drive()
&& parser
.call_hooks_name(&rename_identifier, |this, for_name| {
drive.can_rename(this, for_name)
})
.unwrap_or_default()
{
if !parser
.call_hooks_name(&rename_identifier, |this, for_name| {
drive.rename(this, expr, for_name)
})
.unwrap_or_default()
{
let variable = parser.get_variable_alias(rename_identifier);
return Some(variable);
}
return None;
}
parser.walk_expression(expr);
None
}
fn get_argument_var_name(
parser: &mut JavascriptParser,
argument: Argument,
can_map_parameter: &mut bool,
) -> Option<ExportedVariableInfo> {
let ast = parser.ast.ast;
match ast.argument_data(argument) {
ArgumentData::Expr(expression) if *can_map_parameter => get_var_name(parser, expression),
ArgumentData::Expr(expression) => {
parser.walk_expression(expression);
None
}
ArgumentData::SpreadElement(spread) => {
parser.walk_expression(spread.argument(ast));
*can_map_parameter = false;
None
}
}
}
let mut can_map_parameter = true;
let rename_this =
current_this.and_then(|this| get_argument_var_name(self, this, &mut can_map_parameter));
let variable_info_for_args = args
.map(|argument| get_argument_var_name(self, argument, &mut can_map_parameter))
.collect::<Vec<_>>();
let ast = self.ast.ast;
let mut scope_params = Vec::new();
let formal_params = match ast.expr_data(expr) {
ExprData::Function(function) => function.params(ast),
ExprData::ArrowFunctionExpression(arrow) => arrow.params(ast),
_ => unreachable!("IIFE must be a function or arrow function"),
};
for (i, identifier) in Self::parameter_identifiers(ast, formal_params)
.map(|identifier| identifier.expect("IIFE parameters must be binding identifiers"))
.enumerate()
{
if variable_info_for_args
.get(i)
.and_then(|info| info.as_ref())
.is_none()
{
scope_params.push(PatRef::Borrowed(BindingPattern::BindingIdentifier(
identifier,
)));
}
}
if let ExprData::Function(function) = ast.expr_data(expr)
&& let Some(identifier) = function.id(ast)
{
scope_params.push(PatRef::Owned(BindingPattern::BindingIdentifier(identifier)));
}
let was_top_level_scope = self.top_level_scope;
self.top_level_scope = if !matches!(was_top_level_scope, TopLevelScope::False)
&& expr.is_arrow_function_expression(ast)
{
TopLevelScope::ArrowFunction
} else {
TopLevelScope::False
};
self.in_semantic_scope(expr.node_id(), |this| {
this.in_function_scope(true, scope_params.into_iter(), |parser| {
if let Some(this) = rename_this
&& !expr.is_arrow_function_expression(parser.ast.ast)
{
parser.set_variable("this".into(), this)
}
for (var_info, param) in variable_info_for_args
.into_iter()
.zip(Self::parameter_identifiers(ast, formal_params))
{
if let Some(var_info) = var_info {
let param = param.expect("IIFE parameters must be binding identifiers");
parser.set_variable(
Atom::from(parser.ast.ast.get_utf8(param.name(parser.ast.ast))),
var_info,
);
}
}
parser.walk_function_expression_body(expr);
});
});
self.top_level_scope = was_top_level_scope;
}
fn walk_call_expression(&mut self, expr: CallExpression) {
let ast = self.ast.ast;
let callee = expr.callee(ast);
let callee_data = ast.expr_data(callee);
let callee_member = match callee_data {
ExprData::MemberExpression(member) => Some(member),
_ => None,
};
let arguments = expr.arguments(ast);
if let Some(member) = callee_member
&& let Some(function) = member.object(ast).as_function(ast)
&& Self::property_key_name(ast, member.property(ast))
.is_some_and(|name| name == "call" || name == "bind")
&& !arguments.is_empty()
&& formal_parameters_are_simple_identifiers(ast, function.params(ast))
{
let mut args = ast.nodes(arguments);
let current_this = args.next();
self._walk_iife(member.object(ast), args, current_this);
return;
}
let direct_params = match callee_data {
ExprData::Function(function) => Some(function.params(ast)),
ExprData::ArrowFunctionExpression(arrow) => Some(arrow.params(ast)),
_ => None,
};
if direct_params.is_some_and(|params| formal_parameters_are_simple_identifiers(ast, params)) {
self._walk_iife(callee, ast.nodes(arguments), None);
return;
}
let mut callee_expression_info = None;
if let Some(member) = callee_member {
let (member_info, await_import_member) =
self.get_member_expression_info_and_await_import(member);
match member_info {
Some(MemberExpressionInfo::Call(expr_info))
if expr_info
.root_info
.call_hooks_name(self, |this, for_name| {
this.plugin_drive().call_member_chain_of_call_member_chain(
this,
expr,
&expr_info.callee_members,
expr_info.call,
&expr_info.members,
&expr_info.member_ranges,
for_name,
)
})
.unwrap_or_default() =>
{
return;
}
Some(MemberExpressionInfo::Expression(info)) => callee_expression_info = Some(info),
_ => {}
}
if let Some(import) = member.object(ast).as_import_expression(ast)
&& Self::property_key_name(ast, member.property(ast)) == Some("then")
&& self
.plugin_drive()
.import_call(self, import, Some(expr), None)
.unwrap_or_default()
{
return;
}
if let Some((call, members, await_expr)) = await_import_member {
if self.is_top_level_scope() {
self.plugin_drive().top_level_await_expr(self, await_expr);
}
if self
.plugin_drive()
.import_call(self, call, None, Some((&members, true)))
.unwrap_or_default()
{
self.walk_arguments(ast.nodes(arguments));
return;
}
}
}
let evaluated_callee = if let Some(member) = callee_member {
eval_member_expression_with_info(self, member, callee, callee_expression_info)
.unwrap_or_else(|| {
let span = callee.span(ast);
BasicEvaluatedExpression::with_range(span.real_lo(), span.real_hi())
})
.with_expression_ast(Some(callee), self.active_synthetic_ast)
} else {
self.evaluate_expression(callee)
};
if evaluated_callee.is_identifier() {
let (members, members_optionals, member_ranges) =
evaluated_callee.member_path().unwrap_or((&[], &[], &[]));
let drive = self.plugin_drive();
if evaluated_callee
.root_info()
.call_hooks_name(self, |parser, for_name| {
drive.call_member_chain(
parser,
expr,
for_name,
members,
members_optionals,
member_ranges,
)
})
.unwrap_or_default()
{
return;
}
if drive
.call(self, expr, evaluated_callee.identifier())
.unwrap_or_default()
{
return;
}
}
if let Some(member) = callee_member {
self.walk_expression(member.object(ast));
if member.computed(ast)
&& let PropertyKeyData::Expr(property) = ast.property_key_data(member.property(ast))
{
self.walk_expression(property);
}
} else {
self.walk_expression(callee);
}
self.walk_arguments(ast.nodes(arguments));
}
fn get_member_expression_info_and_await_import(
&mut self,
expr: MemberExpression,
) -> (
Option<MemberExpressionInfo>,
Option<(ImportExpression, AtomMembers, AwaitExpression)>,
) {
let ast = self.ast.ast;
let super::RawExtractedMemberExpressionChainData { object, members } =
self.extract_member_expression_chain_raw(Expr::MemberExpression(expr));
if let ExprData::AwaitExpression(await_expr) = ast.expr_data(object)
&& let Some(call) = await_expr.argument(ast).as_import_expression(ast)
{
let members = members
.iter()
.rev()
.take_while(|member| !member.optional)
.map(|member| member.atom(ast))
.collect();
return (None, Some((call, members, await_expr)));
}
(
self._get_member_expression_info(object, members, AllowedMemberTypes::all()),
None,
)
}
pub fn walk_arguments<I>(&mut self, arguments: I)
where
I: Iterator<Item = Argument>,
{
let ast = self.ast.ast;
for argument in arguments {
match ast.argument_data(argument) {
ArgumentData::Expr(expression) => self.walk_expression(expression),
ArgumentData::SpreadElement(spread) => self.walk_expression(spread.argument(ast)),
}
}
}
fn walk_left_right_expression(&mut self, left: Expr, right: Expr) {
self.walk_expression(left);
self.walk_expression(right);
}
fn walk_binary_expression(&mut self, expr: BinaryExpression) {
if self.plugin_drive().binary_expression(self, expr).is_none() {
let ast = self.ast.ast;
self.walk_left_right_expression(expr.left(ast), expr.right(ast));
}
}
fn walk_logical_expression(&mut self, expr: LogicalExpression) {
let ast = self.ast.ast;
if let Some(keep_right) = self.plugin_drive().expression_logical_operator(self, expr) {
if keep_right {
self.walk_expression(expr.right(ast));
}
} else {
self.walk_left_right_expression(expr.left(ast), expr.right(ast));
}
}
fn walk_await_expression(&mut self, expr: AwaitExpression) {
if self.is_top_level_scope() {
self.plugin_drive().top_level_await_expr(self, expr);
}
self.walk_expression(expr.argument(self.ast.ast));
}
fn walk_identifier(&mut self, identifier: IdentifierReference) {
let ast = self.ast.ast;
let drive = self.plugin_drive();
identifier.call_hooks_name(self, |this, for_name| {
drive.identifier(this, identifier.span(ast), for_name)
});
}
fn walk_identifier_name(&mut self, name: &str, span: Span) {
let drive = self.plugin_drive();
self.call_hooks_name(name, |this, for_name| {
drive.identifier(this, span, for_name)
});
}
fn get_rename_identifier(&mut self, expr: Expr) -> Option<Atom> {
let result = self.evaluate_expression(expr);
result.is_identifier().then(|| result.identifier().clone())
}
fn enter_assignment_target<F>(&mut self, target: AssignmentTarget, on_ident: F)
where
F: FnOnce(&mut Self, PatternIdentifier) + Copy,
{
let old = self.in_assignment_pattern;
self.in_assignment_pattern = true;
let pattern = match self.ast.ast.assignment_target_data(target) {
AssignmentTargetData::SimpleAssignmentTarget(target) => {
BindingPattern::SimpleAssignmentTarget(target)
}
AssignmentTargetData::ArrayAssignmentTarget(array) => BindingPattern::ArrayPattern(array),
AssignmentTargetData::ObjectAssignmentTarget(object) => BindingPattern::ObjectPattern(object),
};
self.enter_assignment_target_pattern(pattern, on_ident);
self.in_assignment_pattern = old;
}
fn enter_assignment_target_pattern<F>(&mut self, pattern: BindingPattern, on_ident: F)
where
F: FnOnce(&mut Self, PatternIdentifier) + Copy,
{
let ast = self.ast.ast;
let identifier = match ast.binding_pattern_data(pattern) {
BindingPatternData::BindingIdentifier(identifier) => {
Some(PatternIdentifier::Binding(identifier))
}
BindingPatternData::SimpleAssignmentTarget(target) => {
simple_assignment_target_identifier(ast, target).map(PatternIdentifier::Reference)
}
BindingPatternData::ArrayPattern(array) => {
for element in ast.nodes(array.elements(ast)).flatten() {
self.enter_assignment_target_pattern(element, on_ident);
}
if let Some(rest) = array.rest(ast) {
self.enter_assignment_target_pattern(rest.argument(ast), on_ident);
}
None
}
BindingPatternData::ObjectPattern(object) => {
for property in ast.nodes(object.properties(ast)) {
let old = self.in_short_hand;
if property.shorthand(ast) {
self.in_short_hand = true;
}
self.enter_assignment_target_pattern(property.value(ast), on_ident);
self.in_short_hand = old;
}
if let Some(rest) = object.rest(ast) {
self.enter_assignment_target_pattern(rest.argument(ast), on_ident);
}
None
}
BindingPatternData::AssignmentPattern(assign) => {
self.enter_assignment_target_pattern(assign.left(ast), on_ident);
None
}
BindingPatternData::BindingRestElement(rest) => {
self.enter_assignment_target_pattern(rest.argument(ast), on_ident);
None
}
};
if let Some(identifier) = identifier {
if self.in_assignment_pattern {
self.mark_mutated_binding(Atom::from(identifier.name(ast)));
}
let drive = self.plugin_drive();
if !identifier
.call_hooks_name(self, |parser, for_name| {
drive.pattern(parser, identifier, for_name)
})
.unwrap_or_default()
{
on_ident(self, identifier);
}
}
}
fn walk_assignment_expression(&mut self, expr: AssignmentExpression) {
let ast = self.ast.ast;
let left = expr.left(ast);
let right = expr.right(ast);
let drive = self.plugin_drive();
if let Some(simple) = left.as_simple_assignment_target(ast)
&& let Some(ident) = simple_assignment_target_identifier(ast, simple)
{
if self.javascript_options.is_create_require_enabled()
&& self
.try_walk_created_require_assignment(expr, ident)
.unwrap_or_default()
{
return;
}
if expr.operator(ast) == AssignmentOperator::Assign
&& let Some(rename_identifier) = self.get_rename_identifier(right)
&& self
.call_hooks_name(&rename_identifier, |this, for_name| {
drive.can_rename(this, for_name)
})
.unwrap_or_default()
{
self.mark_mutated_binding(Atom::from(ast.get_utf8(ident.name(ast))));
if !self
.call_hooks_name(&rename_identifier, |this, for_name| {
drive.rename(this, right, for_name)
})
.unwrap_or_default()
{
let variable = self.get_variable_alias(rename_identifier);
self.set_variable(Atom::from(ast.get_utf8(ident.name(ast))), variable);
}
return;
}
if !self.javascript_options.is_create_require_enabled()
|| !right
.as_identifier_reference(ast)
.is_some_and(|rhs| self.has_create_require_tag(ast.get_utf8(rhs.name(ast)), false))
{
self.walk_expression(right);
}
let name = ast.get_utf8(ident.name(ast));
if self.javascript_options.is_create_require_enabled() {
self.clear_create_require_tag(name);
}
self.enter_assignment_target(left, |this, identifier| {
if !ident
.call_hooks_name(this, |this, for_name| {
drive.assign(this, expr, identifier.span(ast), for_name)
})
.unwrap_or_default()
{
this.walk_identifier(ident);
}
});
} else if let Some(array) = left.as_array_assignment_target(ast) {
self.walk_expression(right);
if self.javascript_options.is_create_require_enabled() {
self.clear_created_require_tags_in_pattern(BindingPattern::ArrayPattern(array));
}
self.enter_assignment_target(left, |this, ident| {
let ast = this.ast.ast;
let name = ident.name(ast);
if !this
.call_hooks_name(name, |this, for_name| {
drive.assign(this, expr, ident.span(ast), for_name)
})
.unwrap_or_default()
{
this.definitions_db.define(Atom::from(name));
}
});
self.walk_array_pattern(array, false);
} else if let Some(object) = left.as_object_assignment_target(ast) {
self.walk_expression(right);
if self.javascript_options.is_create_require_enabled() {
self.clear_created_require_tags_in_pattern(BindingPattern::ObjectPattern(object));
}
self.enter_assignment_target(left, |this, ident| {
let ast = this.ast.ast;
let name = ident.name(ast);
if !this
.call_hooks_name(name, |this, for_name| {
drive.assign(this, expr, ident.span(ast), for_name)
})
.unwrap_or_default()
{
this.definitions_db.define(Atom::from(name));
}
});
self.walk_object_pattern(object, false);
} else if let Some(member) = left
.as_simple_assignment_target(ast)
.and_then(|target| target.as_member_expression(ast))
{
if let Some(MemberExpressionInfo::Expression(expr_name)) = self.get_member_expression_info(
Expr::MemberExpression(member),
AllowedMemberTypes::Expression,
) && expr_name
.root_info
.call_hooks_name(self, |parser, for_name| {
drive.assign_member_chain(
parser,
expr,
&expr_name.members,
&expr_name.member_ranges,
for_name,
)
})
.unwrap_or_default()
{
return;
}
self.walk_expression(right);
self.walk_assignment_target(left);
} else {
self.walk_expression(right);
self.walk_assignment_target(left);
}
}
fn walk_arrow_function_expression(&mut self, expr: ArrowFunctionExpression) {
let ast = self.ast.ast;
let params = expr.params(ast);
let was_top_level_scope = self.top_level_scope;
if !matches!(was_top_level_scope, TopLevelScope::False) {
self.top_level_scope = TopLevelScope::ArrowFunction;
}
self.in_function_scope(
false,
formal_parameter_patterns(ast, params).map(PatRef::Borrowed),
|this| {
for (pattern, initializer) in formal_parameter_patterns_with_defaults(ast, params) {
if let Some(initializer) = initializer {
this.walk_expression(initializer);
}
this.walk_pattern(pattern);
}
match this
.ast
.ast
.arrow_function_body_data(expr.body(this.ast.ast))
{
ArrowFunctionBodyData::FunctionBody(body) => this.walk_function_body(body),
ArrowFunctionBodyData::Expr(expression) => this.walk_expression(expression),
}
},
);
self.top_level_scope = was_top_level_scope;
}
fn walk_expressions<I>(&mut self, expressions: I)
where
I: Iterator<Item = Expr>,
{
for expr in expressions {
self.walk_expression(expr)
}
}
fn walk_array_expression(&mut self, expr: ArrayExpression) {
let ast = self.ast.ast;
self.walk_arguments(ast.nodes(expr.elements(ast)).flatten());
}
fn walk_nested_statement(&mut self, stmt: Stmt) {
self.prev_statement = None;
self.walk_statement(stmt);
}
fn walk_do_while_statement(&mut self, stmt: DoWhileStatement) {
let ast = self.ast.ast;
self.in_block_scope(false, |this| {
this.walk_nested_statement(stmt.body(ast));
this.walk_expression(stmt.test(ast));
});
}
fn walk_block_statement(&mut self, stmt: BlockStatement) {
let ast = self.ast.ast;
let statements = stmt.body(ast);
self.in_block_scope(true, |this| {
this.definitions_db.initialize_scope_bindings();
let prev = this.prev_statement;
this.block_pre_walk_statements(statements);
this.prev_statement = prev;
this.walk_statements(statements);
})
}
fn walk_function_declaration(&mut self, function: Function) {
let was_top_level = self.top_level_scope;
self.top_level_scope = TopLevelScope::False;
let ast = self.ast.ast;
let patterns = formal_parameter_patterns(ast, function.params(ast));
self.in_function_scope(true, patterns.map(PatRef::Borrowed), |this| {
this.walk_function(function);
});
self.top_level_scope = was_top_level;
}
fn walk_function(&mut self, function: Function) {
let ast = self.ast.ast;
for (pattern, initializer) in formal_parameter_patterns_with_defaults(ast, function.params(ast))
{
if let Some(initializer) = initializer {
self.walk_expression(initializer);
}
self.walk_pattern(pattern);
}
self.walk_function_body(function.body(ast));
}
fn walk_function_expression(&mut self, expr: Function) {
let ast = self.ast.ast;
let was_top_level = self.top_level_scope;
self.top_level_scope = TopLevelScope::False;
let scope_params = formal_parameter_patterns(ast, expr.params(ast))
.map(PatRef::Borrowed)
.chain(
expr
.id(ast)
.map(BindingPattern::BindingIdentifier)
.map(PatRef::Owned),
);
self.in_function_scope(true, scope_params, |this| {
this.walk_function(expr);
});
self.top_level_scope = was_top_level;
}
pub fn walk_pattern(&mut self, pattern: BindingPattern) {
self.walk_pattern_with_identifiers(pattern, true);
}
fn walk_pattern_with_identifiers(&mut self, pattern: BindingPattern, walk_identifiers: bool) {
let ast = self.ast.ast;
match ast.binding_pattern_data(pattern) {
BindingPatternData::ArrayPattern(array) => self.walk_array_pattern(array, walk_identifiers),
BindingPatternData::AssignmentPattern(assignment) => {
self.walk_assignment_pattern(assignment, walk_identifiers);
}
BindingPatternData::ObjectPattern(object) => {
self.walk_object_pattern(object, walk_identifiers)
}
BindingPatternData::BindingRestElement(rest) => {
self.walk_rest_element(rest, walk_identifiers)
}
BindingPatternData::SimpleAssignmentTarget(target) => {
if walk_identifiers || !target.is_identifier_reference(ast) {
self.walk_simple_assign_target(target);
}
}
BindingPatternData::BindingIdentifier(_) => (),
}
}
fn walk_simple_assign_target(&mut self, target: SimpleAssignmentTarget) {
let ast = self.ast.ast;
match ast.simple_assignment_target_data(target) {
SimpleAssignmentTargetData::IdentifierReference(identifier) => {
self.walk_identifier(identifier);
}
SimpleAssignmentTargetData::MemberExpression(member) => self.walk_member_expression(member),
SimpleAssignmentTargetData::TsAsExpression(expression) => {
self.walk_expression(expression.expression(ast));
}
SimpleAssignmentTargetData::TsSatisfiesExpression(expression) => {
self.walk_expression(expression.expression(ast));
}
SimpleAssignmentTargetData::TsTypeAssertion(expression) => {
self.walk_expression(expression.expression(ast));
}
SimpleAssignmentTargetData::TsNonNullExpression(expression) => {
self.walk_expression(expression.expression(ast));
}
}
}
fn walk_assignment_target(&mut self, target: AssignmentTarget) {
match self.ast.ast.assignment_target_data(target) {
AssignmentTargetData::SimpleAssignmentTarget(target) => {
self.walk_simple_assign_target(target);
}
AssignmentTargetData::ArrayAssignmentTarget(array) => self.walk_array_pattern(array, true),
AssignmentTargetData::ObjectAssignmentTarget(object) => {
self.walk_object_pattern(object, true)
}
}
}
fn walk_rest_element(&mut self, rest: BindingRestElement, walk_identifiers: bool) {
self.walk_pattern_with_identifiers(rest.argument(self.ast.ast), walk_identifiers);
}
fn walk_object_pattern(&mut self, object: ObjectPattern, walk_identifiers: bool) {
let ast = self.ast.ast;
for property in ast.nodes(object.properties(ast)) {
if property.computed(ast) {
self.walk_property_key(property.key(ast));
}
self.walk_pattern_with_identifiers(property.value(ast), walk_identifiers);
}
if let Some(rest) = object.rest(ast) {
self.walk_rest_element(rest, walk_identifiers);
}
}
fn walk_assignment_pattern(&mut self, pattern: AssignmentPattern, walk_identifiers: bool) {
let ast = self.ast.ast;
self.walk_expression(pattern.right(ast));
self.walk_pattern_with_identifiers(pattern.left(ast), walk_identifiers);
}
fn walk_array_pattern(&mut self, pattern: ArrayPattern, walk_identifiers: bool) {
let ast = self.ast.ast;
for element in ast.nodes(pattern.elements(ast)).flatten() {
self.walk_pattern_with_identifiers(element, walk_identifiers);
}
if let Some(rest) = pattern.rest(ast) {
self.walk_rest_element(rest, walk_identifiers);
}
}
fn walk_class_declaration(&mut self, decl: Class) {
self.walk_class(decl);
}
fn walk_class(&mut self, class: Class) {
let ast = self.ast.ast;
if let Some(super_class) = class.super_class(ast)
&& !self
.plugin_drive()
.class_extends_expression(self, super_class, class)
.unwrap_or_default()
{
self.walk_expression(super_class);
}
let scope_param = match class.class_type(ast) {
ClassType::ClassExpression => class
.id(ast)
.map(BindingPattern::BindingIdentifier)
.map(PatRef::Owned),
ClassType::ClassDeclaration => None,
};
let elements = class.body(ast).body(ast);
self.in_semantic_scope(class.node_id(), |this| {
this.in_class_scope(true, scope_param.into_iter(), |this| {
for class_element in ast.nodes(elements) {
if this
.plugin_drive()
.class_body_element(this, class_element, class)
.unwrap_or_default()
{
continue;
}
match this.ast.ast.class_element_data(class_element) {
ClassElementData::MethodDefinition(method) => {
let ast = this.ast.ast;
if method.computed(ast) {
this.walk_property_key(method.key(ast));
}
if this
.plugin_drive()
.class_body_value(this, class_element, method.span(ast), class)
.unwrap_or_default()
{
continue;
}
let was_top_level = this.top_level_scope;
this.top_level_scope = TopLevelScope::False;
let function = method.value(ast);
let patterns = formal_parameter_patterns(ast, function.params(ast));
this.in_semantic_scope(function.node_id(), |this| {
this.in_function_scope(true, patterns.map(PatRef::Borrowed), |this| {
this.walk_function(function)
});
});
this.top_level_scope = was_top_level;
}
ClassElementData::PropertyDefinition(property) => {
let ast = this.ast.ast;
if property.computed(ast) {
this.walk_property_key(property.key(ast));
}
if let Some(value) = property.value(ast)
&& !this
.plugin_drive()
.class_body_value(this, class_element, value.span(ast), class)
.unwrap_or_default()
{
let was_top_level = this.top_level_scope;
this.top_level_scope = TopLevelScope::False;
this.walk_expression(value);
this.top_level_scope = was_top_level;
}
}
ClassElementData::StaticBlock(block) => {
let was_top_level = this.top_level_scope;
this.top_level_scope = TopLevelScope::False;
let ast = this.ast.ast;
let statements = block.body(ast);
this.in_semantic_scope(block.node_id(), |this| {
this.in_block_scope(true, |this| {
this.definitions_db.initialize_scope_bindings();
let prev = this.prev_statement;
this.block_pre_walk_statements(statements);
this.prev_statement = prev;
this.walk_statements(statements);
});
});
this.top_level_scope = was_top_level;
}
ClassElementData::TsMethodDefinition(method) => {
if method.computed(this.ast.ast) {
this.walk_property_key(method.key(this.ast.ast));
}
}
ClassElementData::TsIndexSignature(_) => {}
};
}
});
});
}
}