refactor: streamline import.meta.env definitions

Author: intellild

crates/rspack_core/src/compilation/build_module_graph/graph_updater/repair/add.rs

@@ -120,7 +120,6 @@ impl Task<TaskContext> for AddTask {
       module: self.module,
       resolver_factory: context.resolver_factory.clone(),
       compiler_options: context.compiler_options.clone(),
-      define_plugin_definitions: context.define_plugin_definitions.clone(),
       plugin_driver: context.plugin_driver.clone(),
       runtime_template: context.runtime_template.create_module_code_template(),
       fs: context.fs.clone(),

crates/rspack_core/src/compilation/build_module_graph/graph_updater/repair/build.rs

@@ -24,7 +24,6 @@ pub struct BuildTask {
   pub module: BoxModule,
   pub resolver_factory: Arc<ResolverFactory>,
   pub compiler_options: Arc<CompilerOptions>,
-  pub define_plugin_definitions: Arc<rustc_hash::FxHashMap<String, serde_json::Value>>,
   pub runtime_template: ModuleCodeTemplate,
   pub plugin_driver: SharedPluginDriver,
   pub fs: Arc<dyn ReadableFileSystem>,
@@ -41,7 +40,6 @@ impl Task<TaskContext> for BuildTask {
       compiler_id,
       compilation_id,
       compiler_options,
-      define_plugin_definitions,
       resolver_factory,
       plugin_driver,
       runtime_template,
@@ -62,7 +60,6 @@ impl Task<TaskContext> for BuildTask {
           compiler_id,
           compilation_id,
           compiler_options: compiler_options.clone(),
-          define_plugin_definitions: define_plugin_definitions.clone(),
           resolver_factory: resolver_factory.clone(),
           plugin_driver: plugin_driver.clone(),
           runtime_template,

crates/rspack_core/src/compilation/build_module_graph/graph_updater/repair/context.rs

@@ -22,7 +22,6 @@ pub struct TaskContext {
   pub intermediate_fs: Arc<dyn IntermediateFileSystem>,
   pub output_fs: Arc<dyn WritableFileSystem>,
   pub compiler_options: Arc<CompilerOptions>,
-  pub define_plugin_definitions: Arc<HashMap<String, serde_json::Value>>,
   pub platform: Arc<CompilerPlatform>,
   pub resolver_factory: Arc<ResolverFactory>,
   pub loader_resolver_factory: Arc<ResolverFactory>,
@@ -46,7 +45,6 @@ impl TaskContext {
       plugin_driver: compilation.plugin_driver.clone(),
       buildtime_plugin_driver: compilation.buildtime_plugin_driver.clone(),
       compiler_options: compilation.options.clone(),
-      define_plugin_definitions: Arc::new(compilation.define_plugin_definitions.clone()),
       platform: compilation.platform.clone(),
       resolver_factory: compilation.resolver_factory.clone(),
       loader_resolver_factory: compilation.loader_resolver_factory.clone(),

crates/rspack_core/src/compilation/mod.rs

@@ -293,7 +293,6 @@ pub struct Compilation {
   pub build_dependencies: ArcPathIndexSet,
 
   pub value_cache_versions: ValueCacheVersions,
-  pub define_plugin_definitions: HashMap<String, serde_json::Value>,
 
   import_var_map: IdentifierDashMap<RuntimeKeyMap<ImportVarMap>>,
 
@@ -426,7 +425,6 @@ impl Compilation {
       build_dependencies: Default::default(),
 
       value_cache_versions: ValueCacheVersions::default(),
-      define_plugin_definitions: Default::default(),
 
       import_var_map: IdentifierDashMap::default(),
 

crates/rspack_core/src/module.rs

@@ -46,7 +46,6 @@ pub struct BuildContext {
   pub compiler_id: CompilerId,
   pub compilation_id: CompilationId,
   pub compiler_options: Arc<CompilerOptions>,
-  pub define_plugin_definitions: Arc<HashMap<String, serde_json::Value>>,
   pub resolver_factory: Arc<ResolverFactory>,
   pub runtime_template: ModuleCodeTemplate,
   pub plugin_driver: SharedPluginDriver,

crates/rspack_core/src/normal_module.rs

@@ -574,7 +574,7 @@ impl Module for NormalModule {
         loaders: &self.loaders,
         resource_data: &self.resource_data,
         compiler_options: &build_context.compiler_options,
-        define_plugin_definitions: Some(&build_context.define_plugin_definitions),
+        compilation_id: build_context.compilation_id,
         additional_data: loader_result.additional_data,
         factory_meta: self.factory_meta.as_ref(),
         build_info: &mut self.build_info,

crates/rspack_core/src/parser_and_generator.rs

@@ -9,16 +9,19 @@ use rspack_error::{Result, TWithDiagnosticArray};
 use rspack_hash::RspackHashDigest;
 use rspack_loader_runner::{AdditionalData, ParseMeta, ResourceData};
 use rspack_sources::BoxSource;
-use rspack_util::{ext::AsAny, source_map::SourceMapKind};
-use rustc_hash::{FxHashMap, FxHashSet};
+use rspack_util::{
+  ext::AsAny,
+  fx_hash::{FxHashMap, FxHashSet},
+  source_map::SourceMapKind,
+};
 use swc_core::atoms::Atom;
 
 use crate::{
   AsyncDependenciesBlock, BoxDependency, BoxDependencyTemplate, BoxLoader, BoxModuleDependency,
-  BuildInfo, BuildMeta, ChunkGraph, CodeGenerationData, Compilation, CompilerOptions,
-  ConcatenationScope, Context, DependencyLocation, DependencyRange, EvaluatedInlinableValue,
-  FactoryMeta, GeneratorOptions, Module, ModuleCodeTemplate, ModuleGraph, ModuleIdentifier,
-  ModuleLayer, ModuleType, NormalModule, ParserOptions, RuntimeSpec, SourceType,
+  BuildInfo, BuildMeta, ChunkGraph, CodeGenerationData, Compilation, CompilationId,
+  CompilerOptions, ConcatenationScope, Context, DependencyLocation, DependencyRange,
+  EvaluatedInlinableValue, FactoryMeta, GeneratorOptions, Module, ModuleCodeTemplate, ModuleGraph,
+  ModuleIdentifier, ModuleLayer, ModuleType, NormalModule, ParserOptions, RuntimeSpec, SourceType,
 };
 
 #[derive(Debug)]
@@ -37,7 +40,7 @@ pub struct ParseContext<'a> {
   pub loaders: &'a [BoxLoader],
   pub resource_data: &'a ResourceData,
   pub compiler_options: &'a CompilerOptions,
-  pub define_plugin_definitions: Option<&'a FxHashMap<String, serde_json::Value>>,
+  pub compilation_id: CompilationId,
   pub additional_data: Option<AdditionalData>,
   pub factory_meta: Option<&'a FactoryMeta>,
   pub parse_meta: ParseMeta,

crates/rspack_plugin_javascript/src/parser_and_generator/mod.rs

@@ -200,7 +200,7 @@ impl ParserAndGenerator for JavaScriptParserAndGenerator {
       module_layer,
       resource_data,
       compiler_options,
-      define_plugin_definitions,
+      compilation_id,
       runtime_template,
       factory_meta,
       build_info,
@@ -327,7 +327,7 @@ impl ParserAndGenerator for JavaScriptParserAndGenerator {
       build_info,
       module_identifier,
       module_parser_options,
-      define_plugin_definitions,
+      compilation_id,
       &mut semicolons,
       &mut self.parser_plugins,
       parse_meta,

crates/rspack_plugin_javascript/src/parser_plugin/define_plugin/mod.rs

@@ -2,24 +2,23 @@ mod parser;
 pub(crate) mod utils;
 mod walk_data;
 
-use std::sync::Arc;
+use std::sync::{Arc, LazyLock};
 
 use parser::DefineParserPlugin;
 use rspack_core::{
-  Compilation, CompilationParams, CompilerCompilation, ModuleType, NormalModuleFactoryParser,
-  ParserAndGenerator, ParserOptions, Plugin,
+  Compilation, CompilationId, CompilationParams, CompilerCompilation, ModuleType,
+  NormalModuleFactoryParser, ParserAndGenerator, ParserOptions, Plugin,
 };
 use rspack_error::{Diagnostic, Error, Result};
 use rspack_hook::{plugin, plugin_hook};
-use rustc_hash::FxHashMap;
+use rspack_util::fx_hash::{FxDashMap, FxHashMap};
 use serde_json::Value;
 
-use self::walk_data::WalkData;
+use self::{utils::code_to_string, walk_data::WalkData};
 use crate::parser_and_generator::JavaScriptParserAndGenerator;
 
 pub(crate) const VALUE_DEP_PREFIX: &str = "rspack/DefinePlugin ";
 pub(crate) const IMPORT_META_ENV_VALUE_DEP_KEY: &str = "rspack/DefinePlugin import.meta.env.*";
-const IMPORT_META_ENV_PREFIX: &str = "import.meta.env.";
 
 #[derive(Debug)]
 struct ConflictingValuesError(String, String, String);
@@ -35,54 +34,82 @@ impl ConflictingValuesError {
 }
 
 pub type DefineValue = FxHashMap<String, Value>;
+pub(crate) type ImportMetaEnvDefinitions = FxHashMap<String, Value>;
+
+#[derive(Debug, Default)]
+struct ImportMetaEnvDefinitionsState {
+  definitions: ImportMetaEnvDefinitions,
+  serialized: Option<String>,
+}
+
+static IMPORT_META_ENV_DEFINITIONS_MAP: LazyLock<
+  FxDashMap<CompilationId, ImportMetaEnvDefinitionsState>,
+> = LazyLock::new(Default::default);
 
 #[plugin]
 #[derive(Debug)]
 pub struct DefinePlugin {
   walk_data: Arc<WalkData>,
-  definitions: Arc<DefineValue>,
 }
 
 impl DefinePlugin {
   pub fn new(definitions: DefineValue) -> Self {
-    Self::new_inner(Arc::new(WalkData::new(&definitions)), Arc::new(definitions))
+    Self::new_inner(Arc::new(WalkData::new(&definitions)))
   }
 }
 
-fn import_meta_env_value(definitions: &DefineValue) -> String {
+pub(crate) fn serialize_import_meta_env_definitions(
+  definitions: &ImportMetaEnvDefinitions,
+) -> String {
   let mut pairs = definitions
     .iter()
-    .filter_map(|(key, value)| {
-      key
-        .strip_prefix(IMPORT_META_ENV_PREFIX)
-        .map(|env_key| (env_key, value.to_string()))
-    })
+    .map(|(key, value)| (key.as_str(), code_to_string(value, None, None)))
     .collect::<Vec<_>>();
   pairs.sort_unstable_by(|a, b| a.0.cmp(b.0));
-  pairs
+  let content = pairs
     .into_iter()
-    .map(|(key, value)| format!("{key}:{value}"))
+    .map(|(key, value)| format!("{}:{value}", rspack_util::json_stringify_str(key)))
     .collect::<Vec<_>>()
-    .join(",")
+    .join(",");
+  format!("{{{content}}}")
+}
+
+pub(crate) fn remove_import_meta_env_definitions(compilation_id: CompilationId) {
+  IMPORT_META_ENV_DEFINITIONS_MAP.remove(&compilation_id);
+}
+
+pub(crate) fn import_meta_env_definitions_string(compilation_id: CompilationId) -> String {
+  IMPORT_META_ENV_DEFINITIONS_MAP
+    .get(&compilation_id)
+    .map(|state| {
+      state
+        .serialized
+        .clone()
+        .unwrap_or_else(|| serialize_import_meta_env_definitions(&state.definitions))
+    })
+    .unwrap_or_else(|| "{}".to_string())
+}
+
+pub(crate) fn has_import_meta_env_definition(compilation_id: CompilationId, name: &str) -> bool {
+  IMPORT_META_ENV_DEFINITIONS_MAP
+    .get(&compilation_id)
+    .is_some_and(|state| state.definitions.contains_key(name))
 }
 
 #[plugin_hook(CompilerCompilation for DefinePlugin, tracing=false)]
-async fn compilation(
+async fn collect_import_meta_env_definitions(
   &self,
   compilation: &mut Compilation,
   _params: &mut CompilationParams,
 ) -> Result<()> {
   compilation.extend_diagnostics(self.walk_data.diagnostics.clone());
-  compilation.define_plugin_definitions.extend(
-    self
-      .definitions
-      .iter()
-      .map(|(key, value)| (key.clone(), value.clone())),
-  );
-  compilation.value_cache_versions.insert(
-    IMPORT_META_ENV_VALUE_DEP_KEY.to_string(),
-    import_meta_env_value(&compilation.define_plugin_definitions),
-  );
+  let mut definitions = IMPORT_META_ENV_DEFINITIONS_MAP
+    .entry(compilation.id())
+    .or_default();
+  for (key, value) in &self.walk_data.import_meta_env_definitions {
+    definitions.definitions.insert(key.clone(), value.clone());
+    definitions.serialized = None;
+  }
   for (key, value) in self.walk_data.tiling_definitions.iter() {
     let cache_key = format!("{VALUE_DEP_PREFIX}{key}");
     if let Some(prev) = compilation.value_cache_versions.get(&cache_key)
@@ -101,6 +128,30 @@ async fn compilation(
   Ok(())
 }
 
+#[plugin_hook(CompilerCompilation for DefinePlugin, stage = i32::MAX, tracing=false)]
+async fn finalize_import_meta_env_definitions(
+  &self,
+  compilation: &mut Compilation,
+  _params: &mut CompilationParams,
+) -> Result<()> {
+  let mut state = IMPORT_META_ENV_DEFINITIONS_MAP
+    .entry(compilation.id())
+    .or_default();
+  let serialized = match &state.serialized {
+    Some(serialized) => serialized.clone(),
+    None => {
+      let serialized = serialize_import_meta_env_definitions(&state.definitions);
+      state.serialized = Some(serialized.clone());
+      serialized
+    }
+  };
+  compilation
+    .value_cache_versions
+    .insert(IMPORT_META_ENV_VALUE_DEP_KEY.to_string(), serialized);
+
+  Ok(())
+}
+
 #[plugin_hook(NormalModuleFactoryParser for DefinePlugin, tracing=false)]
 async fn nmf_parser(
   &self,
@@ -121,8 +172,19 @@ impl Plugin for DefinePlugin {
     "rspack.DefinePlugin"
   }
 
+  fn clear_cache(&self, id: CompilationId) {
+    remove_import_meta_env_definitions(id);
+  }
+
   fn apply(&self, ctx: &mut rspack_core::ApplyContext<'_>) -> Result<()> {
-    ctx.compiler_hooks.compilation.tap(compilation::new(self));
+    ctx
+      .compiler_hooks
+      .compilation
+      .tap(collect_import_meta_env_definitions::new(self));
+    ctx
+      .compiler_hooks
+      .compilation
+      .tap(finalize_import_meta_env_definitions::new(self));
     ctx
       .normal_module_factory_hooks
       .parser

crates/rspack_plugin_javascript/src/parser_plugin/define_plugin/parser.rs

@@ -7,7 +7,7 @@ use std::{
 };
 
 use rspack_util::SpanExt;
-use swc_experimental_ecma_ast::{Expr, Ident, MemberExpr, UnaryExpr};
+use swc_experimental_ecma_ast::{Expr, Ident, MemberExpr, Span, UnaryExpr};
 
 use super::{VALUE_DEP_PREFIX, utils::gen_const_dep, walk_data::WalkData};
 use crate::{
@@ -42,6 +42,24 @@ impl DefineParserPlugin {
     }
   }
 
+  fn add_destructuring_value_dependencies(
+    &self,
+    parser: &mut JavascriptParser,
+    key: &str,
+    span: Span,
+  ) {
+    let Some(properties) = parser
+      .destructuring_assignment_properties
+      .get(&span)
+      .cloned()
+    else {
+      return;
+    };
+    for prop in properties.iter() {
+      self.add_value_dependency(parser, &format!("{key}.{}", prop.id));
+    }
+  }
+
   fn get_define_record(&self, for_name: &str) -> Option<&DefineRecord> {
     self
       .walk_data
@@ -170,6 +188,10 @@ impl<'p, 'a> JavascriptParserPlugin<'p, 'a> for DefineParserPlugin {
         || self
           .walk_data
           .object_define_record
+          .contains_key(info.name.as_str())
+        || self
+          .walk_data
+          .destructuring_define_record
           .contains_key(info.name.as_str()))
     {
       return Some(true);
@@ -209,6 +231,19 @@ impl<'p, 'a> JavascriptParserPlugin<'p, 'a> for DefineParserPlugin {
         span.real_hi(),
         for_name,
       );
+    } else if let Some(record) = self.walk_data.destructuring_define_record.get(for_name)
+      && let Some(on_expression) = &record.on_expression
+    {
+      let span = expr.span;
+      self.add_destructuring_value_dependencies(parser, for_name, span);
+      return on_expression(
+        record,
+        parser,
+        span,
+        span.real_lo(),
+        span.real_hi(),
+        for_name,
+      );
     }
     None
   }