feat: static analyze destructuring assignment dynamic import variable for tree shaking (#11731)

Author: ahabhgk

crates/rspack_plugin_javascript/src/dependency/context/import_context_dependency.rs

@@ -6,6 +6,7 @@ use rspack_core::{
   TemplateContext, TemplateReplaceSource,
 };
 use rspack_error::Diagnostic;
+use swc_core::atoms::Atom;
 
 use super::{
   context_dependency_template_as_require_call, create_resource_identifier_for_context_dependency,
@@ -15,7 +16,7 @@ use super::{
 #[derive(Debug, Clone)]
 pub struct ImportContextDependency {
   id: DependencyId,
-  pub options: ContextOptions,
+  options: ContextOptions,
   range: DependencyRange,
   value_range: DependencyRange,
   resource_identifier: String,
@@ -43,6 +44,10 @@ impl ImportContextDependency {
       factorize_info: Default::default(),
     }
   }
+
+  pub fn set_referenced_exports(&mut self, referenced_exports: Vec<Vec<Atom>>) {
+    self.options.referenced_exports = Some(referenced_exports);
+  }
 }
 
 #[cacheable_dyn]

crates/rspack_plugin_javascript/src/dependency/esm/import_dependency.rs

@@ -63,15 +63,15 @@ pub fn create_import_dependency_referenced_exports(
 pub struct ImportDependency {
   id: DependencyId,
   #[cacheable(with=AsPreset)]
-  pub request: Atom,
+  request: Atom,
   pub range: DependencyRange,
   #[cacheable(with=AsOption<AsVec<AsVec<AsPreset>>>)]
-  pub referenced_exports: Option<Vec<Vec<Atom>>>,
-  pub attributes: Option<ImportAttributes>,
+  referenced_exports: Option<Vec<Vec<Atom>>>,
+  attributes: Option<ImportAttributes>,
   pub comments: Vec<(bool, String)>,
-  pub resource_identifier: String,
-  pub factorize_info: FactorizeInfo,
-  pub optional: bool,
+  resource_identifier: String,
+  factorize_info: FactorizeInfo,
+  optional: bool,
 }
 
 impl ImportDependency {
@@ -97,6 +97,10 @@ impl ImportDependency {
       comments,
     }
   }
+
+  pub fn set_referenced_exports(&mut self, referenced_exports: Vec<Vec<Atom>>) {
+    self.referenced_exports = Some(referenced_exports);
+  }
 }
 
 #[cacheable_dyn]

crates/rspack_plugin_javascript/src/dependency/esm/import_eager_dependency.rs

@@ -23,7 +23,7 @@ pub struct ImportEagerDependency {
   request: Atom,
   range: DependencyRange,
   #[cacheable(with=AsOption<AsVec<AsVec<AsPreset>>>)]
-  pub referenced_exports: Option<Vec<Vec<Atom>>>,
+  referenced_exports: Option<Vec<Vec<Atom>>>,
   attributes: Option<ImportAttributes>,
   resource_identifier: String,
   factorize_info: FactorizeInfo,
@@ -48,6 +48,10 @@ impl ImportEagerDependency {
       factorize_info: Default::default(),
     }
   }
+
+  pub fn set_referenced_exports(&mut self, referenced_exports: Vec<Vec<Atom>>) {
+    self.referenced_exports = Some(referenced_exports);
+  }
 }
 
 #[cacheable_dyn]

crates/rspack_plugin_javascript/src/parser_plugin/define_plugin/utils.rs

@@ -44,11 +44,11 @@ pub fn gen_const_dep(
   }
 }
 
