refactor: check neutral platform (#12534)

* refactor: add platform to compiler

* refactor: add platform to compiler

Author: LingyuCoder

crates/node_binding/napi-binding.d.ts

@@ -326,7 +326,7 @@ export declare class JsCompilation {
 }
 
 export declare class JsCompiler {
-  constructor(compilerPath: string, options: RawOptions, builtinPlugins: Array<BuiltinPlugin>, registerJsTaps: RegisterJsTaps, outputFilesystem: ThreadsafeNodeFS, intermediateFilesystem: ThreadsafeNodeFS | undefined | null, inputFilesystem: ThreadsafeNodeFS | undefined | null, resolverFactoryReference: JsResolverFactory, unsafeFastDrop: boolean)
+  constructor(compilerPath: string, options: RawOptions, builtinPlugins: Array<BuiltinPlugin>, registerJsTaps: RegisterJsTaps, outputFilesystem: ThreadsafeNodeFS, intermediateFilesystem: ThreadsafeNodeFS | undefined | null, inputFilesystem: ThreadsafeNodeFS | undefined | null, resolverFactoryReference: JsResolverFactory, unsafeFastDrop: boolean, platform: RawCompilerPlatform)
   setNonSkippableRegisters(kinds: Array<RegisterJsTapKind>): void
   /** Build with the given option passed to the constructor */
   build(callback: (err: null | Error) => void): void
@@ -1838,6 +1838,15 @@ export interface RawCircularDependencyRspackPluginOptions {
   onEnd?: () => void
 }
 
+export interface RawCompilerPlatform {
+  web?: boolean | null
+  browser?: boolean | null
+  webworker?: boolean | null
+  node?: boolean | null
+  nwjs?: boolean | null
+  electron?: boolean | null
+}
+
 export interface RawConsumeOptions {
   key: string
   import?: string

crates/rspack/src/builder/builder_context.rs

@@ -1,8 +1,8 @@
 #![allow(clippy::enum_variant_names)]
 use enum_tag::EnumTag;
 use rspack_core::{
-  BoxPlugin, ChunkLoadingType, CompilerOptions, EntryOptions, ExternalItem, ExternalType,
-  LibraryType, PluginExt as _, WasmLoadingType,
+  BoxPlugin, ChunkLoadingType, CompilerOptions, CompilerPlatform, EntryOptions, ExternalItem,
+  ExternalType, LibraryType, PluginExt as _, WasmLoadingType,
 };
 
 /// Options of builtin plugins
@@ -100,9 +100,15 @@ pub(super) enum BuiltinPluginOptions {
 #[derive(Default, Debug)]
 pub struct BuilderContext {
   pub(super) plugins: Vec<BuiltinPluginOptions>,
+  pub(super) platform: CompilerPlatform,
 }
 
 impl BuilderContext {
+  /// Take platform from the context
+  pub fn take_platform(&mut self) -> CompilerPlatform {
+    std::mem::take(&mut self.platform)
+  }
+
   /// Take plugins from the context.
   ///
   /// The plugins are sorted by their tag.

crates/rspack/src/builder/mod.rs

@@ -38,10 +38,10 @@ use externals::ExternalsPresets;
 use indexmap::IndexMap;
 use rspack_core::{
   AssetParserDataUrl, AssetParserDataUrlOptions, AssetParserOptions, BoxPlugin, ByDependency,
-  CacheOptions, ChunkLoading, ChunkLoadingType, CleanOptions, Compiler, CompilerOptions, Context,
-  CrossOriginLoading, CssAutoGeneratorOptions, CssAutoParserOptions, CssExportsConvention,
-  CssGeneratorOptions, CssModuleGeneratorOptions, CssModuleParserOptions, CssParserOptions,
-  DynamicImportMode, EntryDescription, EntryOptions, EntryRuntime, Environment,
+  CacheOptions, ChunkLoading, ChunkLoadingType, CleanOptions, Compiler, CompilerOptions,
+  CompilerPlatform, Context, CrossOriginLoading, CssAutoGeneratorOptions, CssAutoParserOptions,
+  CssExportsConvention, CssGeneratorOptions, CssModuleGeneratorOptions, CssModuleParserOptions,
+  CssParserOptions, DynamicImportMode, EntryDescription, EntryOptions, EntryRuntime, Environment,
   ExperimentCacheOptions, Experiments, ExternalItem, ExternalType, Filename, GeneratorOptions,
   GeneratorOptionsMap, JavascriptParserCommonjsExportsOption, JavascriptParserCommonjsOptions,
   JavascriptParserOptions, JavascriptParserOrder, JavascriptParserUrl, JsonGeneratorOptions,
@@ -448,6 +448,7 @@ impl CompilerBuilder {
     let mut builder_context = BuilderContext::default();
     let compiler_options = self.options_builder.build(&mut builder_context)?;
     let mut plugins = builder_context.take_plugins(&compiler_options);
+    let platform = builder_context.take_platform();
     plugins.append(&mut self.plugins);
 
     let input_filesystem = self.input_filesystem.take();
@@ -465,6 +466,7 @@ impl CompilerBuilder {
       None,
       None,
       compiler_context,
+      Arc::new(platform),
     ))
   }
 }
@@ -913,6 +915,7 @@ impl CompilerOptionsBuilder {
       vec!["web".to_string()]
     });
     let target_properties = get_targets_properties(&target, &context);
+    builder_context.platform = CompilerPlatform::from(&target_properties);
 
     let development = matches!(self.mode, Some(Mode::Development));
     let production = matches!(self.mode, Some(Mode::Production) | None);

crates/rspack/src/builder/target.rs

@@ -1,5 +1,5 @@
 use rspack_browserslist::load_browserslist;
-use rspack_core::Context;
+use rspack_core::{CompilerPlatform, Context};
 
 /// Targets type.
 pub type Targets = Vec<String>;
@@ -128,6 +128,19 @@ impl TargetProperties {
   }
 }
 
+impl From<&TargetProperties> for CompilerPlatform {
+  fn from(value: &TargetProperties) -> Self {
+    Self {
+      web: value.web,
+      browser: value.browser,
+      webworker: value.webworker,
+      node: value.node,
+      nwjs: value.nwjs,
+      electron: value.electron,
+    }
+  }
+}
+
 fn version_dependent(
   major: u32,
   minor: Option<u32>,

crates/rspack/tests/snapshots/defaults__default_options-2.snap

@@ -52,4 +52,24 @@ BuilderContext {
         EnsureChunkConditionsPlugin,
         WorkerPlugin,
     ],
+    platform: CompilerPlatform {
+        web: Some(
+            true,
+        ),
+        browser: Some(
+            true,
+        ),
+        webworker: Some(
+            false,
+        ),
+        node: Some(
+            false,
+        ),
+        nwjs: Some(
+            false,
+        ),
+        electron: Some(
+            false,
+        ),
+    },
 }

crates/rspack_binding_api/src/lib.rs

@@ -82,6 +82,7 @@ mod normal_module_factory;
 mod options;
 mod panic;
 mod path_data;
+mod platform;
 mod plugins;
 mod raw_options;
 mod resolver;
@@ -109,7 +110,8 @@ use napi::{CallContext, bindgen_prelude::*};
 pub use raw_options::{CustomPluginBuilder, register_custom_plugin};
 use rspack_collections::UkeyMap;
 use rspack_core::{
-  BoxDependency, Compilation, CompilerId, EntryOptions, ModuleIdentifier, PluginExt,
+  BoxDependency, Compilation, CompilerId, CompilerPlatform, EntryOptions, ModuleIdentifier,
+  PluginExt,
 };
 use rspack_error::Diagnostic;
 use rspack_fs::{IntermediateFileSystem, NativeFileSystem, ReadableFileSystem};
@@ -127,6 +129,7 @@ use crate::{
   error::{ErrorCode, RspackResultToNapiResultExt},
   fs_node::{HybridFileSystem, NodeFileSystem, ThreadsafeNodeFS},
   module::ModuleObject,
+  platform::RawCompilerPlatform,
   plugins::{
     JsCleanupPlugin, JsHooksAdapterPlugin, RegisterJsTapKind, RegisterJsTaps, buildtime_plugins,
   },
@@ -188,6 +191,7 @@ impl JsCompiler {
     input_filesystem: Option<ThreadsafeNodeFS>,
     mut resolver_factory_reference: Reference<JsResolverFactory>,
     unsafe_fast_drop: bool,
+    platform: RawCompilerPlatform,
   ) -> Result<Self> {
     tracing::info!(name:"rspack_version", version = rspack_workspace::rspack_pkg_version!());
     tracing::info!(name:"raw_options", options=?&options);
@@ -296,6 +300,8 @@ impl JsCompiler {
           None
         };
 
+      let platform = Arc::new(CompilerPlatform::from(platform));
+
       let rspack = rspack_core::Compiler::new(
         compiler_path,
         compiler_options,
@@ -311,6 +317,7 @@ impl JsCompiler {
         Some(resolver_factory),
         Some(loader_resolver_factory),
         Some(compiler_context.clone()),
+        platform,
       );
 
       Ok(Self {

crates/rspack_binding_api/src/platform.rs

@@ -0,0 +1,34 @@
+use napi::{Either, bindgen_prelude::Null};
+use napi_derive::napi;
+use rspack_core::CompilerPlatform;
+
+#[derive(Debug)]
+#[napi(object, object_to_js = false)]
+pub struct RawCompilerPlatform {
+  pub web: Option<Either<bool, Null>>,
+  pub browser: Option<Either<bool, Null>>,
+  pub webworker: Option<Either<bool, Null>>,
+  pub node: Option<Either<bool, Null>>,
+  pub nwjs: Option<Either<bool, Null>>,
+  pub electron: Option<Either<bool, Null>>,
+}
+
+impl From<RawCompilerPlatform> for CompilerPlatform {
+  fn from(value: RawCompilerPlatform) -> Self {
+    Self {
+      web: from_raw_platform(value.web),
+      browser: from_raw_platform(value.browser),
+      webworker: from_raw_platform(value.webworker),
+      node: from_raw_platform(value.node),
+      nwjs: from_raw_platform(value.nwjs),
+      electron: from_raw_platform(value.electron),
+    }
+  }
+}
+
+fn from_raw_platform(v: Option<Either<bool, Null>>) -> Option<bool> {
+  match v {
+    Some(Either::A(v)) => Some(v),
+    _ => None,
+  }
+}

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

@@ -6,7 +6,7 @@ use rustc_hash::FxHashMap as HashMap;
 
 use super::BuildModuleGraphArtifact;
 use crate::{
-  Compilation, CompilationId, CompilerId, CompilerOptions, DependencyTemplate,
+  Compilation, CompilationId, CompilerId, CompilerOptions, CompilerPlatform, DependencyTemplate,
   DependencyTemplateType, DependencyType, ModuleFactory, ResolverFactory, RuntimeTemplate,
   SharedPluginDriver,
   incremental::Incremental,
@@ -25,6 +25,7 @@ pub struct TaskContext {
   pub intermediate_fs: Arc<dyn IntermediateFileSystem>,
   pub output_fs: Arc<dyn WritableFileSystem>,
   pub compiler_options: Arc<CompilerOptions>,
+  pub platform: Arc<CompilerPlatform>,
   pub resolver_factory: Arc<ResolverFactory>,
   pub loader_resolver_factory: Arc<ResolverFactory>,
   pub old_cache: Arc<OldCache>,
@@ -43,6 +44,7 @@ impl TaskContext {
       plugin_driver: compilation.plugin_driver.clone(),
       buildtime_plugin_driver: compilation.buildtime_plugin_driver.clone(),
       compiler_options: compilation.options.clone(),
+      platform: compilation.platform.clone(),
       resolver_factory: compilation.resolver_factory.clone(),
       loader_resolver_factory: compilation.loader_resolver_factory.clone(),
       old_cache: compilation.old_cache.clone(),
@@ -67,6 +69,7 @@ impl TaskContext {
     let mut compilation = Compilation::new(
       self.compiler_id,
       self.compiler_options.clone(),
+      self.platform.clone(),
       self.plugin_driver.clone(),
       self.buildtime_plugin_driver.clone(),
       self.resolver_factory.clone(),

crates/rspack_core/src/compilation/mod.rs

@@ -45,7 +45,7 @@ use crate::{
   ChunkByUkey, ChunkContentHash, ChunkGraph, ChunkGroupByUkey, ChunkGroupUkey, ChunkHashesArtifact,
   ChunkKind, ChunkNamedIdArtifact, ChunkRenderArtifact, ChunkRenderCacheArtifact,
   ChunkRenderResult, ChunkUkey, CodeGenerationJob, CodeGenerationResult, CodeGenerationResults,
-  CompilationLogger, CompilationLogging, CompilerOptions, ConcatenationScope,
+  CompilationLogger, CompilationLogging, CompilerOptions, CompilerPlatform, ConcatenationScope,
   DependenciesDiagnosticsArtifact, DependencyCodeGeneration, DependencyTemplate,
   DependencyTemplateType, DependencyType, DerefOption, Entry, EntryData, EntryOptions,
   EntryRuntime, Entrypoint, ExecuteModuleId, Filename, ImportPhase, ImportVarMap,
@@ -218,6 +218,7 @@ pub struct Compilation {
   pub hot_index: u32,
   pub records: Option<CompilationRecords>,
   pub options: Arc<CompilerOptions>,
+  pub platform: Arc<CompilerPlatform>,
   pub entries: Entry,
   pub global_entry: EntryData,
   // module graph partial used in seal phase
@@ -337,6 +338,7 @@ impl Compilation {
   pub fn new(
     compiler_id: CompilerId,
     options: Arc<CompilerOptions>,
+    platform: Arc<CompilerPlatform>,
     plugin_driver: SharedPluginDriver,
     buildtime_plugin_driver: SharedPluginDriver,
     resolver_factory: Arc<ResolverFactory>,
@@ -360,6 +362,7 @@ impl Compilation {
       runtime_template: RuntimeTemplate::new(options.clone()),
       records,
       options: options.clone(),
+      platform,
       seal_module_graph_partial: None,
       dependency_factories: Default::default(),
       dependency_templates: Default::default(),

crates/rspack_core/src/compiler/mod.rs

@@ -14,9 +14,9 @@ use tracing::instrument;
 
 pub use self::rebuild::CompilationRecords;
 use crate::{
-  BoxPlugin, CleanOptions, Compilation, CompilationAsset, CompilerOptions, ContextModuleFactory,
-  Filename, KeepPattern, Logger, NormalModuleFactory, PluginDriver, ResolverFactory,
-  SharedPluginDriver,
+  BoxPlugin, CleanOptions, Compilation, CompilationAsset, CompilerOptions, CompilerPlatform,
+  ContextModuleFactory, Filename, KeepPattern, Logger, NormalModuleFactory, PluginDriver,
+  ResolverFactory, SharedPluginDriver,
   cache::{Cache, new_cache},
   compilation::build_module_graph::ModuleExecutor,
   fast_set, include_hash,
@@ -92,6 +92,7 @@ pub struct Compiler {
   /// emitted asset versions
   /// the key of HashMap is filename, the value of HashMap is version
   pub emitted_asset_versions: HashMap<String, String>,
+  pub platform: Arc<CompilerPlatform>,
   compiler_context: Arc<CompilerContext>,
 }
 
@@ -110,6 +111,7 @@ impl Compiler {
     resolver_factory: Option<Arc<ResolverFactory>>,
     loader_resolver_factory: Option<Arc<ResolverFactory>>,
     compiler_context: Option<Arc<CompilerContext>>,
+    platform: Arc<CompilerPlatform>,
   ) -> Self {
     #[cfg(debug_assertions)]
     {
@@ -162,6 +164,7 @@ impl Compiler {
       compilation: Compilation::new(
         id,
         options,
+        platform.clone(),
         plugin_driver.clone(),
         buildtime_plugin_driver.clone(),
         resolver_factory.clone(),
@@ -188,6 +191,7 @@ impl Compiler {
       old_cache,
       emitted_asset_versions: Default::default(),
       input_filesystem,
+      platform,
       compiler_context,
     }
   }
@@ -219,6 +223,7 @@ impl Compiler {
       Compilation::new(
         self.id,
         self.options.clone(),
+        self.platform.clone(),
         self.plugin_driver.clone(),
         self.buildtime_plugin_driver.clone(),
         self.resolver_factory.clone(),