feat: add HarmonyImportSideEffectDependency (#4010)

Author: underfin

crates/rspack_core/src/dependency/mod.rs

@@ -6,6 +6,7 @@ use std::sync::atomic::Ordering::Relaxed;
 pub use entry::*;
 use once_cell::sync::Lazy;
 use rspack_util::ext::AsAny;
+use rustc_hash::FxHashSet as HashSet;
 use serde::Serialize;
 pub use span::SpanExt;
 mod runtime_template;
@@ -29,7 +30,7 @@ use dyn_clone::{clone_trait_object, DynClone};
 
 use crate::{
   ChunkGroupOptions, ConnectionState, Context, ContextMode, ContextOptions, ErrorSpan, ModuleGraph,
-  ModuleGraphConnection, ReferencedExport, RuntimeSpec,
+  ModuleGraphConnection, ModuleIdentifier, ReferencedExport, RuntimeSpec,
 };
 
 // Used to describe dependencies' types, see webpack's `type` getter in `Dependency`
@@ -43,6 +44,7 @@ pub enum DependencyType {
   // Harmony import
   EsmImport,
   EsmImportSpecifier,
+  EsmImportSideEffect,
   // Harmony export
   EsmExport,
   EsmExportImportedSpecifier,
@@ -94,6 +96,7 @@ impl Display for DependencyType {
       DependencyType::Unknown => write!(f, "unknown"),
       DependencyType::Entry => write!(f, "entry"),
       DependencyType::EsmImport => write!(f, "esm import"),
+      DependencyType::EsmImportSideEffect => write!(f, "esm import side effect"),
       DependencyType::EsmExport => write!(f, "esm export"),
       DependencyType::EsmExportSpecifier => write!(f, "esm export specifier"),
       DependencyType::EsmExportImportedSpecifier => write!(f, "esm export import specifier"),
@@ -311,6 +314,14 @@ pub trait ModuleDependency: Dependency {
     None
   }
 
+  fn get_module_evaluation_side_effects_state(
+    &self,
+    _module_graph: &ModuleGraph,
+    _module_chain: &mut HashSet<ModuleIdentifier>,
+  ) -> ConnectionState {
+    ConnectionState::Bool(true)
+  }
+
   fn get_referenced_exports(
     &self,
     _module_graph: &ModuleGraph,

crates/rspack_core/src/module.rs

@@ -14,8 +14,8 @@ use rustc_hash::FxHashSet as HashSet;
 use crate::tree_shaking::visitor::OptimizeAnalyzeResult;
 use crate::{
   BoxDependency, ChunkUkey, CodeGenerationResult, Compilation, CompilerContext, CompilerOptions,
-  Context, ContextModule, DependencyTemplate, ExternalModule, ModuleDependency, ModuleType,
-  NormalModule, RawModule, Resolve, SharedPluginDriver, SourceType,
+  ConnectionState, Context, ContextModule, DependencyTemplate, ExternalModule, ModuleDependency,
+  ModuleGraph, ModuleType, NormalModule, RawModule, Resolve, SharedPluginDriver, SourceType,
 };
 
 pub struct BuildContext<'a> {
@@ -105,8 +105,7 @@ pub struct BuildMeta {
   pub default_object: BuildMetaDefaultObject,
   pub module_argument: ModuleArgument,
   pub exports_argument: ExportsArgument,
-  // TODO: Don't delete this comment, it will be used in near future
-  // pub side_effect_free: bool,
+  pub side_effect_free: Option<bool>,
 }
 
 // webpack build info
@@ -223,6 +222,14 @@ pub trait Module: Debug + Send + Sync + AsAny + DynHash + DynEq + Identifiable {
   fn chunk_condition(&self, _chunk_key: &ChunkUkey, _compilation: &Compilation) -> bool {
     true
   }
+
+  fn get_side_effects_connection_state(
+    &self,
+    _module_graph: &ModuleGraph,
+    _module_chain: &mut HashSet<ModuleIdentifier>,
+  ) -> ConnectionState {
+    ConnectionState::Bool(true)
+  }
 }
 
 pub trait ModuleExt {

crates/rspack_core/src/module_graph/connection.rs

@@ -142,3 +142,22 @@ impl ConnectionState {
     !matches!(self, ConnectionState::Bool(false))
   }
 }
+
+pub fn add_connection_states(a: ConnectionState, b: ConnectionState) -> ConnectionState {
+  if matches!(a, ConnectionState::Bool(true)) || matches!(b, ConnectionState::Bool(true)) {
+    return ConnectionState::Bool(true);
+  }
+  if matches!(a, ConnectionState::Bool(false)) {
+    return ConnectionState::Bool(false);
+  }
+  if matches!(b, ConnectionState::Bool(false)) {
+    return ConnectionState::Bool(false);
+  }
+  if matches!(a, ConnectionState::TransitiveOnly) {
+    return b;
+  }
+  if matches!(b, ConnectionState::TransitiveOnly) {
+    return a;
+  }
+  a
+}

crates/rspack_core/src/module_graph/mod.rs

@@ -8,7 +8,7 @@ use rspack_identifier::IdentifierMap;
 use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
 
 mod connection;
-pub use connection::{ConnectionId, ConnectionState, ModuleGraphConnection};
+pub use connection::*;
 
 use crate::{
   to_identifier, BoxDependency, BoxModule, BuildDependency, BuildInfo, BuildMeta,

crates/rspack_core/src/normal_module.rs

@@ -21,15 +21,16 @@ use rspack_sources::{
   BoxSource, CachedSource, OriginalSource, RawSource, SourceExt, SourceMap, SourceMapSource,
   WithoutOriginalOptions,
 };
+use rustc_hash::FxHashSet as HashSet;
 use rustc_hash::FxHasher;
 use serde_json::json;
 
 use crate::{
-  contextify, get_context, BoxLoader, BoxModule, BuildContext, BuildInfo, BuildMeta, BuildResult,
-  CodeGenerationResult, Compilation, CompilerOptions, Context, DependencyTemplate, GenerateContext,
-  GeneratorOptions, LibIdentOptions, LoaderRunnerPluginProcessResource, Module, ModuleDependency,
-  ModuleGraph, ModuleIdentifier, ModuleType, ParseContext, ParseResult, ParserAndGenerator,
-  ParserOptions, Resolve, SourceType,
+  add_connection_states, contextify, get_context, BoxLoader, BoxModule, BuildContext, BuildInfo,
+  BuildMeta, BuildResult, CodeGenerationResult, Compilation, CompilerOptions, ConnectionState,
+  Context, DependencyTemplate, GenerateContext, GeneratorOptions, LibIdentOptions,
+  LoaderRunnerPluginProcessResource, Module, ModuleDependency, ModuleGraph, ModuleIdentifier,
+  ModuleType, ParseContext, ParseResult, ParserAndGenerator, ParserOptions, Resolve, SourceType,
 };
 
 bitflags! {
@@ -455,6 +456,40 @@ impl Module for NormalModule {
   fn get_context(&self) -> Option<&Context> {
     Some(&self.context)
   }
+
+  // Port from https://github.com/webpack/webpack/blob/main/lib/NormalModule.js#L1120
+  fn get_side_effects_connection_state(
+    &self,
+    module_graph: &ModuleGraph,
+    module_chain: &mut HashSet<ModuleIdentifier>,
+  ) -> ConnectionState {
+    if let Some(mgm) = module_graph.module_graph_module_by_identifier(&self.identifier()) {
+      if let Some(side_effect) = mgm.factory_meta.as_ref().and_then(|m| m.side_effects) {
+        return ConnectionState::Bool(side_effect);
+      }
+      if let Some(side_effect_free) = mgm.build_meta.as_ref().and_then(|m| m.side_effect_free) && side_effect_free {
+        // use module chain instead of is_evaluating_side_effects to mut module graph
+        if module_chain.contains(&self.identifier()) {
+          return ConnectionState::CircularConnection;
+        }
+        module_chain.insert(self.identifier());
+        let mut current = ConnectionState::Bool(false);
+        for dependency_id in mgm.dependencies.iter() {
+          if let Some(dependency) = module_graph.dependency_by_id(dependency_id).expect("should have dependency").as_module_dependency() {
+            let state = dependency.get_module_evaluation_side_effects_state(module_graph, module_chain);
+            if matches!(state, ConnectionState::Bool(true)) {
+              // TODO add optimization bailout
+              return ConnectionState::Bool(true);
+            } else if matches!(state, ConnectionState::CircularConnection) {
+              current = add_connection_states(current, state);
+            }
+          }
+        }
+        return current;
+      }
+    }
+    ConnectionState::Bool(true)
+  }
 }
 
 impl PartialEq for NormalModule {

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

@@ -1,8 +1,10 @@
 use rspack_core::{
-  export_from_import, get_exports_type, Dependency, DependencyCategory, DependencyId,
-  DependencyTemplate, DependencyType, ErrorSpan, ExportsType, InitFragment, InitFragmentStage,
-  ModuleDependency, RuntimeGlobals, TemplateContext, TemplateReplaceSource,
+  export_from_import, get_exports_type, ConnectionState, Dependency, DependencyCategory,
+  DependencyId, DependencyTemplate, DependencyType, ErrorSpan, ExportsType, InitFragment,
+  InitFragmentStage, ModuleDependency, ModuleGraph, ModuleIdentifier, RuntimeGlobals,
+  TemplateContext, TemplateReplaceSource,
 };
+use rustc_hash::FxHashSet as HashSet;
 use swc_core::ecma::atoms::JsWord;
 
 use super::{create_resource_identifier_for_esm_dependency, format_exports};
@@ -135,6 +137,14 @@ impl ModuleDependency for HarmonyExportImportedSpecifierDependency {
   fn resource_identifier(&self) -> Option<&str> {
     Some(&self.resource_identifier)
   }
+
+  fn get_module_evaluation_side_effects_state(
+    &self,
+    _module_graph: &ModuleGraph,
+    _module_chain: &mut HashSet<ModuleIdentifier>,
+  ) -> ConnectionState {
+    ConnectionState::Bool(false)
+  }
 }
 
 #[allow(unused)]

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

@@ -0,0 +1,96 @@
+use rspack_core::{AsDependencyTemplate, ModuleGraph};
+use rspack_core::{
+  ConnectionState, Dependency, DependencyCategory, DependencyCondition, DependencyId,
+  DependencyType, ErrorSpan, ModuleDependency, ModuleIdentifier,
+};
+use rustc_hash::FxHashSet as HashSet;
+use swc_core::ecma::atoms::JsWord;
+
+use super::create_resource_identifier_for_esm_dependency;
+
+#[derive(Debug, Clone)]
+pub struct HarmonyImportSideEffectDependency {
+  pub request: JsWord,
+  pub id: DependencyId,
+  resource_identifier: String,
+}
+
+impl HarmonyImportSideEffectDependency {
+  pub fn new(request: JsWord) -> Self {
+    let resource_identifier = create_resource_identifier_for_esm_dependency(&request);
+    Self {
+      id: DependencyId::new(),
+      request,
+      resource_identifier,
+    }
+  }
+}
+
+impl Dependency for HarmonyImportSideEffectDependency {
+  fn id(&self) -> &DependencyId {
+    &self.id
+  }
+
+  fn category(&self) -> &DependencyCategory {
+    &DependencyCategory::Esm
+  }
+
+  fn dependency_type(&self) -> &DependencyType {
+    &DependencyType::EsmImportSideEffect
+  }
+}
+
+impl ModuleDependency for HarmonyImportSideEffectDependency {
+  fn request(&self) -> &str {
+    &self.request
+  }
+
+  fn user_request(&self) -> &str {
+    &self.request
+  }
+
+  fn span(&self) -> Option<&ErrorSpan> {
+    None
+  }
+
+  fn set_request(&mut self, request: String) {
+    self.request = request.into();
+  }
+
+  fn resource_identifier(&self) -> Option<&str> {
+    Some(&self.resource_identifier)
+  }
+
+  fn get_condition(&self, _module_graph: &ModuleGraph) -> Option<DependencyCondition> {
+    let id = self.id;
+    Some(DependencyCondition::Fn(Box::new(
+      move |_, _, module_graph| {
+        if let Some(module) = module_graph
+          .parent_module_by_dependency_id(&id)
+          .and_then(|module_identifier| module_graph.module_by_identifier(&module_identifier))
+        {
+          module.get_side_effects_connection_state(module_graph, &mut HashSet::default())
+        } else {
+          ConnectionState::Bool(true)
+        }
+      },
+    )))
+  }
+
+  fn get_module_evaluation_side_effects_state(
+    &self,
+    module_graph: &ModuleGraph,
+    module_chain: &mut HashSet<ModuleIdentifier>,
+  ) -> ConnectionState {
+    if let Some(module) = module_graph
+      .parent_module_by_dependency_id(&self.id)
+      .and_then(|module_identifier| module_graph.module_by_identifier(&module_identifier))
+    {
+      module.get_side_effects_connection_state(module_graph, module_chain)
+    } else {
+      ConnectionState::Bool(true)
+    }
+  }
+}
+
+impl AsDependencyTemplate for HarmonyImportSideEffectDependency {}

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

@@ -1,9 +1,10 @@
 use rspack_core::{
   export_from_import, get_dependency_used_by_exports_condition,
-  tree_shaking::symbol::DEFAULT_JS_WORD, Compilation, Dependency, DependencyCategory,
-  DependencyCondition, DependencyId, DependencyTemplate, DependencyType, ErrorSpan,
-  ExportsReferencedType, ModuleDependency, ModuleGraph, ModuleGraphModule, ReferencedExport,
-  RuntimeSpec, TemplateContext, TemplateReplaceSource, UsedByExports,
+  tree_shaking::symbol::DEFAULT_JS_WORD, Compilation, ConnectionState, Dependency,
+  DependencyCategory, DependencyCondition, DependencyId, DependencyTemplate, DependencyType,
+  ErrorSpan, ExportsReferencedType, ModuleDependency, ModuleGraph, ModuleGraphModule,
+  ModuleIdentifier, ReferencedExport, RuntimeSpec, TemplateContext, TemplateReplaceSource,
+  UsedByExports,
 };
 use rustc_hash::FxHashSet as HashSet;
 use swc_core::ecma::atoms::JsWord;
@@ -200,6 +201,14 @@ impl ModuleDependency for HarmonyImportSpecifierDependency {
     get_dependency_used_by_exports_condition(&self.id, &self.used_by_exports, module_graph)
   }
 
+  fn get_module_evaluation_side_effects_state(
+    &self,
+    _module_graph: &ModuleGraph,
+    _module_chain: &mut HashSet<ModuleIdentifier>,
+  ) -> ConnectionState {
+    ConnectionState::Bool(false)
+  }
+
   fn get_referenced_exports(
     &self,
     _module_graph: &ModuleGraph,

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

@@ -17,7 +17,8 @@ pub use harmony_import_specifier_dependency::*;
 mod import_dependency;
 pub use import_dependency::*;
 use rspack_core::DependencyCategory;
-
+mod harmony_import_side_effect_dependency;
+pub use harmony_import_side_effect_dependency::*;
 pub fn create_resource_identifier_for_esm_dependency(request: &str) -> String {
   format!("{}|{}", DependencyCategory::Esm, &request)
 }

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

@@ -18,7 +18,7 @@ use swc_core::{
 
 use crate::dependency::{
   HarmonyExportImportedSpecifierDependency, HarmonyImportDependency,
-  HarmonyImportSpecifierDependency, Specifier,
+  HarmonyImportSideEffectDependency, HarmonyImportSpecifierDependency, Specifier,
 };
 
 pub struct ImporterReferenceInfo {
@@ -114,12 +114,16 @@ impl Visit for HarmonyImportDependencyScanner<'_> {
       self
         .dependencies
         .push(Box::new(HarmonyImportDependency::new(
-          request,
+          request.clone(),
           Some(importer_info.span.into()),
           importer_info.specifiers,
           dependency_type,
           importer_info.exports_all,
         )));
+      // TODO merge HarmonyImportSideEffectDependency and HarmonyImportDependency
+      self
+        .dependencies
+        .push(Box::new(HarmonyImportSideEffectDependency::new(request)));
     }
 
     // collect import reference info