-pub fn code_to_string(
-  code: &Value,
+pub fn code_to_string<'a>(
+  code: &'a Value,
   asi_safe: Option<bool>,
-  obj_keys: Option<FxHashSet<DestructuringAssignmentProperty>>,
-) -> Cow<'_, str> {
+  obj_keys: Option<&FxHashSet<DestructuringAssignmentProperty>>,
+) -> Cow<'a, str> {
   fn wrap_ansi(code: Cow<str>, is_arr: bool, asi_safe: Option<bool>) -> Cow<str> {
     match asi_safe {
       Some(true) if is_arr => code,
@@ -75,10 +75,7 @@ pub fn code_to_string(
       let elements = obj
         .iter()
         .filter_map(|(key, value)| {
-          if obj_keys
-            .as_ref()
-            .is_none_or(|keys| keys.iter().any(|prop| prop.id.as_str() == key))
-          {
+          if obj_keys.is_none_or(|keys| keys.iter().any(|prop| prop.id.as_str() == key)) {
             Some(format!(
               "{}:{}",
               json!(key),

crates/rspack_plugin_javascript/src/parser_plugin/define_plugin/walk_data.rs

@@ -368,7 +368,7 @@ impl WalkData {
             let code = code_to_string(
               &record.object,
               Some(!parser.is_asi_position(span.lo)),
-              parser.destructuring_assignment_properties_for(&span),
+              parser.destructuring_assignment_properties.get(&span),
             );
             parser.add_presentational_dependency(Box::new(gen_const_dep(
               parser, code, for_name, start, end,

crates/rspack_plugin_javascript/src/parser_plugin/esm_import_dependency_parser_plugin.rs

@@ -178,8 +178,10 @@ impl JavascriptParserPlugin for ESMImportDependencyParserPlugin {
       .definitions_db
       .expect_get_tag_info(parser.current_tag_info?);
     let settings = ESMSpecifierData::downcast(tag_info.data.clone()?);
-    let referenced_properties_in_destructuring =
-      parser.destructuring_assignment_properties_for(&ident.span());
+    let referenced_properties_in_destructuring = parser
+      .destructuring_assignment_properties
+      .get(&ident.span())
+      .cloned();
     let dep = ESMImportSpecifierDependency::new(
       settings.source,
       settings.name,
@@ -309,8 +311,10 @@ impl JavascriptParserPlugin for ESMImportDependencyParserPlugin {
     };
     let mut ids = settings.ids;
     ids.extend(non_optional_members.iter().cloned());
-    let referenced_properties_in_destructuring =
-      parser.destructuring_assignment_properties_for(&member_expr.span());
+    let referenced_properties_in_destructuring = parser
+      .destructuring_assignment_properties
+      .get(&member_expr.span())
+      .cloned();
     let dep = ESMImportSpecifierDependency::new(
       settings.source,
       settings.name,

crates/rspack_plugin_javascript/src/parser_plugin/import_meta_plugin.rs

@@ -167,7 +167,7 @@ impl JavascriptParserPlugin for ImportMetaPlugin {
   ) -> Option<bool> {
     if root_name == expr_name::IMPORT_META {
       if let Some(referenced_properties_in_destructuring) =
-        parser.destructuring_assignment_properties_for(&span)
+        parser.destructuring_assignment_properties.get(&span)
       {
         let mut content = vec![];
         for prop in referenced_properties_in_destructuring {

crates/rspack_plugin_javascript/src/parser_plugin/import_parser_plugin.rs

@@ -22,9 +22,10 @@ use crate::{
   dependency::{ImportContextDependency, ImportDependency, ImportEagerDependency},
   utils::object_properties::{get_attributes, get_value_by_obj_prop},
   visitors::{
-    ContextModuleScanResult, JavascriptParser, Statement, TagInfoData, TopLevelScope,
-    VariableDeclaration, context_reg_exp, create_context_dependency, create_traceable_error,
-    get_non_optional_part, parse_order_string,
+    AllowedMemberTypes, ContextModuleScanResult, ExportedVariableInfo, JavascriptParser,
+    MemberExpressionInfo, Statement, TagInfoData, TopLevelScope, VariableDeclaration,
+    context_reg_exp, create_context_dependency, create_traceable_error, get_non_optional_part,
+    parse_order_string,
   },
   webpack_comment::try_extract_webpack_magic_comment,
 };
@@ -55,30 +56,26 @@ impl ImportsReferencesState {
     self.inner.insert(import, ImportReferences::default());
   }
 
-  pub fn add_import_reference(&mut self, import: Span, reference: Vec<Atom>) {
-    let references = self
-      .inner
-      .get_mut(&import)
-      .expect("should add_import before");
-    references.references.push(reference);
+  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_import_references(
+  fn take_all_import_references(
     &mut self,
   ) -> impl Iterator<Item = (ImportDependencyLocator, Vec<Vec<Atom>>)> + use<> {
     let inner = std::mem::take(&mut self.inner);
     inner
       .into_values()
       .filter_map(|value| value.dep_locator.map(|locator| (locator, value.references)))
   }
-
-  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)
-  }
 }
 
 #[derive(Debug, Default)]
@@ -87,6 +84,12 @@ struct ImportReferences {
   references: Vec<Vec<Atom>>,
 }
 
+impl ImportReferences {
+  pub fn add_reference(&mut self, reference: Vec<Atom>) {
+    self.references.push(reference);
+  }
+}
+
 #[derive(Debug, PartialEq, Eq, Hash)]
 struct ImportDependencyLocator {
   block_idx: Option<usize>,
@@ -104,14 +107,24 @@ pub struct ImportParserPlugin;
 impl JavascriptParserPlugin for ImportParserPlugin {
   fn can_collect_destructuring_assignment_properties(
     &self,
-    _parser: &mut JavascriptParser,
+    parser: &mut JavascriptParser,
     expr: &Expr,
   ) -> Option<bool> {
     if let Some(call) = expr.as_call()
       && call.callee.is_import()
     {
       return Some(true);
     }
+    if let MemberExpressionInfo::Expression(info) =
+      parser.get_member_expression_info_from_expr(expr, AllowedMemberTypes::Expression)?
+      && let ExportedVariableInfo::VariableInfo(id) = &info.root_info
+      && let Some(name) = &parser.definitions_db.expect_get_variable(*id).name
+      && parser
+        .get_tag_data(&name.clone(), DYNAMIC_IMPORT_TAG)
+        .is_some()
+    {
+      return Some(true);
+    }
     None
   }
 
@@ -135,7 +148,7 @@ impl JavascriptParserPlugin for ImportParserPlugin {
   fn identifier(
     &self,
     parser: &mut JavascriptParser,
-    _ident: &Ident,
+    ident: &Ident,
     for_name: &str,
   ) -> Option<bool> {
     if for_name != DYNAMIC_IMPORT_TAG {
@@ -145,9 +158,22 @@ impl JavascriptParserPlugin for ImportParserPlugin {
       .definitions_db
       .expect_get_tag_info(parser.current_tag_info?);
     let data = ImportTagData::downcast(tag_info.data.clone()?);
-    parser
-      .dynamic_import_references
-      .add_import_reference(data.import_span, vec![]);
+    if let Some(keys) = parser
+      .destructuring_assignment_properties
+      .get(&ident.span())
+    {
+      for key in keys {
+        parser
+          .dynamic_import_references
+          .get_import_mut_expect(&data.import_span)
+          .add_reference(vec![key.id.clone()]);
+      }
+    } else {
+      parser
+        .dynamic_import_references
+        .get_import_mut_expect(&data.import_span)
+        .add_reference(vec![]);
+    }
     Some(true)
   }
 
@@ -170,7 +196,8 @@ impl JavascriptParserPlugin for ImportParserPlugin {
     let ids = get_non_optional_part(members, members_optionals);
     parser
       .dynamic_import_references
-      .add_import_reference(data.import_span, ids.to_vec());
+      .get_import_mut_expect(&data.import_span)
+      .add_reference(ids.to_vec());
     Some(true)
   }
 
@@ -198,7 +225,8 @@ impl JavascriptParserPlugin for ImportParserPlugin {
     }
     parser
       .dynamic_import_references
-      .add_import_reference(data.import_span, ids.to_vec());
+      .get_import_mut_expect(&data.import_span)
+      .add_reference(ids.to_vec());
     parser.walk_expr_or_spread(&expr.args);
     Some(true)
   }
@@ -263,8 +291,10 @@ impl JavascriptParserPlugin for ImportParserPlugin {
         .collect::<Vec<_>>()
     });
 
-    let referenced_in_destructuring =
-      parser.destructuring_assignment_properties_for(&import_call_span);
+    let referenced_in_destructuring = parser
+      .destructuring_assignment_properties
+      .get(&import_call_span)
+      .cloned();
     let referenced_in_member = parser
       .dynamic_import_references
       .get_import(&import_call_span);
@@ -421,7 +451,10 @@ impl JavascriptParserPlugin for ImportParserPlugin {
   }
 
   fn finish(&self, parser: &mut JavascriptParser) -> Option<bool> {
-    for (locator, references) in parser.dynamic_import_references.take_import_references() {
+    for (locator, references) in parser
+      .dynamic_import_references
+      .take_all_import_references()
+    {
       let dep = if let Some(block_idx) = locator.block_idx
         && let Some(block) = parser.get_block_mut(block_idx)
       {
@@ -437,19 +470,19 @@ impl JavascriptParserPlugin for ImportParserPlugin {
           let dep = dep
             .downcast_mut::<ImportDependency>()
             .expect("Failed to downcast to ImportDependency");
-          dep.referenced_exports = Some(references);
+          dep.set_referenced_exports(references);
         }
         DependencyType::DynamicImportEager => {
           let dep = dep
             .downcast_mut::<ImportEagerDependency>()
             .expect("Failed to downcast to ImportEagerDependency");
-          dep.referenced_exports = Some(references);
+          dep.set_referenced_exports(references);
         }
         DependencyType::ImportContext => {
           let dep = dep
             .downcast_mut::<ImportContextDependency>()
             .expect("Failed to downcast to ImportContextDependency");
-          dep.options.referenced_exports = Some(references);
+          dep.set_referenced_exports(references);
         }
         _ => unreachable!(),
       };
@@ -530,10 +563,11 @@ fn walk_import_then_fulfilled_callback(
           parser
             .dynamic_import_references
             .add_import(import_call.span());
+          let import_references = parser
+            .dynamic_import_references
+            .get_import_mut_expect(&import_call.span());
           for key in keys {
-            parser
-              .dynamic_import_references
-              .add_import_reference(import_call.span(), vec![key.id.clone()]);
+            import_references.add_reference(vec![key.id.clone()]);
           }
         }
       } else {