feat: tree shaking nested exports for destructuring assignment (#11781)

Author: ahabhgk

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

@@ -16,7 +16,6 @@ use rspack_core::{
 };
 use rspack_error::Diagnostic;
 use rspack_util::json_stringify;
-use rustc_hash::FxHashSet as HashSet;
 use swc_core::ecma::atoms::Atom;
 
 use super::{
@@ -25,7 +24,7 @@ use super::{
 };
 use crate::{
   connection_active_inline_value_for_esm_import_specifier, connection_active_used_by_exports,
-  is_export_inlined, visitors::DestructuringAssignmentProperty,
+  is_export_inlined, visitors::DestructuringAssignmentProperties,
 };
 
 #[cacheable]
@@ -45,8 +44,8 @@ pub struct ESMImportSpecifierDependency {
   call: bool,
   direct_import: bool,
   used_by_exports: Option<UsedByExports>,
-  #[cacheable(with=AsOption<AsVec<AsCacheable>>)]
-  referenced_properties_in_destructuring: Option<HashSet<DestructuringAssignmentProperty>>,
+  #[cacheable(with=AsOption<AsCacheable>)]
+  referenced_properties_in_destructuring: Option<DestructuringAssignmentProperties>,
   resource_identifier: String,
   export_presence_mode: ExportPresenceMode,
   attributes: Option<ImportAttributes>,
@@ -69,7 +68,7 @@ impl ESMImportSpecifierDependency {
     call: bool,
     direct_import: bool,
     export_presence_mode: ExportPresenceMode,
-    referenced_properties_in_destructuring: Option<HashSet<DestructuringAssignmentProperty>>,
+    referenced_properties_in_destructuring: Option<DestructuringAssignmentProperties>,
     attributes: Option<ImportAttributes>,
     source_map: Option<SharedSourceMap>,
   ) -> Self {
@@ -110,17 +109,19 @@ impl ESMImportSpecifierDependency {
     ids: Option<&[Atom]>,
   ) -> Vec<ExtendedReferencedExport> {
     if let Some(referenced_properties) = &self.referenced_properties_in_destructuring {
-      referenced_properties
-        .iter()
-        .map(|prop| {
-          if let Some(v) = ids {
-            let mut value = v.to_vec();
-            value.push(prop.id.clone());
-            value
-          } else {
-            vec![prop.id.clone()]
-          }
-        })
+      let mut refs = Vec::new();
+      referenced_properties.traverse_on_left(&mut |stack| {
+        let ids_in_destructuring = stack.iter().map(|p| p.id.clone());
+        if let Some(ids) = ids {
+          let mut ids = ids.to_vec();
+          ids.extend(ids_in_destructuring);
+          refs.push(ids);
+        } else {
+          refs.push(ids_in_destructuring.collect::<Vec<_>>());
+        }
+      });
+      refs
+        .into_iter()
         // Do not inline if there are any places where used as destructuring
         .map(|name| ExtendedReferencedExport::Export(ReferencedExport::new(name, true, false)))
         .collect::<Vec<_>>()
@@ -565,9 +566,10 @@ impl DependencyTemplate for ESMImportSpecifierDependencyTemplate {
         }
       }
 
-      for prop in referenced_properties {
+      referenced_properties.traverse_on_enter(&mut |stack| {
+        let prop = stack.last().expect("should have last");
         let mut concated_ids = prefixed_ids.clone();
-        concated_ids.push(prop.id.clone());
+        concated_ids.extend(stack.iter().map(|p| p.id.clone()));
         let Some(new_name) = ExportsInfoGetter::get_used_name(
           GetUsedNameParam::WithNames(&module_graph.get_prefetched_exports_info(
             &module.identifier(),
@@ -586,7 +588,7 @@ impl DependencyTemplate for ESMImportSpecifierDependencyTemplate {
         };
 
         if new_name == prop.id {
-          continue;
+          return;
         }
 
         let comment = to_normal_comment(prop.id.as_str());
@@ -597,7 +599,7 @@ impl DependencyTemplate for ESMImportSpecifierDependencyTemplate {
           key
         };
         source.replace(prop.range.start, prop.range.end, &content, None);
-      }
+      });
     }
   }
 }

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

@@ -3,10 +3,9 @@ use std::{borrow::Cow, sync::LazyLock};
 use itertools::Itertools as _;
 use regex::Regex;
 use rspack_core::{ConstDependency, RuntimeGlobals};
-use rustc_hash::FxHashSet;
 use serde_json::{Value, json};
 
-use crate::visitors::{DestructuringAssignmentProperty, JavascriptParser};
+use crate::visitors::{DestructuringAssignmentProperties, JavascriptParser};
 
 static WEBPACK_REQUIRE_FUNCTION_REGEXP: LazyLock<Regex> = LazyLock::new(|| {
   Regex::new("__webpack_require__\\s*(!?\\.)")
@@ -47,7 +46,7 @@ pub fn gen_const_dep(
 pub fn code_to_string<'a>(
   code: &'a Value,
   asi_safe: Option<bool>,
-  obj_keys: Option<&FxHashSet<DestructuringAssignmentProperty>>,
+  obj_keys: Option<&DestructuringAssignmentProperties>,
 ) -> Cow<'a, str> {
   fn wrap_ansi(code: Cow<str>, is_arr: bool, asi_safe: Option<bool>) -> Cow<str> {
     match asi_safe {

crates/rspack_plugin_javascript/src/parser_plugin/import_meta_plugin.rs

@@ -170,7 +170,7 @@ impl JavascriptParserPlugin for ImportMetaPlugin {
         parser.destructuring_assignment_properties.get(&span)
       {
         let mut content = vec![];
-        for prop in referenced_properties_in_destructuring {
+        for prop in referenced_properties_in_destructuring.iter() {
           if prop.id == "url" {
             content.push(format!(r#"url: "{}""#, self.import_meta_url(parser)))
           } else if prop.id == "webpack" {

crates/rspack_plugin_javascript/src/parser_plugin/import_parser_plugin.rs

@@ -1,6 +1,5 @@
 use std::borrow::Cow;
 
-use itertools::Itertools;
 use rspack_core::{
   AsyncDependenciesBlock, ChunkGroupOptions, ContextDependency, ContextNameSpaceObject,
   ContextOptions, DependencyCategory, DependencyRange, DependencyType, DynamicImportFetchPriority,
@@ -163,11 +162,15 @@ impl JavascriptParserPlugin for ImportParserPlugin {
       .destructuring_assignment_properties
       .get(&ident.span())
     {
-      for key in keys {
+      let mut refs = Vec::new();
+      keys.traverse_on_left(&mut |stack| {
+        refs.push(stack.iter().map(|p| p.id.clone()).collect());
+      });
+      for ids in refs {
         parser
           .dynamic_import_references
           .get_import_mut_expect(&data.import_span)
-          .add_reference(vec![key.id.clone()]);
+          .add_reference(ids);
       }
     } else {
       parser
@@ -291,20 +294,28 @@ impl JavascriptParserPlugin for ImportParserPlugin {
         .map(|name| vec![Atom::from(name.as_str())])
         .collect::<Vec<_>>()
     });
+    let has_webpack_exports_comment = exports.is_some();
 
     let referenced_in_destructuring = parser
       .destructuring_assignment_properties
-      .get(&import_call_span)
-      .cloned();
+      .get(&import_call_span);
     let referenced_in_member = 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(import_then));
+    if let Some(keys) = referenced_in_destructuring {
+      let mut refs = Vec::new();
+      keys.traverse_on_left(&mut |stack| {
+        refs.push(stack.iter().map(|p| p.id.clone()).collect());
+      });
+      exports = Some(refs);
+    }
+
     let is_statical = referenced_in_destructuring.is_some()
       || referenced_in_member.is_some()
       || referenced_fulfilled_ns_obj.is_some();
-    if is_statical && exports.is_some() {
+    if is_statical && has_webpack_exports_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(),
@@ -315,15 +326,6 @@ impl JavascriptParserPlugin for ImportParserPlugin {
       error.hide_stack = Some(true);
       parser.add_warning(error.into());
     }
-    if let Some(referenced_properties_in_destructuring) = referenced_in_destructuring {
-      exports = Some(
-        referenced_properties_in_destructuring
-          .iter()
-          .cloned()
-          .map(|x| vec![x.id])
-          .collect_vec(),
-      );
-    }
 
     let attributes = get_attributes_from_call_expr(node);
     let param = parser.evaluate_expression(dyn_imported.expr.as_ref());
@@ -562,15 +564,21 @@ fn walk_import_then_fulfilled_callback(
       if let Some(ns_obj) = namespace_obj_arg.as_ident() {
         tag_dynamic_import_referenced(parser, import_call, ns_obj.id.sym.clone());
       } else if let Some(ns_obj) = namespace_obj_arg.as_object() {
-        if let Some(keys) = parser.collect_destructuring_assignment_properties(ns_obj) {
+        if let Some(keys) =
+          parser.collect_destructuring_assignment_properties_from_object_pattern(ns_obj)
+        {
           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 {
-            import_references.add_reference(vec![key.id.clone()]);
+          let mut refs = Vec::new();
+          keys.traverse_on_left(&mut |stack| {
+            refs.push(stack.iter().map(|p| p.id.clone()).collect());
+          });
+          for ids in refs {
+            import_references.add_reference(ids);
           }
         }
       } else {

crates/rspack_plugin_javascript/src/visitors/dependency/mod.rs

@@ -17,9 +17,9 @@ use swc_core::common::{BytePos, Mark, SourceFile, SourceMap, comments::Comments}
 pub use self::{
   context_dependency_helper::{ContextModuleScanResult, create_context_dependency},
   parser::{
-    AllowedMemberTypes, CallExpressionInfo, CallHooksName, DestructuringAssignmentProperty,
-    ExportedVariableInfo, JavascriptParser, MemberExpressionInfo, RootName, TagInfoData,
-    TopLevelScope, estree::*,
+    AllowedMemberTypes, CallExpressionInfo, CallHooksName, DestructuringAssignmentProperties,
+    DestructuringAssignmentProperty, ExportedVariableInfo, JavascriptParser, MemberExpressionInfo,
+    RootName, TagInfoData, TopLevelScope, estree::*,
   },
   util::*,
 };

crates/rspack_plugin_javascript/src/visitors/dependency/parser/mod.rs

@@ -5,11 +5,20 @@ mod walk_block_pre;
 mod walk_module_pre;
 mod walk_pre;
 
-use std::{borrow::Cow, fmt::Display, rc::Rc, sync::Arc};
+use std::{
+  borrow::Cow,
+  fmt::Display,
+  hash::{Hash, Hasher},
+  rc::Rc,
+  sync::Arc,
+};
 
 use bitflags::bitflags;
 pub use call_hooks_name::CallHooksName;
-use rspack_cacheable::{cacheable, with::AsPreset};
+use rspack_cacheable::{
+  cacheable,
+  with::{AsCacheable, AsOption, AsPreset, AsVec},
+};
 use rspack_core::{
   AsyncDependenciesBlock, BoxDependency, BoxDependencyTemplate, BuildInfo, BuildMeta,
   CompilerOptions, DependencyRange, FactoryMeta, JavascriptParserCommonjsExportsOption,
@@ -113,15 +122,6 @@ pub struct ExpressionExpressionInfo {
   pub member_ranges: Vec<Span>,
 }
 
-#[cacheable]
-#[derive(Debug, Clone, Hash, Eq, PartialEq)]
-pub struct DestructuringAssignmentProperty {
-  pub range: DependencyRange,
-  #[cacheable(with=AsPreset)]
-  pub id: Atom,
-  pub shorthand: bool,
-}
-
 #[derive(Debug, Clone)]
 pub enum ExportedVariableInfo {
   Name(Atom),
@@ -211,17 +211,96 @@ impl From<Span> for StatementPath {
   }
 }
 
-#[derive(Debug, Default)]
+#[cacheable]
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+pub struct DestructuringAssignmentProperty {
+  pub range: DependencyRange,
+  #[cacheable(with=AsPreset)]
+  pub id: Atom,
+  #[cacheable(omit_bounds, with=AsOption<AsCacheable>)]
+  pub pattern: Option<DestructuringAssignmentProperties>,
+  pub shorthand: bool,
+}
+
+#[cacheable]
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct DestructuringAssignmentProperties {
-  inner: FxHashMap<Span, FxHashSet<DestructuringAssignmentProperty>>,
+  #[cacheable(with=AsVec<AsCacheable>)]
+  inner: FxHashSet<DestructuringAssignmentProperty>,
+}
+
+impl Hash for DestructuringAssignmentProperties {
+  fn hash<H: Hasher>(&self, state: &mut H) {
+    for prop in &self.inner {
+      prop.hash(state);
+    }
+  }
 }
 
 impl DestructuringAssignmentProperties {
-  pub fn add(&mut self, span: Span, props: FxHashSet<DestructuringAssignmentProperty>) {
+  pub fn new(properties: FxHashSet<DestructuringAssignmentProperty>) -> Self {
+    Self { inner: properties }
+  }
+
+  pub fn insert(&mut self, prop: DestructuringAssignmentProperty) -> bool {
+    self.inner.insert(prop)
+  }
+
+  pub fn extend(&mut self, other: Self) {
+    self.inner.extend(other.inner);
+  }
+
+  pub fn iter(&self) -> impl Iterator<Item = &DestructuringAssignmentProperty> {
+    self.inner.iter()
+  }
+
+  pub fn traverse_on_left<'a, F>(&'a self, on_left_node: &mut F)
+  where
+    F: FnMut(&mut Vec<&'a DestructuringAssignmentProperty>),
+  {
+    self.traverse_impl(on_left_node, &mut |_| {}, &mut Vec::new());
+  }
+
+  pub fn traverse_on_enter<'a, F>(&'a self, on_enter_node: &mut F)
+  where
+    F: FnMut(&mut Vec<&'a DestructuringAssignmentProperty>),
+  {
+    self.traverse_impl(&mut |_| {}, on_enter_node, &mut Vec::new());
+  }
+
+  fn traverse_impl<'a, L, E>(
+    &'a self,
+    on_left_node: &mut L,
+    on_enter_node: &mut E,
+    stack: &mut Vec<&'a DestructuringAssignmentProperty>,
+  ) where
+    L: FnMut(&mut Vec<&'a DestructuringAssignmentProperty>),
+    E: FnMut(&mut Vec<&'a DestructuringAssignmentProperty>),
+  {
+    for prop in &self.inner {
+      stack.push(prop);
+      on_enter_node(stack);
+      if let Some(pattern) = &prop.pattern {
+        pattern.traverse_impl(on_left_node, on_enter_node, stack);
+      } else {
+        on_left_node(stack);
+      }
+      stack.pop();
+    }
+  }
+}
+
+#[derive(Debug, Default)]
+pub struct DestructuringAssignmentPropertiesMap {
+  inner: FxHashMap<Span, DestructuringAssignmentProperties>,
+}
+
+impl DestructuringAssignmentPropertiesMap {
+  pub fn add(&mut self, span: Span, props: DestructuringAssignmentProperties) {
     self.inner.entry(span).or_default().extend(props)
   }
 
-  pub fn get(&self, span: &Span) -> Option<&FxHashSet<DestructuringAssignmentProperty>> {
+  pub fn get(&self, span: &Span) -> Option<&DestructuringAssignmentProperties> {
     self.inner.get(span)
   }
 }
@@ -264,7 +343,7 @@ pub struct JavascriptParser<'parser> {
   pub(crate) statement_path: Vec<StatementPath>,
   pub(crate) prev_statement: Option<StatementPath>,
   pub is_esm: bool,
-  pub(crate) destructuring_assignment_properties: DestructuringAssignmentProperties,
+  pub(crate) destructuring_assignment_properties: DestructuringAssignmentPropertiesMap,
   pub(crate) dynamic_import_references: ImportsReferencesState,
   pub(crate) worker_index: u32,
   pub(crate) parser_exports_state: Option<bool>,
@@ -1123,7 +1202,8 @@ impl<'parser> JavascriptParser<'parser> {
       can_collect.then_some(expr)
     };
     if let Some(destructuring) = destructuring
-      && let Some(keys) = self.collect_destructuring_assignment_properties(pattern)
+      && let Some(keys) =
+        self.collect_destructuring_assignment_properties_from_object_pattern(pattern)
     {
       self
         .destructuring_assignment_properties