use rspack_core::{
AsyncDependenciesBlock, BoxDependency, ChunkGroupOptions, ContextDependency,
ContextNameSpaceObject, ContextOptions, Dependency, DependencyCategory, DependencyRange,
DependencyType, DynamicImportFetchPriority, DynamicImportMode, GroupOptions, ImportAttributes,
ReferencedSpecifier, get_context,
};
use rspack_error::{Error, Severity};
use rspack_util::{
SpanExt,
swc::{AstSubRangeExt, get_swc_next_comments},
};
use rustc_hash::{FxHashMap, FxHashSet};
use swc_next_ecma_ast::{
Ast, BindingIdentifier, BindingPattern, BindingPatternData, CallExpression, Expr, ExprData,
Function, GetSpan, IdentifierReference, ImportExpression, ObjectPattern, Span,
VariableDeclaration, VariableDeclarator, VariableKind, Visit, VisitWith,
};
use super::{
JavascriptParserPlugin,
compatibility_plugin::{NESTED_IDENTIFIER_TAG, NestedRequireData},
import_phase::get_import_phase,
inner_graph::state::InnerGraphUsageOperation,
};
use crate::{
Atom, InnerGraphParserPlugin,
dependency::{
ImportContextDependency, ImportDependency, ImportEagerDependency, ImportWeakDependency,
},
magic_comment::try_extract_magic_comment,
utils::object_properties::{get_attributes, get_value_by_obj_prop},
visitors::{
ContextModuleScanResult, DestructuringAssignmentProperties, HookMemberExpression,
JavascriptParser, PatRef, SymbolBinding, TagInfoData, TopLevelScope, VariableInfoFlags,
context_reg_exp, create_context_dependency, create_traceable_error, formal_parameter_pattern,
formal_parameter_patterns, formal_parameter_patterns_with_defaults, get_non_optional_part,
parse_order_string,
},
};
const DYNAMIC_IMPORT_TAG: &str = "dynamic import";
fn tag_dynamic_import_referenced(
parser: &mut JavascriptParser,
import_call: ImportExpression,
binding: BindingIdentifier,
) {
tag_dynamic_import_binding(parser, import_call, binding, vec![]);
}
fn tag_dynamic_import_binding(
parser: &mut JavascriptParser,
import_call: ImportExpression,
binding: BindingIdentifier,
export_path: Vec<Atom>,
) {
let import_span = import_call.span(parser.ast.ast);
parser.dynamic_import_references.add_import(import_span);
let resolution = parser.definitions_db.resolve_binding(parser.ast, binding);
let needs_compatibility = resolution.0.is_some_and(|state| {
parser
.get_variable_tag_data::<NestedRequireData>(state, NESTED_IDENTIFIER_TAG)
.is_some()
});
let Some(symbol) = resolution.1.filter(|_| !needs_compatibility) else {
parser
.dynamic_import_references
.get_import_mut_expect(&import_span)
.add_reference(export_path);
return;
};
let references = parser
.dynamic_import_references
.get_import_mut_expect(&import_span);
references.bindings.push((symbol, export_path.clone()));
let ast = parser.ast.ast;
parser.tag_variable_resolved(
Atom::from(ast.get_utf8(binding.name(ast))),
DYNAMIC_IMPORT_TAG,
Some(TagInfoData::into_any(ImportTagData {
import_span,
export_path,
})),
VariableInfoFlags::TAGGED,
resolution,
);
}
fn collect_destructuring_references(
properties: &DestructuringAssignmentProperties,
) -> Vec<Vec<Atom>> {
let mut references = Vec::new();
properties.traverse_on_leaf(&mut |stack| {
references.push(stack.iter().map(|property| property.id.clone()).collect());
});
references
}
fn track_destructuring_import_bindings(
parser: &mut JavascriptParser,
import_call: ImportExpression,
pattern: ObjectPattern,
) {
let Some(properties) =
parser.collect_destructuring_assignment_properties_from_object_pattern(pattern)
else {
return;
};
let import_span = import_call.span(parser.ast.ast);
parser.dynamic_import_references.add_import(import_span);
track_collected_import_bindings(parser, import_call, pattern, &properties, &mut Vec::new());
}
fn track_collected_import_bindings(
parser: &mut JavascriptParser,
import_call: ImportExpression,
pattern: ObjectPattern,
properties: &DestructuringAssignmentProperties,
path: &mut Vec<Atom>,
) {
let import_span = import_call.span(parser.ast.ast);
let ast = parser.ast.ast;
if properties.iter().next().is_none() && !path.is_empty() {
parser
.dynamic_import_references
.get_import_mut_expect(&import_span)
.add_reference(path.clone());
}
for (property, key) in ast.nodes(pattern.properties(ast)).zip(properties.iter()) {
path.push(key.id.clone());
let value = property.value(ast);
match (ast.binding_pattern_data(value), &key.pattern) {
(BindingPatternData::BindingIdentifier(binding), _) => {
tag_dynamic_import_binding(parser, import_call, binding, path.clone());
}
(BindingPatternData::ObjectPattern(pattern), Some(properties)) => {
track_collected_import_bindings(parser, import_call, pattern, properties, path);
}
_ => parser
.dynamic_import_references
.get_import_mut_expect(&import_span)
.add_reference(path.clone()),
}
path.pop();
}
}
fn is_unbound_promise_all(parser: &mut JavascriptParser, call: CallExpression) -> bool {
let ast = parser.ast.ast;
let Some(member) = call.callee(ast).as_member_expression(ast) else {
return false;
};
member
.object(ast)
.as_identifier_reference(ast)
.is_some_and(|ident| ast.get_utf8(ident.name(ast)) == "Promise")
&& member
.property(ast)
.as_identifier_name(ast)
.is_some_and(|ident| ast.get_utf8(ident.name(ast)) == "all")
&& parser.get_variable_info("Promise").is_none()
}
fn track_dynamic_import_pattern(
parser: &mut JavascriptParser,
import_call: ImportExpression,
pattern: BindingPattern,
) {
let ast = parser.ast.ast;
match ast.binding_pattern_data(pattern) {
BindingPatternData::BindingIdentifier(binding) => {
tag_dynamic_import_referenced(parser, import_call, binding);
}
BindingPatternData::ObjectPattern(pattern) => {
track_destructuring_import_bindings(parser, import_call, pattern);
}
BindingPatternData::AssignmentPattern(pattern) => {
track_dynamic_import_pattern(parser, import_call, pattern.left(ast));
}
_ => {}
}
}
fn track_dynamic_imports_in_promise_all(
parser: &mut JavascriptParser,
declarator: VariableDeclarator,
) {
let ast = parser.ast.ast;
let Some(pattern) = declarator.id(ast).as_array_pattern(ast) else {
return;
};
let Some(init) = declarator.init(ast) else {
return;
};
let Some(await_expr) = init.as_await_expression(ast) else {
return;
};
let Some(promise_all) = await_expr.argument(ast).as_call_expression(ast) else {
return;
};
if !is_unbound_promise_all(parser, promise_all) {
return;
}
let arguments = promise_all.arguments(ast);
if arguments.len() != 1 {
return;
}
let Some(argument) = ast.first(arguments) else {
return;
};
let Some(imports) = argument
.as_expr(ast)
.and_then(|expr| expr.as_array_expression(ast))
else {
return;
};
if ast
.optional_nodes(imports.elements(ast))
.any(|element| element.is_some_and(|argument| argument.is_spread_element(ast)))
{
return;
}
for (pattern, import) in ast
.optional_nodes(pattern.elements(ast))
.zip(ast.optional_nodes(imports.elements(ast)))
{
let (Some(pattern), Some(import)) = (pattern, import) else {
continue;
};
let Some(import_call) = import
.as_expr(ast)
.and_then(|expr| expr.as_import_expression(ast))
else {
continue;
};
track_dynamic_import_pattern(parser, import_call, pattern);
}
}
#[derive(Debug, Default)]
pub struct ImportsReferencesState {
inner: FxHashMap<Span, ImportReferences>,
exported_bindings: Vec<SymbolBinding>,
}
impl ImportsReferencesState {
pub(crate) fn record_exported_binding(&mut self, binding: SymbolBinding) {
self.exported_bindings.push(binding);
}
pub fn add_import(&mut self, import: Span) {
self.inner.entry(import).or_default();
}
fn get_import(&self, import: &Span) -> Option<&ImportReferences> {
self.inner.get(import)
}
fn get_import_mut(&mut self, import: &Span) -> Option<&mut ImportReferences> {
self.inner.get_mut(import)
}
fn get_import_mut_expect(&mut self, import: &Span) -> &mut ImportReferences {
self.get_import_mut(import).expect("should get import")
}
fn take_all_import_references(
&mut self,
) -> impl Iterator<Item = (ImportDependencyLocator, ImportReferences)> + use<> {
let inner = std::mem::take(&mut self.inner);
inner.into_values().filter_map(|mut value| {
let locator = value.dep_locator.take()?;
Some((locator, value))
})
}
}
#[derive(Debug, Default)]
struct ImportReferences {
dep_locator: Option<ImportDependencyLocator>,
bindings: Vec<(SymbolBinding, Vec<Atom>)>,
references: Vec<ReferencedSpecifier>,
}
impl ImportReferences {
pub fn add_reference(&mut self, reference: Vec<Atom>) {
self.references.push(ReferencedSpecifier::new(reference));
}
pub fn add_call_reference(&mut self, reference: Vec<Atom>, namespace_object_as_context: bool) {
self.references.push(ReferencedSpecifier::new_call(
reference,
namespace_object_as_context,
));
}
}
#[derive(Default)]
struct ReferencedBindingPaths<'a> {
edges: FxHashMap<(usize, &'a Atom), usize>,
referenced: Vec<bool>,
}
impl<'a> ReferencedBindingPaths<'a> {
fn add_binding(&mut self, path: &'a [Atom]) {
if !path.is_empty() && self.referenced.is_empty() {
self.referenced.push(false); }
let mut node = 0;
for property in path {
let next = self.referenced.len();
node = *self.edges.entry((node, property)).or_insert_with(|| {
self.referenced.push(false);
next
});
}
}
fn add_reference(&mut self, path: &[Atom]) {
let mut node = 0;
for property in path {
let Some(&next) = self.edges.get(&(node, property)) else {
break;
};
self.referenced[next] = true;
node = next;
}
}
fn is_referenced(&self, path: &[Atom]) -> bool {
let mut node = 0;
for property in path {
let Some(&next) = self.edges.get(&(node, property)) else {
return false;
};
node = next;
}
self.referenced.get(node).copied().unwrap_or_default()
}
}
#[derive(Debug, PartialEq, Eq, Hash)]
struct ImportDependencyLocator {
block_idx: Option<usize>,
dep_idx: usize,
dep_type: DependencyType,
}
#[derive(Debug, Clone)]
struct ImportTagData {
import_span: Span,
export_path: Vec<Atom>,
}
fn add_import_member_reference(
parser: &mut JavascriptParser,
data: &ImportTagData,
members: &[Atom],
members_optionals: &[bool],
is_call: bool,
) {
let ids = get_non_optional_part(members, members_optionals);
let names = data.export_path.iter().chain(ids).cloned().collect();
let namespace_object_as_context = parser
.javascript_options
.strict_this_context_on_imports
.unwrap_or(false)
&& !members.is_empty();
let references = parser
.dynamic_import_references
.get_import_mut_expect(&data.import_span);
if is_call && !members.is_empty() {
references.add_call_reference(names, namespace_object_as_context);
} else {
references.add_reference(names);
}
}
pub struct ImportParserPlugin;
#[rspack_macros::implemented_javascript_parser_hooks]
impl<'p, 'a> JavascriptParserPlugin<'p, 'a> for ImportParserPlugin {
fn can_collect_destructuring_assignment_properties(
&self,
parser: &mut JavascriptParser<'p>,
expr: Expr,
) -> Option<bool> {
let ast = parser.ast.ast;
if expr.as_import_expression(ast).is_some() {
return Some(true);
}
if let Some(ident) = expr.as_identifier_reference(ast)
&& let Some(name_info) = parser.get_name_info_from_variable(ast.get_utf8(ident.name(ast)))
&& let Some(info) = name_info.info
&& let Some(name) = info.name.cloned()
&& parser
.get_tag_data::<ImportTagData>(&name, DYNAMIC_IMPORT_TAG)
.is_some()
{
return Some(true);
}
None
}
fn pre_declarator(
&self,
parser: &mut JavascriptParser<'p>,
declarator: VariableDeclarator,
declaration: VariableDeclaration,
) -> Option<bool> {
let ast = parser.ast.ast;
if declaration.kind(ast) != VariableKind::Var {
if let Some(init) = declarator.init(ast)
&& let Some(expr) = init.as_await_expression(ast)
&& let Some(import) = expr.argument(ast).as_import_expression(ast)
{
track_dynamic_import_pattern(parser, import, declarator.id(ast));
}
track_dynamic_imports_in_promise_all(parser, declarator);
}
None
}
fn identifier(
&self,
parser: &mut JavascriptParser<'p>,
span: Span,
for_name: &str,
) -> Option<bool> {
if for_name != DYNAMIC_IMPORT_TAG {
return None;
}
let tag_info = parser
.definitions_db
.expect_get_tag_info(parser.current_tag_info?);
let data = ImportTagData::downcast(tag_info.data.clone()?);
if let Some(keys) = parser.destructuring_assignment_properties.get(&span) {
for ids in collect_destructuring_references(keys) {
parser
.dynamic_import_references
.get_import_mut_expect(&data.import_span)
.add_reference(data.export_path.iter().cloned().chain(ids).collect());
}
} else {
parser
.dynamic_import_references
.get_import_mut_expect(&data.import_span)
.add_reference(data.export_path);
}
Some(true)
}
fn member_chain(
&self,
parser: &mut JavascriptParser<'p>,
_expr: HookMemberExpression,
for_name: &str,
members: &[Atom],
members_optionals: &[bool],
_member_ranges: &[Span],
) -> Option<bool> {
if for_name != DYNAMIC_IMPORT_TAG {
return None;
}
let tag_info = parser
.definitions_db
.expect_get_tag_info(parser.current_tag_info?);
let data = ImportTagData::downcast(tag_info.data.clone()?);
let is_call = parser.in_tagged_template_tag;
add_import_member_reference(parser, &data, members, members_optionals, is_call);
Some(true)
}
fn call_member_chain(
&self,
parser: &mut JavascriptParser<'p>,
expr: CallExpression,
for_name: &str,
members: &[Atom],
members_optionals: &[bool],
_member_ranges: &[Span],
) -> Option<bool> {
if for_name != DYNAMIC_IMPORT_TAG {
return None;
}
let tag_info = parser
.definitions_db
.expect_get_tag_info(parser.current_tag_info?);
let data = ImportTagData::downcast(tag_info.data.clone()?);
add_import_member_reference(parser, &data, members, members_optionals, true);
let ast = parser.ast.ast;
parser.walk_arguments(ast.nodes(expr.arguments(ast)));
Some(true)
}
fn import_call(
&self,
parser: &mut JavascriptParser<'p>,
node: ImportExpression,
import_then: Option<CallExpression>,
referenced_in_members: Option<(&[Atom], bool)>,
) -> Option<bool> {
if parser.terminated.is_some() && !parser.is_top_level_scope() {
return Some(true);
}
let ast = parser.ast.ast;
let dyn_imported = node.source(ast);
let import_call_span = node.span(ast);
let dyn_imported_span = dyn_imported.span(ast);
let dynamic_import_mode = parser.javascript_options.dynamic_import_mode;
let dynamic_import_preload = parser
.javascript_options
.dynamic_import_preload
.expect("should have dynamic_import_preload")
.get_order();
let dynamic_import_prefetch = parser
.javascript_options
.dynamic_import_prefetch
.expect("should have dynamic_import_prefetch")
.get_order();
let dynamic_import_fetch_priority = parser.javascript_options.dynamic_import_fetch_priority;
let magic_comment_options =
try_extract_magic_comment(parser, import_call_span, dyn_imported_span);
if magic_comment_options.get_ignore().unwrap_or_default() {
return None;
}
let mode = magic_comment_options.get_mode().map_or(
dynamic_import_mode.expect("should have dynamic_import_mode"),
|x| DynamicImportMode::from(x.as_str()),
);
let chunk_name = magic_comment_options.get_chunk_name().map(|x| x.to_owned());
let chunk_prefetch = magic_comment_options
.get_prefetch()
.and_then(|x| parse_order_string(x.as_ref()))
.or(dynamic_import_prefetch);
let chunk_preload = magic_comment_options
.get_preload()
.and_then(|x| parse_order_string(x.as_ref()))
.or(dynamic_import_preload);
let fetch_priority = magic_comment_options
.get_fetch_priority()
.map(|x| DynamicImportFetchPriority::from(x.as_str()))
.or(dynamic_import_fetch_priority);
let include = magic_comment_options.get_include();
let exclude = magic_comment_options.get_exclude();
let mut exports = magic_comment_options.get_exports().map(|x| {
x.iter()
.map(|name| ReferencedSpecifier::new(vec![Atom::from(name.as_str())]))
.collect::<Vec<_>>()
});
let has_exports_magic_comment = exports.is_some();
let referenced_in_destructuring = parser
.destructuring_assignment_properties
.get(&import_call_span);
let referenced_in_variable = parser
.dynamic_import_references
.get_import(&import_call_span);
let referenced_fulfilled_ns_obj = import_then
.and_then(|import_then| get_fulfilled_callback_namespace_obj(parser.ast.ast, import_then));
if let Some(keys) = referenced_in_destructuring {
exports = Some(
collect_destructuring_references(keys)
.into_iter()
.map(ReferencedSpecifier::new)
.collect(),
);
}
if let Some((referenced_in_members, is_call)) = referenced_in_members {
let referenced = if is_call {
ReferencedSpecifier::new_call(
referenced_in_members.to_vec(),
parser
.javascript_options
.strict_this_context_on_imports
.unwrap_or(false)
&& !referenced_in_members.is_empty(),
)
} else {
ReferencedSpecifier::new(referenced_in_members.to_vec())
};
exports = Some(vec![referenced]);
}
let is_statical = referenced_in_destructuring.is_some()
|| referenced_in_variable.is_some()
|| referenced_fulfilled_ns_obj.is_some()
|| referenced_in_members.is_some();
if is_statical && has_exports_magic_comment {
let mut error: Error = create_traceable_error(
"Useless magic comments".into(),
"You don't need `webpackExports` if the usage of dynamic import is statically analyse-able. You can safely remove the `webpackExports` magic comment.".into(),
parser.source.to_string(),
import_call_span.into(),
);
error.severity = Severity::Warning;
error.hide_stack = Some(true);
parser.add_warning(error.into());
}
let phase = get_import_phase(parser, node.phase(parser.ast.ast));
if phase.is_defer() && !parser.compiler_options.experiments.defer_import {
parser.add_error(rspack_error::error!("deferImport is still an experimental feature. To continue using it, please enable 'experiments.deferImport'.").into());
}
if phase.is_source() && !parser.compiler_options.experiments.source_import {
parser.add_error(rspack_error::error!("sourceImport is still an experimental feature. To continue using it, please enable 'experiments.sourceImport'.").into());
}
let attributes = get_attributes_from_import_expr(parser.ast.ast, node);
let param = parser.evaluate_expression(dyn_imported);
let dep_locator = if param.is_string() {
if matches!(mode, DynamicImportMode::Eager) {
let mut dep = ImportEagerDependency::new(
param.string().into(),
import_call_span.into(),
attributes,
phase,
);
if let Some(exports) = exports {
dep.set_referenced_specifiers(exports, !is_statical && has_exports_magic_comment);
}
let dep_id = *dep.id();
let dep_idx = parser.next_dependency_idx();
parser.add_dependency(BoxDependency::new(dep));
InnerGraphParserPlugin::on_usage(
parser,
InnerGraphUsageOperation::ImportDependency(dep_id),
);
ImportDependencyLocator {
block_idx: None,
dep_idx,
dep_type: DependencyType::DynamicImportEager,
}
} else if matches!(mode, DynamicImportMode::Weak) {
let mut dep = ImportWeakDependency::new(
param.string().into(),
import_call_span.into(),
attributes,
phase,
parser.in_try,
);
if let Some(exports) = exports {
dep.set_referenced_specifiers(exports, !is_statical && has_exports_magic_comment);
}
let dep_idx = parser.next_dependency_idx();
parser.add_dependency(BoxDependency::new(dep));
ImportDependencyLocator {
block_idx: None,
dep_idx,
dep_type: DependencyType::DynamicImportWeak,
}
} else {
let mut dep = ImportDependency::new(
param.string().into(),
import_call_span.into(),
attributes,
phase,
parser.in_try,
{
get_swc_next_comments(
parser.ast.comments,
dyn_imported_span.start,
dyn_imported_span.end,
)
},
);
if let Some(export) = exports {
dep.set_referenced_specifiers(export, !is_statical && has_exports_magic_comment);
}
let dep_id = dep.id;
let range = DependencyRange::from(import_call_span);
let loc = parser.to_dependency_location(range);
let mut block = AsyncDependenciesBlock::new(
*parser.module_identifier,
loc,
None,
vec![BoxDependency::new(dep)],
Some(param.string().to_owned()),
);
block.set_group_options(GroupOptions::ChunkGroup(ChunkGroupOptions::new(
chunk_name,
chunk_preload,
chunk_prefetch,
fetch_priority,
)));
let block_idx = parser.next_block_idx();
parser.add_block(Box::new(block));
InnerGraphParserPlugin::on_usage(
parser,
InnerGraphUsageOperation::ImportDependency(dep_id),
);
ImportDependencyLocator {
block_idx: Some(block_idx),
dep_idx: 0,
dep_type: DependencyType::DynamicImport,
}
}
} else {
if matches!(parser.javascript_options.import_dynamic, Some(false)) {
return None;
}
let result = create_context_dependency(¶m, parser);
let request = result.request();
let ContextModuleScanResult {
reg,
replaces,
critical,
..
} = result;
let reg_exp = context_reg_exp(®, "", Some(dyn_imported_span.into()), parser);
let mut dep = ImportContextDependency::new(
ContextOptions {
mode: mode.into(),
recursive: true,
pattern: reg_exp.into(),
include,
exclude,
category: DependencyCategory::Esm,
request,
context: get_context(parser.resource_data).to_string(),
compiler_context: parser.compiler_options.context.clone(),
namespace_object: if parser.build_meta.strict_esm_module() {
ContextNameSpaceObject::Strict
} else {
ContextNameSpaceObject::Bool(true)
},
group_options: Some(GroupOptions::ChunkGroup(ChunkGroupOptions::new(
chunk_name,
chunk_preload,
chunk_prefetch,
fetch_priority,
))),
replaces,
start: import_call_span.real_lo(),
end: import_call_span.real_hi(),
referenced_specifiers: None,
glob_import: None,
glob_exhaustive: false,
glob_case_sensitive: true,
attributes,
phase: Some(phase),
},
import_call_span.into(),
dyn_imported_span.into(),
parser.in_try,
);
if let Some(export) = exports {
dep.set_referenced_specifiers(export, !is_statical && has_exports_magic_comment);
}
dep.set_critical(critical);
let dep_idx = parser.next_dependency_idx();
parser.add_dependency(BoxDependency::new(dep));
ImportDependencyLocator {
block_idx: None,
dep_idx,
dep_type: DependencyType::ImportContext,
}
};
if let Some(import_then) = import_then {
if let Some(ns_obj) = referenced_fulfilled_ns_obj {
let ast = parser.ast.ast;
let arguments = import_then.arguments(ast);
let fulfilled_callback = ast
.first(arguments)
.and_then(|argument| argument.as_expr(ast))
.expect("fulfilled callback should be an expression");
walk_import_then_fulfilled_callback(parser, node, fulfilled_callback, ns_obj);
parser.walk_arguments(ast.nodes(arguments).skip(1));
} else {
let ast = parser.ast.ast;
parser.walk_arguments(ast.nodes(import_then.arguments(ast)));
}
}
if let Some(import_references) = parser
.dynamic_import_references
.get_import_mut(&import_call_span)
{
import_references.dep_locator = Some(dep_locator);
}
Some(true)
}
fn finish(&self, parser: &mut JavascriptParser<'p>) -> Option<bool> {
if parser.dynamic_import_references.inner.is_empty() {
return None;
}
let exported_bindings: FxHashSet<SymbolBinding> =
std::mem::take(&mut parser.dynamic_import_references.exported_bindings)
.into_iter()
.collect();
for (locator, import) in parser
.dynamic_import_references
.take_all_import_references()
{
let ImportReferences {
bindings,
mut references,
..
} = import;
let mut referenced_paths = ReferencedBindingPaths::default();
for (_, path) in &bindings {
referenced_paths.add_binding(path);
}
if !referenced_paths.edges.is_empty() {
for reference in &references {
referenced_paths.add_reference(&reference.names);
}
}
let retain_bindings = bindings
.iter()
.map(|(binding, path)| {
let retain = parser.build_info.has_direct_eval
|| exported_bindings.contains(binding)
|| (!path.is_empty() && !referenced_paths.is_referenced(path));
if retain {
referenced_paths.add_reference(path);
}
retain
})
.collect::<Vec<_>>();
drop(referenced_paths);
for ((_, path), retain) in bindings.into_iter().zip(retain_bindings) {
if retain {
references.push(ReferencedSpecifier::new(path));
}
}
let dep = if let Some(block_idx) = locator.block_idx
&& let Some(block) = parser.get_block_mut(block_idx)
{
block.get_dependency_mut(locator.dep_idx)
} else {
parser.get_dependency_mut(locator.dep_idx)
};
let Some(dep) = dep else {
continue;
};
match locator.dep_type {
DependencyType::DynamicImport => {
let dep = dep
.downcast_mut::<ImportDependency>()
.expect("Failed to downcast to ImportDependency");
dep.set_referenced_specifiers(references, false);
}
DependencyType::DynamicImportEager => {
let dep = dep
.downcast_mut::<ImportEagerDependency>()
.expect("Failed to downcast to ImportEagerDependency");
dep.set_referenced_specifiers(references, false);
}
DependencyType::DynamicImportWeak => {
let dep = dep
.downcast_mut::<ImportWeakDependency>()
.expect("Failed to downcast to ImportWeakDependency");
dep.set_referenced_specifiers(references, false);
}
DependencyType::ImportContext => {
let dep = dep
.downcast_mut::<ImportContextDependency>()
.expect("Failed to downcast to ImportContextDependency");
dep.set_referenced_specifiers(references, false);
}
_ => unreachable!(),
};
}
None
}
}
fn get_attributes_from_import_expr(
ast: &swc_next_ecma_ast::Ast<'_>,
node: ImportExpression,
) -> Option<ImportAttributes> {
let options = node.options(ast)?.as_object_expression(ast)?;
get_value_by_obj_prop(ast, options, "with")
.and_then(|expr| expr.as_object_expression(ast))
.map(|object| get_attributes(ast, object))
}
fn get_fulfilled_callback_namespace_obj(
ast: &swc_next_ecma_ast::Ast<'_>,
import_then: CallExpression,
) -> Option<BindingPattern> {
let fulfilled_callback = ast.first(import_then.arguments(ast))?.as_expr(ast)?;
let params = match ast.expr_data(fulfilled_callback) {
ExprData::ArrowFunctionExpression(function) => function.params(ast),
ExprData::Function(function) => {
if function_uses_arguments(ast, function) {
return None;
}
function.params(ast)
}
_ => return None,
};
let ns_obj = ast
.first(params.items(ast))
.and_then(|item| item.as_formal_parameter(ast))
.filter(|parameter| parameter.initializer(ast).is_none())
.map(|parameter| formal_parameter_pattern(ast, parameter.pattern(ast)))?;
if ns_obj.as_binding_identifier(ast).is_some() || ns_obj.as_object_pattern(ast).is_some() {
return Some(ns_obj);
}
None
}
fn function_uses_arguments(ast: &Ast<'_>, function: Function) -> bool {
struct ArgumentsVisitor<'a, 'b> {
ast: &'b Ast<'a>,
found: bool,
}
impl<'a> Visit<'a> for ArgumentsVisitor<'a, '_> {
fn ast(&self) -> &Ast<'a> {
self.ast
}
fn visit_function(&mut self, _function: Function) {}
fn visit_identifier_reference(&mut self, identifier: IdentifierReference) {
if self.ast.get_utf8(identifier.name(self.ast)) == "arguments" {
self.found = true;
}
}
}
let mut visitor = ArgumentsVisitor { ast, found: false };
function.visit_children_with(&mut visitor);
visitor.found
}
fn walk_import_then_fulfilled_callback(
parser: &mut JavascriptParser,
import_call: ImportExpression,
fulfilled_callback: Expr,
namespace_obj_arg: BindingPattern,
) {
let ast = parser.ast.ast;
let (params, function_id, is_function) = match ast.expr_data(fulfilled_callback) {
ExprData::Function(function) => (function.params(ast), function.id(ast), true),
ExprData::ArrowFunctionExpression(function) => (function.params(ast), None, false),
_ => unreachable!(),
};
let scope_params = formal_parameter_patterns(ast, params)
.map(PatRef::Borrowed)
.chain(
function_id
.map(BindingPattern::BindingIdentifier)
.map(PatRef::Owned),
);
let was_top_level_scope = parser.top_level_scope;
parser.top_level_scope = if !matches!(was_top_level_scope, TopLevelScope::False) && !is_function {
TopLevelScope::ArrowFunction
} else {
TopLevelScope::False
};
parser.in_semantic_scope(fulfilled_callback.node_id(), |parser| {
parser.in_function_scope(is_function, scope_params, |parser| {
let ast = parser.ast.ast;
if let Some(ns_obj) = namespace_obj_arg.as_binding_identifier(ast) {
tag_dynamic_import_referenced(parser, import_call, ns_obj);
} else if let Some(ns_obj) = namespace_obj_arg.as_object_pattern(ast) {
track_destructuring_import_bindings(parser, import_call, ns_obj);
} else {
unreachable!()
}
for (pattern, initializer) in formal_parameter_patterns_with_defaults(parser.ast.ast, params)
{
if let Some(initializer) = initializer {
parser.walk_expression(initializer);
}
parser.walk_pattern(pattern);
}
parser.walk_function_expression_body(fulfilled_callback);
});
});
parser.top_level_scope = was_top_level_scope;
}