refactor(core): improve referenced export data struct (#14796)

Author: SyMind

crates/rspack_core/src/artifacts/exports_info_artifact.rs

@@ -25,6 +25,14 @@ impl ArtifactExt for ExportsInfoArtifact {
 }
 
 impl ExportsInfoArtifact {
+  pub fn len(&self) -> usize {
+    self.exports_info_map.len()
+  }
+
+  pub fn is_empty(&self) -> bool {
+    self.exports_info_map.is_empty()
+  }
+
   pub fn new_exports_info(&mut self, module_identifier: ModuleIdentifier) {
     let info = ExportsInfoData::default();
     let id = info.id();

crates/rspack_core/src/compilation/mod.rs

@@ -79,13 +79,13 @@ use crate::{
   CompilationLogger, CompilationLogging, CompilerOptions, CompilerPlatform, ConcatenationScope,
   DependenciesDiagnosticsArtifact, DependencyId, DependencyTemplate, DependencyTemplateType,
   DependencyType, Entry, EntryData, EntryOptions, EntryRuntime, Entrypoint, ExecuteModuleId,
-  ExportsInfoArtifact, ExtendedReferencedExport, Filename, ImportPhase, ImportVarMap,
-  ImportedByDeferModulesArtifact, MemoryGCStorage, ModuleFactory, ModuleGraph,
-  ModuleGraphCacheArtifact, ModuleIdentifier, ModuleIdsArtifact, ModuleStaticCache, PathData,
-  ProcessRuntimeRequirementsCacheArtifact, ResolverFactory, RuntimeGlobals, RuntimeKeyMap,
-  RuntimeMode, RuntimeModule, RuntimeProxyMetadataArtifact, RuntimeSpec, RuntimeSpecMap,
-  RuntimeTemplate, SharedPluginDriver, SideEffectsOptimizeArtifact, SideEffectsStateArtifact,
-  SourceType, Stats, StatsContext, StealCell, ValueCacheVersions,
+  ExportsInfoArtifact, Filename, ImportPhase, ImportVarMap, ImportedByDeferModulesArtifact,
+  MemoryGCStorage, ModuleFactory, ModuleGraph, ModuleGraphCacheArtifact, ModuleIdentifier,
+  ModuleIdsArtifact, ModuleStaticCache, PathData, ProcessRuntimeRequirementsCacheArtifact,
+  ReferencedExport, ResolverFactory, RuntimeGlobals, RuntimeKeyMap, RuntimeMode, RuntimeModule,
+  RuntimeProxyMetadataArtifact, RuntimeSpec, RuntimeSpecMap, RuntimeTemplate, SharedPluginDriver,
+  SideEffectsOptimizeArtifact, SideEffectsStateArtifact, SourceType, Stats, StatsContext,
+  StealCell, ValueCacheVersions,
   cache::persistent::occasion::{
     devtool::SourceMapDevToolPluginCacheArtifact, minimize::MinimizePersistentCacheArtifact,
   },
@@ -110,7 +110,7 @@ define_hook!(CompilationSeal: Series(compilation: &Compilation, diagnostics: &mu
 define_hook!(CompilationDependencyReferencedExports: Sync(
   compilation: &Compilation,
   dependency: &DependencyId,
-  referenced_exports: &Option<Vec<ExtendedReferencedExport>>,
+  referenced_exports: &Option<Vec<ReferencedExport>>,
   runtime: Option<&RuntimeSpec>,
   module_graph: Option<&ModuleGraph>
 ));

crates/rspack_core/src/dependency/context_element_dependency.rs

@@ -8,8 +8,8 @@ use super::{AffectType, FactorizeInfo};
 use crate::{
   AsContextDependency, AsDependencyCodeGeneration, Context, ContextMode, ContextNameSpaceObject,
   ContextOptions, Dependency, DependencyCategory, DependencyId, DependencyType,
-  ExportsInfoArtifact, ExtendedReferencedExport, ImportAttributes, ModuleDependency, ModuleGraph,
-  ModuleGraphCacheArtifact, ModuleLayer, ReferencedSpecifier, ResourceIdentifier, RuntimeSpec,
+  ExportsInfoArtifact, ImportAttributes, ModuleDependency, ModuleGraph, ModuleGraphCacheArtifact,
+  ModuleLayer, ReferencedExport, ReferencedSpecifier, ResourceIdentifier, RuntimeSpec,
   create_exports_object_referenced, create_referenced_exports_by_referenced_specifiers,
 };
 
@@ -82,7 +82,7 @@ impl Dependency for ContextElementDependency {
     module_graph_cache: &ModuleGraphCacheArtifact,
     exports_info_artifact: &ExportsInfoArtifact,
     _runtime: Option<&RuntimeSpec>,
-  ) -> Vec<ExtendedReferencedExport> {
+  ) -> Vec<ReferencedExport> {
     if let Some(referenced_specifiers) = &self.referenced_specifiers {
       let Some(parent_module) = module_graph
         .get_parent_module(&self.id)

crates/rspack_core/src/dependency/dependency_trait.rs

@@ -12,9 +12,9 @@ use super::{
   dependency_template::AsDependencyCodeGeneration, module_dependency::*,
 };
 use crate::{
-  AsContextDependency, ConnectionState, Context, ExportsInfoArtifact, ExtendedReferencedExport,
-  ForwardId, ImportAttributes, ImportPhase, LazyUntil, ModuleGraph, ModuleGraphCacheArtifact,
-  ModuleLayer, RuntimeSpec, SideEffectsStateArtifact, create_exports_object_referenced,
+  AsContextDependency, ConnectionState, Context, ExportsInfoArtifact, ForwardId, ImportAttributes,
+  ImportPhase, LazyUntil, ModuleGraph, ModuleGraphCacheArtifact, ModuleLayer, ReferencedExport,
+  RuntimeSpec, SideEffectsStateArtifact, create_exports_object_referenced,
 };
 
 #[derive(Debug, Clone, Copy)]
@@ -114,7 +114,7 @@ pub trait Dependency:
     _module_graph_cache: &ModuleGraphCacheArtifact,
     _exports_info_artifact: &ExportsInfoArtifact,
     _runtime: Option<&RuntimeSpec>,
-  ) -> Vec<ExtendedReferencedExport> {
+  ) -> Vec<ReferencedExport> {
     create_exports_object_referenced()
   }
 

crates/rspack_core/src/dependency/mod.rs

@@ -47,18 +47,11 @@ pub use static_exports_dependency::{StaticExportsDependency, StaticExportsSpec};
 use swc_core::ecma::atoms::Atom;
 
 use crate::{
-  ConnectionState, EvaluatedInlinableValue, ExportsInfoArtifact, ExportsType,
-  ExtendedReferencedExport, ModuleGraph, ModuleGraphCacheArtifact, ModuleGraphConnection,
-  ModuleIdentifier, ReferencedExport, RuntimeSpec, SideEffectsStateArtifact,
-  create_exports_object_referenced,
+  ConnectionState, EvaluatedInlinableValue, ExportsInfoArtifact, ExportsType, ModuleGraph,
+  ModuleGraphCacheArtifact, ModuleGraphConnection, ModuleIdentifier, ReferencedExport, RuntimeSpec,
+  SideEffectsStateArtifact, create_exports_object_referenced,
 };
 
-#[derive(Debug, Clone)]
-pub enum ProcessModuleReferencedExports {
-  Map(FxHashMap<String, ExtendedReferencedExport>),
-  ExtendRef(Vec<ExtendedReferencedExport>),
-}
-
 #[derive(Debug, Default)]
 pub struct ExportSpec {
   pub name: Atom,
@@ -312,7 +305,7 @@ pub fn create_referenced_exports_by_referenced_specifiers(
   referenced_specifiers: &[ReferencedSpecifier],
   exports_type: ExportsType,
   is_json: bool,
-) -> Vec<ExtendedReferencedExport> {
+) -> Vec<ReferencedExport> {
   let mut refs = vec![];
   for ReferencedSpecifier {
     names,
@@ -357,11 +350,11 @@ pub fn create_referenced_exports_by_referenced_specifiers(
       // remove last one
       names = &names[..names.len().saturating_sub(1)];
     }
-    refs.push(ExtendedReferencedExport::Export(ReferencedExport::new(
-      names.to_vec(),
-      false,
-      false,
-    )));
+    refs.push(
+      ReferencedExport::from(names)
+        .with_can_mangle(false)
+        .with_can_inline(false),
+    );
   }
   refs
 }

crates/rspack_core/src/exports/referenced_export.rs

@@ -1,69 +1,150 @@
+use bitflags::bitflags;
 use rspack_util::atom::Atom;
 use rustc_hash::FxHashSet;
+use smallvec::SmallVec;
 
 use crate::{ExportInfo, ExportInfoData, ExportsInfoArtifact, RuntimeSpec, UsageState};
 
-/// refer https://github.com/webpack/webpack/blob/d15c73469fd71cf98734685225250148b68ddc79/lib/FlagDependencyUsagePlugin.js#L64
-#[derive(Clone, Debug)]
-pub enum ExtendedReferencedExport {
-  Array(Vec<Atom>),
-  Export(ReferencedExport),
+pub type ReferencedExportPath = SmallVec<[Atom; 2]>;
+
+bitflags! {
+  #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+  pub struct ReferencedExportFlags: u8 {
+    const CAN_MANGLE = 1 << 0;
+    const CAN_INLINE = 1 << 1;
+    const NS_ACCESS = 1 << 2;
+  }
+}
+
+impl Default for ReferencedExportFlags {
+  fn default() -> Self {
+    Self::CAN_MANGLE | Self::CAN_INLINE
+  }
+}
+
+impl ReferencedExportFlags {
+  #[inline]
+  pub fn merge(&mut self, other: Self) {
+    self.set(
+      Self::CAN_MANGLE,
+      self.contains(Self::CAN_MANGLE) && other.contains(Self::CAN_MANGLE),
+    );
+    self.set(
+      Self::CAN_INLINE,
+      self.contains(Self::CAN_INLINE) && other.contains(Self::CAN_INLINE),
+    );
+    self.set(
+      Self::NS_ACCESS,
+      self.contains(Self::NS_ACCESS) || other.contains(Self::NS_ACCESS),
+    );
+  }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct ReferencedExport {
+  pub name: ReferencedExportPath,
+  pub flags: ReferencedExportFlags,
 }
 
-pub fn is_no_exports_referenced(exports: &[ExtendedReferencedExport]) -> bool {
+pub fn is_no_exports_referenced(exports: &[ReferencedExport]) -> bool {
   exports.is_empty()
 }
 
-pub fn is_exports_object_referenced(exports: &[ExtendedReferencedExport]) -> bool {
-  matches!(exports[..], [ExtendedReferencedExport::Array(ref arr)] if arr.is_empty())
+pub fn is_exports_object_referenced(exports: &[ReferencedExport]) -> bool {
+  matches!(exports, [export] if export.name.is_empty())
 }
 
-pub fn create_no_exports_referenced() -> Vec<ExtendedReferencedExport> {
+pub fn create_no_exports_referenced() -> Vec<ReferencedExport> {
   vec![]
 }
 
-pub fn create_exports_object_referenced() -> Vec<ExtendedReferencedExport> {
-  vec![ExtendedReferencedExport::Array(vec![])]
+pub fn create_exports_object_referenced() -> Vec<ReferencedExport> {
+  vec![ReferencedExport::default()]
 }
 
-impl From<Vec<Atom>> for ExtendedReferencedExport {
+impl From<Vec<Atom>> for ReferencedExport {
+  #[inline]
   fn from(value: Vec<Atom>) -> Self {
-    ExtendedReferencedExport::Array(value)
+    Self::from(ReferencedExportPath::from_vec(value))
   }
 }
-impl From<ReferencedExport> for ExtendedReferencedExport {
-  fn from(value: ReferencedExport) -> Self {
-    ExtendedReferencedExport::Export(value)
+
+impl From<Vec<&Atom>> for ReferencedExport {
+  #[inline]
+  fn from(value: Vec<&Atom>) -> Self {
+    Self::from(value.into_iter().cloned().collect::<ReferencedExportPath>())
   }
 }
 
-#[derive(Clone, Debug)]
-pub struct ReferencedExport {
-  pub name: Vec<Atom>,
-  pub can_mangle: bool,
-  pub can_inline: bool,
-  pub ns_access: bool,
+impl From<&[Atom]> for ReferencedExport {
+  #[inline]
+  fn from(value: &[Atom]) -> Self {
+    Self::from(ReferencedExportPath::from(value))
+  }
 }
 
-impl ReferencedExport {
-  pub fn new(name: Vec<Atom>, can_mangle: bool, can_inline: bool) -> Self {
+impl From<ReferencedExportPath> for ReferencedExport {
+  #[inline]
+  fn from(name: ReferencedExportPath) -> Self {
     Self {
       name,
-      can_mangle,
-      can_inline,
-      ns_access: false,
+      flags: ReferencedExportFlags::default(),
     }
   }
 }
 
-impl Default for ReferencedExport {
-  fn default() -> Self {
-    Self {
-      name: vec![],
-      can_mangle: true,
-      can_inline: true,
-      ns_access: false,
-    }
+impl From<Atom> for ReferencedExport {
+  #[inline]
+  fn from(value: Atom) -> Self {
+    let mut path = ReferencedExportPath::new();
+    path.push(value);
+    Self::from(path)
+  }
+}
+
+impl From<&Atom> for ReferencedExport {
+  #[inline]
+  fn from(value: &Atom) -> Self {
+    Self::from(value.clone())
+  }
+}
+
+impl ReferencedExport {
+  #[inline]
+  pub fn with_can_mangle(mut self, can_mangle: bool) -> Self {
+    self
+      .flags
+      .set(ReferencedExportFlags::CAN_MANGLE, can_mangle);
+    self
+  }
+
+  #[inline]
+  pub fn with_can_inline(mut self, can_inline: bool) -> Self {
+    self
+      .flags
+      .set(ReferencedExportFlags::CAN_INLINE, can_inline);
+    self
+  }
+
+  #[inline]
+  pub fn with_ns_access(mut self, ns_access: bool) -> Self {
+    self.flags.set(ReferencedExportFlags::NS_ACCESS, ns_access);
+    self
+  }
+
+  #[inline]
+  pub fn can_mangle(&self) -> bool {
+    self.flags.contains(ReferencedExportFlags::CAN_MANGLE)
+  }
+
+  #[inline]
+  pub fn can_inline(&self) -> bool {
+    self.flags.contains(ReferencedExportFlags::CAN_INLINE)
+  }
+
+  #[inline]
+  pub fn ns_access(&self) -> bool {
+    self.flags.contains(ReferencedExportFlags::NS_ACCESS)
   }
 }
 

crates/rspack_plugin_css/src/dependency/compose.rs

@@ -4,8 +4,8 @@ use rspack_cacheable::{
 };
 use rspack_core::{
   AsContextDependency, AsDependencyCodeGeneration, CssExportType, Dependency, DependencyCategory,
-  DependencyId, DependencyRange, DependencyType, ExportsInfoArtifact, ExtendedReferencedExport,
-  FactorizeInfo, ModuleDependency, RuntimeSpec,
+  DependencyId, DependencyRange, DependencyType, ExportsInfoArtifact, FactorizeInfo,
+  ModuleDependency, ReferencedExport, RuntimeSpec,
 };
 use rspack_util::atom::Atom;
 
@@ -81,12 +81,8 @@ impl Dependency for CssComposeDependency {
     _module_graph_cache: &rspack_core::ModuleGraphCacheArtifact,
     _exports_info_artifact: &ExportsInfoArtifact,
     _runtime: Option<&RuntimeSpec>,
-  ) -> Vec<ExtendedReferencedExport> {
-    self
-      .names
-      .iter()
-      .map(|n| ExtendedReferencedExport::Array(vec![n.clone()]))
-      .collect()
+  ) -> Vec<ReferencedExport> {
+    self.names.iter().map(ReferencedExport::from).collect()
   }
 }
 

crates/rspack_plugin_css/src/dependency/self_reference.rs

@@ -2,7 +2,7 @@ use rspack_cacheable::{cacheable, cacheable_dyn};
 use rspack_core::{
   AsContextDependency, Dependency, DependencyCategory, DependencyCodeGeneration, DependencyId,
   DependencyRange, DependencyTemplate, DependencyTemplateType, DependencyType, ExportsInfoArtifact,
-  ExtendedReferencedExport, FactorizeInfo, ModuleDependency, RuntimeSpec, TemplateContext,
+  FactorizeInfo, ModuleDependency, ReferencedExport, RuntimeSpec, TemplateContext,
   TemplateReplaceSource,
 };
 use rspack_util::atom::Atom;
@@ -64,11 +64,11 @@ impl Dependency for CssSelfReferenceLocalIdentDependency {
     _module_graph_cache: &rspack_core::ModuleGraphCacheArtifact,
     _exports_info_artifact: &ExportsInfoArtifact,
     _runtime: Option<&RuntimeSpec>,
-  ) -> Vec<ExtendedReferencedExport> {
+  ) -> Vec<ReferencedExport> {
     self
       .names
       .iter()
-      .map(|n| ExtendedReferencedExport::Array(vec![Atom::from(n.as_str())]))
+      .map(|n| ReferencedExport::from(Atom::from(n.as_str())))
       .collect()
   }
 }