fix: support rspack runtime mode context

Author: LingyuCoder

crates/rspack_binding_api/src/plugins/interceptor.rs

@@ -11,7 +11,7 @@ use napi::{
   Either, Env, JsValue,
   bindgen_prelude::{Buffer, FromNapiValue, Function, JsValuesTupleIntoVec, Promise, ToNapiValue},
 };
-use rspack_collections::{IdentifierMap, IdentifierSet};
+use rspack_collections::{Identifier, IdentifierMap, IdentifierSet};
 use rspack_core::{
   AfterResolveResult, AssetEmittedInfo, AsyncModulesArtifact, BeforeResolveResult, BindingCell,
   BoxModule, ChunkGraph, ChunkUkey, Compilation, CompilationAdditionalTreeRuntimeRequirements,
@@ -1242,7 +1242,7 @@ impl CompilationExecuteModule for CompilationExecuteModuleTap {
   async fn run(
     &self,
     entry: &ModuleIdentifier,
-    runtime_modules: &IdentifierSet,
+    runtime_modules: &[Identifier],
     code_generation_results: &BindingCell<rspack_core::CodeGenerationResults>,
     id: &ExecuteModuleId,
   ) -> rspack_error::Result<()> {

crates/rspack_core/src/artifacts/runtime_proxy_metadata_artifact.rs

@@ -6,26 +6,33 @@ use crate::{ArtifactExt, ChunkUkey, RuntimeGlobals, incremental::IncrementalPass
 
 #[derive(Debug, Default, Clone)]
 pub struct RuntimeProxyMetadata {
+  pub tree_runtime_requirements: RuntimeGlobals,
   pub module_proxy_requirements: RuntimeGlobals,
   pub runtime_module_requirements: RuntimeGlobals,
   pub context_setter_fields: RuntimeGlobals,
   pub hook_exposed_requirements: RuntimeGlobals,
 }
 
 impl RuntimeProxyMetadata {
+  fn renderable_fields(runtime_globals: RuntimeGlobals) -> RuntimeGlobals {
+    runtime_globals
+      .renderable_require_scope()
+      .difference(RuntimeGlobals::REQUIRE | RuntimeGlobals::REQUIRE_SCOPE)
+  }
+
   pub fn lexical_fields(&self) -> RuntimeGlobals {
-    let mut fields = self.runtime_module_requirements;
-    fields.insert(self.module_proxy_requirements);
-    fields.insert(self.context_setter_fields);
-    fields.insert(self.hook_exposed_requirements);
-    fields
+    Self::renderable_fields(self.tree_runtime_requirements)
   }
 
   pub fn context_fields(&self) -> RuntimeGlobals {
     let mut fields = self.module_proxy_requirements;
     fields.insert(self.context_setter_fields);
     fields.insert(self.hook_exposed_requirements);
-    fields
+    Self::renderable_fields(fields)
+  }
+
+  pub fn context_setter_fields(&self) -> RuntimeGlobals {
+    Self::renderable_fields(self.context_setter_fields)
   }
 }
 

crates/rspack_core/src/compilation/build_module_graph/module_executor/execute.rs

@@ -1,16 +1,17 @@
-use std::{collections::VecDeque, iter::once, sync::atomic::AtomicU32};
+use std::{collections::VecDeque, fmt::Write, iter::once, sync::atomic::AtomicU32};
 
 use itertools::Itertools;
 use rspack_collections::{Identifier, IdentifierSet};
 use rspack_error::Error;
 use rspack_paths::ArcPathSet;
+use rspack_sources::{RawStringSource, SourceExt};
 use rustc_hash::{FxHashMap as HashMap, FxHashSet};
 use tokio::sync::oneshot::Sender;
 
 use super::context::{ExecutorTaskContext, ImportModuleMeta};
 use crate::{
-  Chunk, ChunkGraph, ChunkKind, CodeGenerationDataAssetInfo, CodeGenerationDataFilename,
-  CodeGenerationResult, CompilationAsset, CompilationAssets, EntryOptions, Entrypoint,
+  Chunk, ChunkGraph, ChunkKind, ChunkUkey, CodeGenerationDataAssetInfo, CodeGenerationDataFilename,
+  CodeGenerationResult, Compilation, CompilationAsset, CompilationAssets, EntryOptions, Entrypoint,
   FactorizeInfo, ModuleCodeGenerationContext, ModuleType, PublicPath, RuntimeSpec, SourceType,
   compilation::{
     code_generation::code_generation_modules,
@@ -19,6 +20,9 @@ use crate::{
       process_chunks_runtime_requirements, process_modules_runtime_requirements,
     },
   },
+  property_access,
+  runtime_globals::{RuntimeVariable, runtime_variable_name},
+  runtime_mode::RuntimeMode,
   utils::task_loop::{Task, TaskResult, TaskType},
 };
 
@@ -35,6 +39,97 @@ pub struct ExecutedRuntimeModule {
 static EXECUTE_MODULE_ID: AtomicU32 = AtomicU32::new(0);
 pub type ExecuteModuleId = u32;
 
+fn create_execute_runtime_source(
+  compilation: &Compilation,
+  chunk_ukey: &ChunkUkey,
+  runtime_modules: &[Identifier],
+) -> Option<(Identifier, CodeGenerationResult)> {
+  if compilation.options.experiments.runtime_mode != RuntimeMode::Rspack {
+    return None;
+  }
+
+  let metadata = compilation
+    .runtime_proxy_metadata_artifact
+    .get(chunk_ukey)?;
+  let lexical_fields = metadata.lexical_fields();
+  let context_fields = metadata.context_fields();
+  if lexical_fields.is_empty() && context_fields.is_empty() && runtime_modules.is_empty() {
+    return None;
+  }
+
+  let runtime_context = runtime_variable_name(&RuntimeVariable::Context);
+  let mut source = String::new();
+  for (_, runtime_global) in lexical_fields.iter_names() {
+    let Some(lexical_name) = runtime_global.to_lexical_name() else {
+      continue;
+    };
+    writeln!(source, "var {lexical_name};").expect("write to string should succeed");
+  }
+  for runtime_id in runtime_modules {
+    let runtime_module = compilation
+      .runtime_modules
+      .get(runtime_id)
+      .expect("runtime module should exist");
+    let runtime_module_source = compilation
+      .code_generation_results
+      .get(runtime_id, None)
+      .get(&SourceType::JavaScript)
+      .expect("runtime module should have runtime source");
+    writeln!(source, "// {}", runtime_module.identifier()).expect("write to string should succeed");
+    if runtime_module.should_isolate() {
+      if compilation
+        .options
+        .output
+        .environment
+        .supports_arrow_function()
+      {
+        writeln!(source, "(() => {{").expect("write to string should succeed");
+      } else {
+        writeln!(source, "!function() {{").expect("write to string should succeed");
+      }
+    }
+    writeln!(
+      source,
+      "{}",
+      runtime_module_source.source().into_string_lossy()
+    )
+    .expect("write to string should succeed");
+    if runtime_module.should_isolate() {
+      if compilation
+        .options
+        .output
+        .environment
+        .supports_arrow_function()
+      {
+        writeln!(source, "}})();").expect("write to string should succeed");
+      } else {
+        writeln!(source, "}}();").expect("write to string should succeed");
+      }
+    }
+  }
+  for (_, runtime_global) in context_fields.iter_names() {
+    let (Some(property_name), Some(lexical_name)) = (
+      runtime_global.property_name(),
+      runtime_global.to_lexical_name(),
+    ) else {
+      continue;
+    };
+    writeln!(
+      source,
+      "if (typeof {lexical_name} !== \"undefined\") {runtime_context}{} = {lexical_name};",
+      property_access([property_name], 0)
+    )
+    .expect("write to string should succeed");
+  }
+
+  (!source.is_empty()).then(|| {
+    (
+      Identifier::from("webpack/runtime/execute_module_runtime"),
+      CodeGenerationResult::default().with_javascript(RawStringSource::from(source).boxed()),
+    )
+  })
+}
+
 #[derive(Debug, Default)]
 pub struct ExecuteModuleResult {
   pub error: Option<String>,
@@ -309,9 +404,9 @@ impl Task<ExecutorTaskContext> for ExecuteTask {
     let runtime_modules = compilation
       .build_chunk_graph_artifact
       .chunk_graph
-      .get_chunk_runtime_modules_iterable(&chunk_ukey)
-      .copied()
-      .collect::<IdentifierSet>();
+      .get_chunk_runtime_modules_in_order(&chunk_ukey, &compilation)
+      .map(|(identifier, _)| *identifier)
+      .collect_vec();
 
     tracing::debug!(
       "runtime modules: {:?}",
@@ -325,9 +420,7 @@ impl Task<ExecutorTaskContext> for ExecuteTask {
         .get(runtime_id)
         .expect("runtime module exist");
 
-      let mut runtime_template = compilation
-        .runtime_template
-        .create_runtime_module_code_template();
+      let mut runtime_template = compilation.runtime_template.create_module_code_template();
       let mut code_generation_context = ModuleCodeGenerationContext {
         compilation: &compilation,
         runtime: None,
@@ -355,12 +448,28 @@ impl Task<ExecutorTaskContext> for ExecuteTask {
         .insert(runtime_module.identifier());
     }
 
+    let runtime_modules_to_execute = if let Some((runtime_identifier, runtime_result)) =
+      create_execute_runtime_source(&compilation, &chunk_ukey, &runtime_modules)
+    {
+      compilation.code_generation_results.insert(
+        runtime_identifier,
+        runtime_result,
+        std::iter::once(runtime.clone()),
+      );
+      compilation
+        .code_generated_modules
+        .insert(runtime_identifier);
+      vec![runtime_identifier]
+    } else {
+      runtime_modules.clone()
+    };
+
     let exports = main_compilation_plugin_driver
       .compilation_hooks
       .execute_module
       .call(
         &entry_module_identifier,
-        &runtime_modules,
+        &runtime_modules_to_execute,
         &compilation.code_generation_results,
         &id,
       )

crates/rspack_core/src/compilation/mod.rs

@@ -45,7 +45,7 @@ use rspack_cacheable::{
   cacheable,
   with::{AsOption, AsPreset, AsVec},
 };
-use rspack_collections::{IdentifierDashMap, IdentifierMap, IdentifierSet};
+use rspack_collections::{Identifier, IdentifierDashMap, IdentifierMap, IdentifierSet};
 use rspack_error::{Diagnostic, Result, ToStringResultToRspackResultExt};
 use rspack_fs::{IntermediateFileSystem, ReadableFileSystem, WritableFileSystem};
 use rspack_hash::{RspackHash, RspackHashDigest};
@@ -102,7 +102,7 @@ define_hook!(CompilationRevokedModules: Series(compilation: &Compilation, revoke
 define_hook!(CompilationStillValidModule: Series(compiler_id: CompilerId, compilation_id: CompilationId, module: &mut BoxModule));
 define_hook!(CompilationSucceedModule: Series(compiler_id: CompilerId, compilation_id: CompilationId, module: &mut BoxModule),tracing=false);
 define_hook!(CompilationExecuteModule:
-  Series(module: &ModuleIdentifier, runtime_modules: &IdentifierSet, code_generation_results: &BindingCell<CodeGenerationResults>, execute_module_id: &ExecuteModuleId));
+  Series(module: &ModuleIdentifier, runtime_modules: &[Identifier], code_generation_results: &BindingCell<CodeGenerationResults>, execute_module_id: &ExecuteModuleId));
 define_hook!(CompilationFinishModules: Series(compilation: &Compilation, async_modules_artifact: &mut AsyncModulesArtifact, exports_info_artifact: &mut ExportsInfoArtifact, side_effects_state_artifact: &mut SideEffectsStateArtifact));
 define_hook!(CompilationSeal: Series(compilation: &Compilation, diagnostics: &mut Vec<Diagnostic>));
 define_hook!(CompilationDependencyReferencedExports: Sync(

crates/rspack_core/src/compilation/runtime_requirements/mod.rs

@@ -393,6 +393,10 @@ pub async fn process_chunks_runtime_requirements(
     })
     .await?;
 
+    if compilation.options.experiments.runtime_mode == ExperimentRuntimeMode::Rspack {
+      set = set.with_require_scope();
+    }
+
     for module in runtime_modules_to_add {
       compilation.add_runtime_module(&chunk_ukey, module)?;
     }
@@ -478,6 +482,10 @@ pub async fn process_chunks_runtime_requirements(
       }
     }
 
+    if compilation.options.experiments.runtime_mode == ExperimentRuntimeMode::Rspack {
+      all_runtime_requirements = all_runtime_requirements.with_require_scope();
+    }
+
     ChunkGraph::set_tree_runtime_requirements(compilation, entry_ukey, all_runtime_requirements);
     for (chunk_ukey, module) in runtime_modules_to_add {
       compilation.add_runtime_module(&chunk_ukey, module)?;
@@ -532,6 +540,14 @@ pub async fn process_chunks_runtime_requirements(
         .build_chunk_graph_artifact
         .chunk_by_ukey
         .expect_get(chunk_ukey);
+      if let Some(chunk_runtime_requirements) = compilation
+        .cgc_runtime_requirements_artifact
+        .get(chunk_ukey)
+      {
+        metadata
+          .hook_exposed_requirements
+          .insert(*chunk_runtime_requirements);
+      }
       for mid in compilation
         .build_chunk_graph_artifact
         .chunk_graph
@@ -542,7 +558,7 @@ pub async fn process_chunks_runtime_requirements(
         {
           metadata
             .module_proxy_requirements
-            .insert(runtime_requirements.renderable_require_scope());
+            .insert(*runtime_requirements);
         }
         if compilation
           .get_module_graph()
@@ -554,11 +570,9 @@ pub async fn process_chunks_runtime_requirements(
             .data
             .get::<CodeGenerationRuntimeRequirementsWrite>()
         {
-          metadata.context_setter_fields.insert(
-            write_requirements
-              .runtime_requirements
-              .renderable_require_scope(),
-          );
+          metadata
+            .context_setter_fields
+            .insert(write_requirements.runtime_requirements);
         }
       }
 
@@ -571,24 +585,23 @@ pub async fn process_chunks_runtime_requirements(
           .runtime_modules
           .get(runtime_module_id)
           .expect("should have runtime module");
-        metadata.runtime_module_requirements.insert(
-          runtime_module
-            .additional_runtime_requirements(compilation)
-            .renderable_require_scope(),
-        );
+        let additional_runtime_requirements =
+          runtime_module.additional_runtime_requirements(compilation);
+        metadata
+          .runtime_module_requirements
+          .insert(additional_runtime_requirements);
+        metadata
+          .tree_runtime_requirements
+          .insert(additional_runtime_requirements);
       }
     }
 
-    metadata.hook_exposed_requirements.insert(
-      ChunkGraph::get_tree_runtime_requirements(compilation, &entry_ukey)
-        .renderable_require_scope(),
-    );
-    metadata
-      .context_setter_fields
-      .insert(metadata.runtime_module_requirements);
     metadata
-      .context_setter_fields
-      .insert(metadata.hook_exposed_requirements);
+      .tree_runtime_requirements
+      .insert(*ChunkGraph::get_tree_runtime_requirements(
+        compilation,
+        &entry_ukey,
+      ));
     compilation
       .runtime_proxy_metadata_artifact
       .insert(entry_ukey, metadata);

crates/rspack_core/src/runtime_globals.rs

@@ -314,7 +314,6 @@ pub static REQUIRE_SCOPE_GLOBALS: LazyLock<RuntimeGlobals> = LazyLock::new(|| {
   runtime_globals.remove(
     RuntimeGlobals::MODULE
       | RuntimeGlobals::MODULE_ID
-      | RuntimeGlobals::REQUIRE
       | RuntimeGlobals::CHUNK_CALLBACK
       | RuntimeGlobals::RETURN_EXPORTS_FROM_RUNTIME
       | RuntimeGlobals::MODULE_LOADED
@@ -523,9 +522,15 @@ impl RuntimeGlobals {
   }
 
   pub fn renderable_require_scope(self) -> Self {
-    self
-      .intersection(*REQUIRE_SCOPE_GLOBALS)
-      .difference(RuntimeGlobals::REQUIRE_SCOPE)
+    self.intersection(*REQUIRE_SCOPE_GLOBALS)
+  }
+
+  pub fn with_require_scope(self) -> Self {
+    if !self.renderable_require_scope().is_empty() {
+      self | RuntimeGlobals::REQUIRE_SCOPE
+    } else {
+      self
+    }
   }
 
   pub fn to_lexical_name(&self) -> Option<&str> {