diff --git a/crates/rspack_core/src/artifacts/module_graph_cache_artifact.rs b/crates/rspack_core/src/artifacts/module_graph_cache_artifact.rs index 9d97517f9392..d003c84404d1 100644 --- a/crates/rspack_core/src/artifacts/module_graph_cache_artifact.rs +++ b/crates/rspack_core/src/artifacts/module_graph_cache_artifact.rs @@ -157,44 +157,68 @@ pub struct NormalReexportItem { pub export_info: ExportInfo, } -#[derive(Debug, PartialEq, Eq, Clone, Copy)] -pub enum ExportModeType { +#[derive(Debug, Clone)] +pub enum ExportMode { Missing, - Unused, - EmptyStar, - ReexportDynamicDefault, - ReexportNamedDefault, - ReexportNamespaceObject, - ReexportFakeNamespaceObject, - ReexportUndefined, - NormalReexport, - DynamicReexport, + Unused(ExportModeUnused), + EmptyStar(ExportModeEmptyStar), + ReexportDynamicDefault(ExportModeReexportDynamicDefault), + ReexportNamedDefault(ExportModeReexportNamedDefault), + ReexportNamespaceObject(ExportModeReexportNamespaceObject), + ReexportFakeNamespaceObject(ExportModeFakeNamespaceObject), + ReexportUndefined(ExportModeReexportUndefined), + NormalReexport(ExportModeNormalReexport), + DynamicReexport(Box), } #[derive(Debug, Clone)] -pub struct ExportMode { - /// corresponding to `type` field in webpack's `EpxortMode` - pub ty: ExportModeType, - pub items: Option>, - pub name: Option, - pub fake_type: u8, - pub partial_namespace_export_info: Option, - pub ignored: Option>, +pub struct ExportModeUnused { + pub name: Atom, +} + +#[derive(Debug, Clone)] +pub struct ExportModeEmptyStar { pub hidden: Option>, } -impl ExportMode { - pub fn new(ty: ExportModeType) -> Self { - Self { - ty, - items: None, - name: None, - fake_type: 0, - partial_namespace_export_info: None, - ignored: None, - hidden: None, - } - } +#[derive(Debug, Clone)] +pub struct ExportModeReexportDynamicDefault { + pub name: Atom, +} + +#[derive(Debug, Clone)] +pub struct ExportModeReexportNamedDefault { + pub name: Atom, + pub partial_namespace_export_info: ExportInfo, +} + +#[derive(Debug, Clone)] +pub struct ExportModeReexportNamespaceObject { + pub name: Atom, + pub partial_namespace_export_info: ExportInfo, +} + +#[derive(Debug, Clone)] +pub struct ExportModeFakeNamespaceObject { + pub name: Atom, + pub fake_type: u8, + pub partial_namespace_export_info: ExportInfo, +} + +#[derive(Debug, Clone)] +pub struct ExportModeReexportUndefined { + pub name: Atom, +} + +#[derive(Debug, Clone)] +pub struct ExportModeNormalReexport { + pub items: Vec, +} + +#[derive(Debug, Clone)] +pub struct ExportModeDynamicReexport { + pub ignored: HashSet, + pub hidden: Option>, } #[derive(Debug, Default)] diff --git a/crates/rspack_core/src/dependency/mod.rs b/crates/rspack_core/src/dependency/mod.rs index 6bd599c22b5d..c41bcf751821 100644 --- a/crates/rspack_core/src/dependency/mod.rs +++ b/crates/rspack_core/src/dependency/mod.rs @@ -37,7 +37,7 @@ pub use runtime_requirements_dependency::{ RuntimeRequirementsDependency, RuntimeRequirementsDependencyTemplate, }; pub use runtime_template::*; -use rustc_hash::FxHashMap; +use rustc_hash::{FxHashMap, FxHashSet}; use serde::Serialize; pub use span::SpanExt; pub use static_exports_dependency::{StaticExportsDependency, StaticExportsSpec}; @@ -106,8 +106,8 @@ pub struct ExportsSpec { pub terminal_binding: Option, pub from: Option, pub dependencies: Option>, - pub hide_export: Option>, - pub exclude_exports: Option>, + pub hide_export: Option>, + pub exclude_exports: Option>, } pub trait DependencyConditionFn: Sync + Send { diff --git a/crates/rspack_core/src/exports/exports_info.rs b/crates/rspack_core/src/exports/exports_info.rs index 8d2f358ec5f7..31e079f4e9cb 100644 --- a/crates/rspack_core/src/exports/exports_info.rs +++ b/crates/rspack_core/src/exports/exports_info.rs @@ -4,6 +4,7 @@ use either::Either; use rspack_cacheable::cacheable; use rspack_collections::{impl_item_ukey, Ukey, UkeySet}; use rspack_util::atom::Atom; +use rustc_hash::FxHashSet; use serde::Serialize; use super::{ @@ -129,7 +130,7 @@ impl ExportsInfo { &self, mg: &mut ModuleGraph, can_mangle: bool, - exclude_exports: Option>, + exclude_exports: Option<&FxHashSet>, target_key: Option, target_module: Option, priority: Option, @@ -137,7 +138,7 @@ impl ExportsInfo { let mut changed = false; if let Some(exclude_exports) = &exclude_exports { - for name in exclude_exports { + for name in exclude_exports.iter() { self.get_export_info(mg, name); } } diff --git a/crates/rspack_plugin_javascript/src/dependency/esm/esm_export_imported_specifier_dependency.rs b/crates/rspack_plugin_javascript/src/dependency/esm/esm_export_imported_specifier_dependency.rs index 83fb41e5d42b..1c2777194dc3 100644 --- a/crates/rspack_plugin_javascript/src/dependency/esm/esm_export_imported_specifier_dependency.rs +++ b/crates/rspack_plugin_javascript/src/dependency/esm/esm_export_imported_specifier_dependency.rs @@ -13,7 +13,10 @@ use rspack_core::{ DependencyCodeGeneration, DependencyCondition, DependencyConditionFn, DependencyId, DependencyLocation, DependencyRange, DependencyTemplate, DependencyTemplateType, DependencyType, DetermineExportAssignmentsKey, ESMExportInitFragment, ExportInfoGetter, ExportMode, - ExportModeType, ExportNameOrSpec, ExportPresenceMode, ExportProvided, ExportSpec, ExportsInfo, + ExportModeDynamicReexport, ExportModeEmptyStar, ExportModeFakeNamespaceObject, + ExportModeNormalReexport, ExportModeReexportDynamicDefault, ExportModeReexportNamedDefault, + ExportModeReexportNamespaceObject, ExportModeReexportUndefined, ExportModeUnused, + ExportNameOrSpec, ExportPresenceMode, ExportProvided, ExportSpec, ExportsInfo, ExportsOfExportsSpec, ExportsSpec, ExportsType, ExtendedReferencedExport, FactorizeInfo, ImportAttributes, InitFragmentExt, InitFragmentKey, InitFragmentStage, JavascriptParserOptions, ModuleDependency, ModuleGraph, ModuleGraphCacheArtifact, ModuleIdentifier, NormalInitFragment, @@ -149,7 +152,7 @@ impl ESMExportImportedSpecifierDependency { { imported_module_identifier } else { - return ExportMode::new(ExportModeType::Missing); + return ExportMode::Missing; }; let parent_module = module_graph @@ -163,9 +166,7 @@ impl ESMExportImportedSpecifierDependency { !exports_info.is_used(module_graph, runtime) }; if is_name_unused { - let mut mode = ExportMode::new(ExportModeType::Unused); - mode.name = Some("*".into()); - return mode; + return ExportMode::Unused(ExportModeUnused { name: "*".into() }); } let imported_exports_type = get_exports_type(module_graph, id, parent_module); let ids = self.get_ids(module_graph); @@ -177,16 +178,16 @@ impl ESMExportImportedSpecifierDependency { { match imported_exports_type { ExportsType::Dynamic => { - let mut export_mode = ExportMode::new(ExportModeType::ReexportDynamicDefault); - export_mode.name = Some(name.clone()); - return export_mode; + return ExportMode::ReexportDynamicDefault(ExportModeReexportDynamicDefault { + name: name.clone(), + }); } ExportsType::DefaultOnly | ExportsType::DefaultWithNamed => { let export_info = exports_info.get_read_only_export_info(module_graph, name); - let mut export_mode = ExportMode::new(ExportModeType::ReexportNamedDefault); - export_mode.name = Some(name.clone()); - export_mode.partial_namespace_export_info = Some(export_info); - return export_mode; + return ExportMode::ReexportNamedDefault(ExportModeReexportNamedDefault { + name: name.clone(), + partial_namespace_export_info: export_info, + }); } _ => {} } @@ -199,44 +200,42 @@ impl ESMExportImportedSpecifierDependency { // export { name as name } match imported_exports_type { ExportsType::DefaultOnly => { - let mut export_mode = ExportMode::new(ExportModeType::ReexportUndefined); - export_mode.name = Some(name); - return export_mode; + return ExportMode::ReexportUndefined(ExportModeReexportUndefined { name }); } _ => { - let mut export_mode = ExportMode::new(ExportModeType::NormalReexport); - export_mode.items = Some(vec![NormalReexportItem { - name, - ids: ids.to_vec(), - hidden: false, - checked: false, - export_info, - }]); - return export_mode; + return ExportMode::NormalReexport(ExportModeNormalReexport { + items: vec![NormalReexportItem { + name, + ids: ids.to_vec(), + hidden: false, + checked: false, + export_info, + }], + }); } } } else { // export * as name match imported_exports_type { ExportsType::DefaultOnly => { - let mut export_mode = ExportMode::new(ExportModeType::ReexportFakeNamespaceObject); - export_mode.name = Some(name); - export_mode.partial_namespace_export_info = Some(export_info); - export_mode.fake_type = 0; - return export_mode; + return ExportMode::ReexportFakeNamespaceObject(ExportModeFakeNamespaceObject { + name, + partial_namespace_export_info: export_info, + fake_type: 0, + }); } ExportsType::DefaultWithNamed => { - let mut export_mode = ExportMode::new(ExportModeType::ReexportFakeNamespaceObject); - export_mode.name = Some(name); - export_mode.partial_namespace_export_info = Some(export_info); - export_mode.fake_type = 2; - return export_mode; + return ExportMode::ReexportFakeNamespaceObject(ExportModeFakeNamespaceObject { + name, + partial_namespace_export_info: export_info, + fake_type: 2, + }); } _ => { - let mut export_mode = ExportMode::new(ExportModeType::ReexportNamespaceObject); - export_mode.name = Some(name); - export_mode.partial_namespace_export_info = Some(export_info); - return export_mode; + return ExportMode::ReexportNamespaceObject(ExportModeReexportNamespaceObject { + name, + partial_namespace_export_info: export_info, + }); } } } @@ -256,9 +255,7 @@ impl ESMExportImportedSpecifierDependency { ); if let Some(exports) = exports { if exports.is_empty() { - let mut export_mode = ExportMode::new(ExportModeType::EmptyStar); - export_mode.hidden = hidden; - return export_mode; + return ExportMode::EmptyStar(ExportModeEmptyStar { hidden }); } let mut items = exports @@ -286,14 +283,12 @@ impl ESMExportImportedSpecifierDependency { }); } } - let mut export_mode = ExportMode::new(ExportModeType::NormalReexport); - export_mode.items = Some(items); - export_mode + ExportMode::NormalReexport(ExportModeNormalReexport { items }) } else { - let mut export_mode = ExportMode::new(ExportModeType::DynamicReexport); - export_mode.ignored = Some(ignored_exports); - export_mode.hidden = hidden; - export_mode + ExportMode::DynamicReexport(Box::new(ExportModeDynamicReexport { + ignored: ignored_exports, + hidden, + })) } } @@ -504,7 +499,7 @@ impl ESMExportImportedSpecifierDependency { None } - pub fn add_export_fragments(&self, ctxt: &mut TemplateContext, mut mode: ExportMode) { + pub fn add_export_fragments(&self, ctxt: &mut TemplateContext, mode: ExportMode) { let TemplateContext { module, runtime_requirements, @@ -516,8 +511,8 @@ impl ESMExportImportedSpecifierDependency { let mg_cache = &compilation.module_graph_cache_artifact; let module_identifier = module.identifier(); let import_var = compilation.get_import_var(&self.id); - match mode.ty { - ExportModeType::Missing | ExportModeType::EmptyStar => { + match mode { + ExportMode::Missing | ExportMode::EmptyStar(_) => { fragments.push( NormalInitFragment::new( "/* empty/unused ESM star reexport */\n".to_string(), @@ -529,12 +524,9 @@ impl ESMExportImportedSpecifierDependency { .boxed(), ); } - ExportModeType::Unused => fragments.push( + ExportMode::Unused(ExportModeUnused { name }) => fragments.push( NormalInitFragment::new( - to_normal_comment(&format!( - "unused ESM reexport {}", - mode.name.unwrap_or_default() - )), + to_normal_comment(&format!("unused ESM reexport {name}")), InitFragmentStage::StageESMExports, 1, InitFragmentKey::unique(), @@ -542,12 +534,10 @@ impl ESMExportImportedSpecifierDependency { ) .boxed(), ), - ExportModeType::ReexportDynamicDefault => { - let used_name = mg.get_exports_info(&module.identifier()).get_used_name( - mg, - None, - &[mode.name.expect("should have name")], - ); + ExportMode::ReexportDynamicDefault(ExportModeReexportDynamicDefault { name }) => { + let used_name = mg + .get_exports_info(&module.identifier()) + .get_used_name(mg, None, &[name]); let key = render_used_name(used_name.as_ref()); let init_fragment = self @@ -561,12 +551,10 @@ impl ESMExportImportedSpecifierDependency { .boxed(); fragments.push(init_fragment); } - ExportModeType::ReexportNamedDefault => { - let used_name = mg.get_exports_info(&module.identifier()).get_used_name( - mg, - None, - &[mode.name.expect("should have name")], - ); + ExportMode::ReexportNamedDefault(mode) => { + let used_name = + mg.get_exports_info(&module.identifier()) + .get_used_name(mg, None, &[mode.name]); let key = render_used_name(used_name.as_ref()); let init_fragment = self .get_reexport_fragment( @@ -579,12 +567,10 @@ impl ESMExportImportedSpecifierDependency { .boxed(); fragments.push(init_fragment); } - ExportModeType::ReexportNamespaceObject => { - let used_name = mg.get_exports_info(&module.identifier()).get_used_name( - mg, - None, - &[mode.name.expect("should have name")], - ); + ExportMode::ReexportNamespaceObject(mode) => { + let used_name = + mg.get_exports_info(&module.identifier()) + .get_used_name(mg, None, &[mode.name]); let key = render_used_name(used_name.as_ref()); let init_fragment = self @@ -598,22 +584,18 @@ impl ESMExportImportedSpecifierDependency { .boxed(); fragments.push(init_fragment); } - ExportModeType::ReexportFakeNamespaceObject => { + ExportMode::ReexportFakeNamespaceObject(mode) => { // TODO: reexport fake namespace object - let used_name = mg.get_exports_info(&module.identifier()).get_used_name( - mg, - None, - &[mode.name.expect("should have name")], - ); + let used_name = + mg.get_exports_info(&module.identifier()) + .get_used_name(mg, None, &[mode.name]); let key = render_used_name(used_name.as_ref()); self.get_reexport_fake_namespace_object_fragments(ctxt, key, &import_var, mode.fake_type); } - ExportModeType::ReexportUndefined => { - let used_name = mg.get_exports_info(&module.identifier()).get_used_name( - mg, - None, - &[mode.name.expect("should have name")], - ); + ExportMode::ReexportUndefined(mode) => { + let used_name = + mg.get_exports_info(&module.identifier()) + .get_used_name(mg, None, &[mode.name]); let key = render_used_name(used_name.as_ref()); let init_fragment = self @@ -627,11 +609,11 @@ impl ESMExportImportedSpecifierDependency { .boxed(); fragments.push(init_fragment); } - ExportModeType::NormalReexport => { + ExportMode::NormalReexport(mode) => { let imported_module = mg .module_identifier_by_dependency_id(&self.id) .expect("should have imported module identifier"); - for item in mode.items.into_iter().flatten() { + for item in mode.items { let NormalReexportItem { name, ids, @@ -694,13 +676,12 @@ impl ESMExportImportedSpecifierDependency { } } } - ExportModeType::DynamicReexport => { - let ignored = match (mode.hidden.take(), mode.ignored.take()) { - (None, None) => HashSet::default(), - (None, Some(ignored)) => ignored, - (Some(hidden), None) => hidden, - (Some(hidden), Some(ignore)) => hidden.union(&ignore).cloned().collect(), - }; + ExportMode::DynamicReexport(mode) => { + let mut ignored = mode.ignored; + if let Some(hidden) = mode.hidden { + ignored.extend(hidden); + } + // TODO: modern, need runtimeTemplate support https://github.com/webpack/webpack/blob/1f99ad6367f2b8a6ef17cce0e058f7a67fb7db18/lib/dependencies/HarmonyExportImportedSpecifierDependency.js#L1104-L1106 let mut content = format!( r" @@ -1079,25 +1060,25 @@ impl Dependency for ESMExportImportedSpecifierDependency { module_graph_cache: &ModuleGraphCacheArtifact, ) -> Option { let mode = self.get_mode(mg, None, module_graph_cache); - match mode.ty { - ExportModeType::Missing => None, - ExportModeType::Unused => { + match mode { + ExportMode::Missing => None, + ExportMode::Unused(_) => { // https://github.com/webpack/webpack/blob/ac7e531436b0d47cd88451f497cdfd0dad41535d/lib/dependencies/HarmonyExportImportedSpecifierDependency.js#L630-L742 unreachable!() } - ExportModeType::EmptyStar => Some(ExportsSpec { + ExportMode::EmptyStar(mode) => Some(ExportsSpec { exports: ExportsOfExportsSpec::Names(vec![]), - hide_export: mode.hidden.map(|item| item.into_iter().collect::>()), + hide_export: mode.hidden, dependencies: Some(vec![*mg .module_identifier_by_dependency_id(self.id()) .expect("should have module")]), ..Default::default() }), - ExportModeType::ReexportDynamicDefault => { + ExportMode::ReexportDynamicDefault(mode) => { let from = mg.connection_by_dependency_id(self.id()); Some(ExportsSpec { exports: ExportsOfExportsSpec::Names(vec![ExportNameOrSpec::ExportSpec(ExportSpec { - name: mode.name.unwrap_or_default(), + name: mode.name, export: Some(rspack_core::Nullable::Value(vec![Atom::from("default")])), from: from.cloned(), ..Default::default() @@ -1107,11 +1088,11 @@ impl Dependency for ESMExportImportedSpecifierDependency { ..Default::default() }) } - ExportModeType::ReexportNamedDefault => { + ExportMode::ReexportNamedDefault(mode) => { let from = mg.connection_by_dependency_id(self.id()); Some(ExportsSpec { exports: ExportsOfExportsSpec::Names(vec![ExportNameOrSpec::ExportSpec(ExportSpec { - name: mode.name.unwrap_or_default(), + name: mode.name, export: Some(rspack_core::Nullable::Value(vec![Atom::from("default")])), from: from.cloned(), ..Default::default() @@ -1121,11 +1102,11 @@ impl Dependency for ESMExportImportedSpecifierDependency { ..Default::default() }) } - ExportModeType::ReexportNamespaceObject => { + ExportMode::ReexportNamespaceObject(mode) => { let from = mg.connection_by_dependency_id(self.id()); Some(ExportsSpec { exports: ExportsOfExportsSpec::Names(vec![ExportNameOrSpec::ExportSpec(ExportSpec { - name: mode.name.unwrap_or_default(), + name: mode.name, export: Some(rspack_core::Nullable::Null), from: from.cloned(), ..Default::default() @@ -1135,11 +1116,11 @@ impl Dependency for ESMExportImportedSpecifierDependency { ..Default::default() }) } - ExportModeType::ReexportFakeNamespaceObject => { + ExportMode::ReexportFakeNamespaceObject(mode) => { let from = mg.connection_by_dependency_id(self.id()); Some(ExportsSpec { exports: ExportsOfExportsSpec::Names(vec![ExportNameOrSpec::ExportSpec(ExportSpec { - name: mode.name.unwrap_or_default(), + name: mode.name, export: Some(rspack_core::Nullable::Null), exports: Some(vec![ExportNameOrSpec::ExportSpec(ExportSpec { name: "default".into(), @@ -1156,65 +1137,49 @@ impl Dependency for ESMExportImportedSpecifierDependency { ..Default::default() }) } - ExportModeType::ReexportUndefined => Some(ExportsSpec { - exports: ExportsOfExportsSpec::Names(vec![ExportNameOrSpec::String( - mode.name.unwrap_or_default(), - )]), + ExportMode::ReexportUndefined(mode) => Some(ExportsSpec { + exports: ExportsOfExportsSpec::Names(vec![ExportNameOrSpec::String(mode.name)]), dependencies: Some(vec![*mg .module_identifier_by_dependency_id(self.id()) .expect("should have module id")]), ..Default::default() }), - ExportModeType::NormalReexport => { + ExportMode::NormalReexport(mode) => { let from = mg.connection_by_dependency_id(self.id()); Some(ExportsSpec { priority: Some(1), exports: ExportsOfExportsSpec::Names( mode .items - .map(|items| { - items - .into_iter() - .map(|item| { - ExportNameOrSpec::ExportSpec(ExportSpec { - name: item.name, - from: from.cloned(), - export: Some(rspack_core::Nullable::Value(item.ids)), - hidden: Some(item.hidden), - ..Default::default() - }) - }) - .collect::>() + .into_iter() + .map(|item| { + ExportNameOrSpec::ExportSpec(ExportSpec { + name: item.name, + from: from.cloned(), + export: Some(rspack_core::Nullable::Value(item.ids)), + hidden: Some(item.hidden), + ..Default::default() + }) }) - .unwrap_or_default(), + .collect::>(), ), dependencies: Some(vec![*from.expect("should have module").module_identifier()]), ..Default::default() }) } - ExportModeType::DynamicReexport => { + ExportMode::DynamicReexport(mode) => { let from = mg.connection_by_dependency_id(self.id()); Some(ExportsSpec { exports: ExportsOfExportsSpec::UnknownExports, from: from.cloned(), can_mangle: Some(false), - hide_export: Some( - mode - .hidden - .clone() - .into_iter() - .flatten() - .collect::>(), - ), - exclude_exports: if let Some(hidden) = mode.hidden { - Some( - hidden - .into_iter() - .chain(mode.ignored.into_iter().flatten()) - .collect::>(), - ) - } else { - Some(mode.ignored.into_iter().flatten().collect::>()) + hide_export: mode.hidden.clone(), + exclude_exports: { + let mut exclude_exports = mode.ignored; + if let Some(hidden) = mode.hidden { + exclude_exports.extend(hidden); + } + Some(exclude_exports) }, dependencies: Some(vec![*from.expect("should have module").module_identifier()]), ..Default::default() @@ -1291,53 +1256,56 @@ impl Dependency for ESMExportImportedSpecifierDependency { runtime: Option<&RuntimeSpec>, ) -> Vec { let mode = self.get_mode(module_graph, runtime, module_graph_cache); - match mode.ty { - ExportModeType::Missing - | ExportModeType::Unused - | ExportModeType::EmptyStar - | ExportModeType::ReexportUndefined => create_no_exports_referenced(), - ExportModeType::ReexportDynamicDefault | ExportModeType::DynamicReexport => { + match mode { + ExportMode::Missing + | ExportMode::Unused(_) + | ExportMode::EmptyStar(_) + | ExportMode::ReexportUndefined(_) => create_no_exports_referenced(), + ExportMode::ReexportDynamicDefault(_) | ExportMode::DynamicReexport(_) => { create_exports_object_referenced() } - ExportModeType::ReexportNamedDefault - | ExportModeType::ReexportNamespaceObject - | ExportModeType::ReexportFakeNamespaceObject => { - if let Some(partial_namespace_export_info) = &mode.partial_namespace_export_info { - let mut referenced_exports = vec![]; + ExportMode::ReexportNamedDefault(ExportModeReexportNamedDefault { + partial_namespace_export_info, + .. + }) + | ExportMode::ReexportNamespaceObject(ExportModeReexportNamespaceObject { + partial_namespace_export_info, + .. + }) + | ExportMode::ReexportFakeNamespaceObject(ExportModeFakeNamespaceObject { + partial_namespace_export_info, + .. + }) => { + let mut referenced_exports = vec![]; + process_export_info( + module_graph, + runtime, + &mut referenced_exports, + vec![], + Some(partial_namespace_export_info), + matches!(mode, ExportMode::ReexportFakeNamespaceObject(_)), + &mut Default::default(), + ); + referenced_exports + .into_iter() + .map(ExtendedReferencedExport::Array) + .collect::>() + } + ExportMode::NormalReexport(mode) => { + let mut referenced_exports = vec![]; + for item in mode.items { + if item.hidden { + continue; + } process_export_info( module_graph, runtime, &mut referenced_exports, - vec![], - Some(*partial_namespace_export_info), - mode.ty == ExportModeType::ReexportFakeNamespaceObject, + item.ids, + Some(item.export_info), + false, &mut Default::default(), ); - referenced_exports - .into_iter() - .map(ExtendedReferencedExport::Array) - .collect::>() - } else { - create_exports_object_referenced() - } - } - ExportModeType::NormalReexport => { - let mut referenced_exports = vec![]; - if let Some(items) = mode.items { - for item in items { - if item.hidden { - continue; - } - process_export_info( - module_graph, - runtime, - &mut referenced_exports, - item.ids, - Some(item.export_info), - false, - &mut Default::default(), - ); - } } referenced_exports .into_iter() @@ -1370,8 +1338,8 @@ impl DependencyConditionFn for ESMExportImportedSpecifierDependencyCondition { .expect("should be ESMExportImportedSpecifierDependency"); let mode = down_casted_dep.get_mode(module_graph, runtime, module_graph_cache); ConnectionState::Active(!matches!( - mode.ty, - ExportModeType::Unused | ExportModeType::EmptyStar + mode, + ExportMode::Unused(_) | ExportMode::EmptyStar(_) )) } } @@ -1513,16 +1481,16 @@ impl DependencyTemplate for ESMExportImportedSpecifierDependencyTemplate { let mode = dep.get_mode(&module_graph, *runtime, module_graph_cache); if let Some(ref mut scope) = concatenation_scope { - if matches!(mode.ty, ExportModeType::ReexportUndefined) { + if let ExportMode::ReexportUndefined(mode) = mode { scope.register_raw_export( - mode.name.clone().expect("should have name"), + mode.name.clone(), String::from("/* reexport non-default export from non-ESM */ undefined"), ); } return; } - if !matches!(mode.ty, ExportModeType::Unused | ExportModeType::EmptyStar) { + if !matches!(mode, ExportMode::Unused(_) | ExportMode::EmptyStar(_)) { esm_import_dependency_apply(dep, dep.source_order, code_generatable_context); dep.add_export_fragments(code_generatable_context, mode); } diff --git a/crates/rspack_plugin_javascript/src/plugin/flag_dependency_exports_plugin.rs b/crates/rspack_plugin_javascript/src/plugin/flag_dependency_exports_plugin.rs index e69c3f378e48..f243533ee85a 100644 --- a/crates/rspack_plugin_javascript/src/plugin/flag_dependency_exports_plugin.rs +++ b/crates/rspack_plugin_javascript/src/plugin/flag_dependency_exports_plugin.rs @@ -74,11 +74,12 @@ impl<'a> FlagDependencyExportsState<'a> { q.enqueue(module_id); } + let mut exports_specs_from_dependencies: IndexMap = + IndexMap::default(); while let Some(module_id) = q.dequeue() { self.changed = false; self.current_module_id = module_id; - let mut exports_specs_from_dependencies: IndexMap = - IndexMap::default(); + exports_specs_from_dependencies.clear(); self.mg_cache.freeze(); self.process_dependencies_block( @@ -89,8 +90,8 @@ impl<'a> FlagDependencyExportsState<'a> { self.mg_cache.unfreeze(); let exports_info = self.mg.get_exports_info(&module_id); - for (dep_id, exports_spec) in exports_specs_from_dependencies.into_iter() { - self.process_exports_spec(dep_id, exports_spec, exports_info); + for (dep_id, exports_spec) in exports_specs_from_dependencies.iter() { + self.process_exports_spec(*dep_id, exports_spec, exports_info); } if self.changed { self.notify_dependencies(&mut q); @@ -164,7 +165,7 @@ impl<'a> FlagDependencyExportsState<'a> { pub fn process_exports_spec( &mut self, dep_id: DependencyId, - export_desc: ExportsSpec, + export_desc: &ExportsSpec, exports_info: ExportsInfo, ) { let exports = &export_desc.exports; @@ -173,7 +174,7 @@ impl<'a> FlagDependencyExportsState<'a> { let global_priority = &export_desc.priority; let global_terminal_binding = export_desc.terminal_binding.unwrap_or(false); let export_dependencies = &export_desc.dependencies; - if let Some(hide_export) = export_desc.hide_export { + if let Some(hide_export) = &export_desc.hide_export { for name in hide_export.iter() { ExportInfoSetter::unset_target( exports_info @@ -188,7 +189,7 @@ impl<'a> FlagDependencyExportsState<'a> { if exports_info.set_unknown_exports_provided( self.mg, global_can_mangle.unwrap_or_default(), - export_desc.exclude_exports, + export_desc.exclude_exports.as_ref(), global_from.map(|_| dep_id), global_from.map(|_| dep_id), *global_priority,