fix: tree-shaking unused RawModule

crates/rspack_core/src/context_module_factory.rs

@@ -12,9 +12,9 @@ use tracing::instrument;
 
 use crate::{
   resolve, BoxDependency, CompilationId, ContextElementDependency, ContextModule,
-  ContextModuleOptions, DependencyCategory, DependencyId, DependencyType, ErrorSpan, ModuleExt,
-  ModuleFactory, ModuleFactoryCreateData, ModuleFactoryResult, ModuleIdentifier, RawModule,
-  ResolveArgs, ResolveContextModuleDependencies, ResolveInnerOptions,
+  ContextModuleOptions, DependencyCategory, DependencyId, DependencyType, ErrorSpan, FactoryMeta,
+  ModuleExt, ModuleFactory, ModuleFactoryCreateData, ModuleFactoryResult, ModuleIdentifier,
+  RawModule, ResolveArgs, ResolveContextModuleDependencies, ResolveInnerOptions,
   ResolveOptionsWithDependencyType, ResolveResult, Resolver, ResolverFactory, SharedPluginDriver,
 };
 
@@ -315,13 +315,18 @@ impl ContextModuleFactory {
       Ok(ResolveResult::Ignored) => {
         let ident = format!("{}/{}", data.context, specifier);
         let module_identifier = ModuleIdentifier::from(format!("ignored|{ident}"));
-        let raw_module = RawModule::new(
+        let mut raw_module = RawModule::new(
           "/* (ignored) */".to_owned(),
           module_identifier,
           format!("{specifier} (ignored)"),
           Default::default(),
         )
         .boxed();
+
+        raw_module.set_factory_meta(FactoryMeta {
+          side_effect_free: Some(true),
+        });
+
         data.add_file_dependencies(file_dependencies);
         data.add_missing_dependencies(missing_dependencies);
         return Ok((ModuleFactoryResult::new_with_module(raw_module), None));

crates/rspack_core/src/normal_module_factory.rs

@@ -18,11 +18,12 @@ use crate::{
   stringify_loaders_and_resource, AssetInlineGeneratorOptions, AssetResourceGeneratorOptions,
   BoxLoader, BoxModule, CompilerOptions, Context, CssAutoGeneratorOptions, CssAutoParserOptions,
   CssModuleGeneratorOptions, CssModuleParserOptions, Dependency, DependencyCategory,
-  DependencyRange, FuncUseCtx, GeneratorOptions, ModuleExt, ModuleFactory, ModuleFactoryCreateData,
-  ModuleFactoryResult, ModuleIdentifier, ModuleLayer, ModuleRuleEffect, ModuleRuleEnforce,
-  ModuleRuleUse, ModuleRuleUseLoader, ModuleType, NormalModule, ParserAndGenerator, ParserOptions,
-  RawModule, Resolve, ResolveArgs, ResolveOptionsWithDependencyType, ResolveResult, Resolver,
-  ResolverFactory, ResourceData, ResourceParsedData, RunnerContext, SharedPluginDriver,
+  DependencyRange, FactoryMeta, FuncUseCtx, GeneratorOptions, ModuleExt, ModuleFactory,
+  ModuleFactoryCreateData, ModuleFactoryResult, ModuleIdentifier, ModuleLayer, ModuleRuleEffect,
+  ModuleRuleEnforce, ModuleRuleUse, ModuleRuleUseLoader, ModuleType, NormalModule,
+  ParserAndGenerator, ParserOptions, RawModule, Resolve, ResolveArgs,
+  ResolveOptionsWithDependencyType, ResolveResult, Resolver, ResolverFactory, ResourceData,
+  ResourceParsedData, RunnerContext, SharedPluginDriver,
 };
 
 define_hook!(NormalModuleFactoryBeforeResolve: SeriesBail(data: &mut ModuleFactoryCreateData) -> bool,tracing=false);
@@ -346,14 +347,18 @@ impl NormalModuleFactory {
             let ident = format!("{}/{}", &data.context, resource);
             let module_identifier = ModuleIdentifier::from(format!("ignored|{ident}"));
 
-            let raw_module = RawModule::new(
+            let mut raw_module = RawModule::new(
               "/* (ignored) */".to_owned(),
               module_identifier,
               format!("{resource} (ignored)"),
               Default::default(),
             )
             .boxed();
 
+            raw_module.set_factory_meta(FactoryMeta {
+              side_effect_free: Some(true),
+            });
+
             return Ok(Some(ModuleFactoryResult::new_with_module(raw_module)));
           }
           Err(err) => {
@@ -866,7 +871,7 @@ impl NormalModuleFactory {
         );
         let module_identifier = ModuleIdentifier::from(format!("ignored|{ident}"));
 
-        let raw_module = RawModule::new(
+        let mut raw_module = RawModule::new(
           "/* (ignored) */".to_owned(),
           module_identifier,
           format!(
@@ -877,6 +882,10 @@ impl NormalModuleFactory {
         )
         .boxed();
 
+        raw_module.set_factory_meta(FactoryMeta {
+          side_effect_free: Some(true),
+        });
+
         return Ok(ModuleFactoryResult::new_with_module(raw_module));
       }
     }

crates/rspack_core/src/raw_module.rs

@@ -4,7 +4,7 @@ use rspack_cacheable::{
   cacheable, cacheable_dyn,
   with::{AsOption, AsPreset},
 };
-use rspack_collections::Identifiable;
+use rspack_collections::{Identifiable, IdentifierMap, IdentifierSet};
 use rspack_error::{impl_empty_diagnosable_trait, Result};
 use rspack_hash::{RspackHash, RspackHashDigest};
 use rspack_macros::impl_source_map_config;
@@ -13,9 +13,9 @@ use rspack_util::source_map::{ModuleSourceMapConfig, SourceMapKind};
 
 use crate::{
   dependencies_block::AsyncDependenciesBlockIdentifier, impl_module_meta_info, module_update_hash,
-  BuildInfo, BuildMeta, CodeGenerationResult, Compilation, ConcatenationScope, Context,
-  DependenciesBlock, DependencyId, FactoryMeta, Module, ModuleGraph, ModuleIdentifier, ModuleType,
-  RuntimeGlobals, RuntimeSpec, SourceType,
+  BuildInfo, BuildMeta, CodeGenerationResult, Compilation, ConcatenationScope, ConnectionState,
+  Context, DependenciesBlock, DependencyId, FactoryMeta, Module, ModuleGraph,
+  ModuleGraphCacheArtifact, ModuleIdentifier, ModuleType, RuntimeGlobals, RuntimeSpec, SourceType,
 };
 
 #[impl_source_map_config]
@@ -150,6 +150,19 @@ impl Module for RawModule {
     module_update_hash(self, &mut hasher, compilation, runtime);
     Ok(hasher.digest(&compilation.options.output.hash_digest))
   }
+
+  fn get_side_effects_connection_state(
+    &self,
+    _module_graph: &ModuleGraph,
+    _module_graph_cache: &ModuleGraphCacheArtifact,
+    _module_chain: &mut IdentifierSet,
+    _connection_state_cache: &mut IdentifierMap<ConnectionState>,
+  ) -> ConnectionState {
+    if let Some(side_effect_free) = self.factory_meta().and_then(|m| m.side_effect_free) {
+      return ConnectionState::Active(!side_effect_free);
+    }
+    ConnectionState::Active(true)
+  }
 }
 
 impl_empty_diagnosable_trait!(RawModule);

tests/webpack-test/configCases/ignore/side-effects/ignored-module.js

@@ -0,0 +1 @@
+module.exports = "ignored";

tests/webpack-test/configCases/ignore/side-effects/locales/a.js

@@ -0,0 +1 @@
+export default "a";

tests/webpack-test/configCases/ignore/side-effects/locales/b.js

@@ -0,0 +1 @@
+export default "b";

tests/webpack-test/configCases/ignore/side-effects/test.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import "ignored-module";
+import "./ignored-module";
+
+it("should remove all ignored modules", async function() {
+	// Current module + module with runtime code to load context modules
+	expect(Object.keys(__webpack_modules__)).toHaveLength(2);
+
+	const x = "a";
+	const locale = (await import("./locales/" + x)).default;
+
+	expect(locale).toBe("a");
+	expect(Object.keys(__webpack_modules__)).toHaveLength(3);
+});

tests/webpack-test/configCases/ignore/side-effects/webpack.config.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const webpack = require("@rspack/core");
+
+/** @type {import("../../../../").Configuration} */
+module.exports = {
+	entry: "./test.js",
+	resolve: {
+		alias: {
+			"ignored-module": false,
+			"./ignored-module": false
+		}
+	},
+	plugins: [new webpack.IgnorePlugin({ resourceRegExp: /(b\.js|b)$/ })],
+	optimization: {
+		sideEffects: true
+	}
+};