feat: support devtool in compiler options builder (#8940)

feat: init

crates/rspack_core/src/options/compiler_options_builder.rs

@@ -9,8 +9,8 @@ use super::{
   ByDependency, CacheOptions, ChunkLoading, ChunkLoadingType, CleanOptions, CompilerOptions,
   Context, CrossOriginLoading, CssAutoGeneratorOptions, CssAutoParserOptions, CssExportsConvention,
   CssGeneratorOptions, CssModuleGeneratorOptions, CssModuleParserOptions, CssParserOptions,
-  DynamicImportMode, EntryDescription, Environment, ExperimentCacheOptions, Experiments, Filename,
-  FilenameTemplate, GeneratorOptions, GeneratorOptionsMap, JavascriptParserOptions,
+  Devtool, DynamicImportMode, EntryDescription, Environment, ExperimentCacheOptions, Experiments,
+  Filename, FilenameTemplate, GeneratorOptions, GeneratorOptionsMap, JavascriptParserOptions,
   JavascriptParserOrder, JavascriptParserUrl, LibraryName, LibraryNonUmdObject, LibraryOptions,
   Mode, ModuleNoParseRules, ModuleOptions, ModuleRule, ModuleRuleEffect, OutputOptions,
   ParserOptions, ParserOptionsMap, PathInfo, PublicPath, Resolve, RspackFuture, RuleSetCondition,
@@ -24,6 +24,12 @@ macro_rules! d {
   }};
 }
 
+macro_rules! w {
+  ($o:expr, $v:expr) => {{
+    $o.get_or_insert($v)
+  }};
+}
+
 macro_rules! f {
   ($o:expr, $v:expr) => {{
     $o.unwrap_or_else($v)
@@ -38,6 +44,8 @@ pub struct CompilerOptionsBuilder {
   context: Option<Context>,
   cache: Option<CacheOptions>,
   mode: Option<Mode>,
+  devtool: Option<Devtool>,
+  profile: Option<bool>,
   bail: Option<bool>,
   experiments: Option<ExperimentsBuilder>,
   module: Option<ModuleOptionsBuilder>,
@@ -79,6 +87,11 @@ impl CompilerOptionsBuilder {
     self
   }
 
+  pub fn devtool(&mut self, devtool: Devtool) -> &mut Self {
+    self.devtool = Some(devtool);
+    self
+  }
+
   pub fn mode(&mut self, mode: Mode) -> &mut Self {
     self.mode = Some(mode);
     self
@@ -89,6 +102,11 @@ impl CompilerOptionsBuilder {
     self
   }
 
+  pub fn profile(&mut self, profile: bool) -> &mut Self {
+    self.profile = Some(profile);
+    self
+  }
+
   pub fn module<V>(&mut self, module: V) -> &mut Self
   where
     V: Into<ModuleOptionsBuilder>,
@@ -115,7 +133,7 @@ impl CompilerOptionsBuilder {
 
   pub fn build(&mut self) -> CompilerOptions {
     let name = self.name.take();
-    let context = self.context.take().unwrap_or_else(|| {
+    let context = f!(self.context.take(), || {
       std::env::current_dir()
         .expect("`current_dir` should be available")
         .assert_utf8()
@@ -124,13 +142,22 @@ impl CompilerOptionsBuilder {
 
     // TODO: support browserlist default target
     let target = f!(self.target.take(), || vec!["web".to_string()]);
-
     let target_properties = get_targets_properties(&target, &context);
+
     let development = matches!(self.mode, Some(Mode::Development));
     let production = matches!(self.mode, Some(Mode::Production) | None);
     let mode = d!(self.mode.take(), Mode::Production);
 
-    let bail = self.bail.unwrap_or(false);
+    // TODO: support entry
+    let _devtool = f!(self.devtool.take(), || {
+      if development {
+        Devtool::Eval
+      } else {
+        Devtool::False
+      }
+    });
+    let profile = d!(self.profile.take(), false);
+    let bail = d!(self.bail.take(), false);
     let cache = d!(self.cache.take(), {
       if development {
         CacheOptions::Memory
@@ -139,31 +166,39 @@ impl CompilerOptionsBuilder {
       }
     });
 
-    let mut experiments = self.apply_experiments(development, production);
+    let mut experiments_builder = f!(self.experiments.take(), Experiments::builder);
+    let mut experiments = experiments_builder.build(development, production);
     // Disable experiments cache if global cache is set to `Disabled`
     if matches!(cache, CacheOptions::Disabled) {
       experiments.cache = ExperimentCacheOptions::Disabled;
     }
 
-    // TODO: support css
-    let css = true;
-    // TODO: support async web assembly
-    let async_web_assembly = false;
-    // TODO: support experiment output module
-    let output_module = Some(false);
-
-    let module = self.apply_module(async_web_assembly, css, Some(&target_properties));
+    let async_web_assembly = experiments_builder
+      .async_web_assembly
+      .expect("should apply default value");
+    let css = experiments_builder.css.expect("should apply default value");
+    let future_defaults = experiments_builder
+      .future_defaults
+      .expect("should apply default value");
+    let output_module = experiments_builder
+      .output_module
+      .expect("should apply default value");
+
+    let module = f!(self.module.take(), ModuleOptions::builder).build(
+      async_web_assembly,
+      css,
+      &target_properties,
+    );
 
-    // TODO: options
-    let entry = self.entry.clone();
-    let output = self.apply_output(
-      context.clone(),
+    let is_affected_by_browserslist = target.iter().any(|t| t.starts_with("browserslist"));
+    let output = f!(self.output.take(), OutputOptions::builder).build(
+      &context,
       output_module,
       Some(&target_properties),
-      target.iter().any(|t| t.starts_with("browserslist")),
+      is_affected_by_browserslist,
       development,
-      &entry,
-      false,
+      &self.entry,
+      future_defaults,
     );
 
     CompilerOptions {
@@ -179,61 +214,12 @@ impl CompilerOptionsBuilder {
       experiments,
       node: Default::default(),
       optimization: Default::default(),
-      profile: Default::default(),
+      profile,
       amd: None,
       bail,
       __references: Default::default(),
     }
   }
-
-  fn apply_module(
-    &mut self,
-    async_web_assembly: bool,
-    css: bool,
-    target_properties: Option<&TargetProperties>,
-  ) -> ModuleOptions {
-    self
-      .module
-      .take()
-      .unwrap_or_else(ModuleOptions::builder)
-      .build(async_web_assembly, css, target_properties)
-  }
-
-  #[allow(clippy::too_many_arguments)]
-  fn apply_output(
-    &mut self,
-    context: Context,
-    output_module: Option<bool>,
-    target_properties: Option<&TargetProperties>,
-    is_affected_by_browserslist: bool,
-    development: bool,
-    entry: &IndexMap<String, EntryDescription>,
-    future_defaults: bool,
-  ) -> OutputOptions {
-    self
-      .output
-      .take()
-      .unwrap_or_else(OutputOptions::builder)
-      .build(
-        context.clone(),
-        output_module,
-        target_properties,
-        is_affected_by_browserslist,
-        development,
-        entry,
-        future_defaults,
-      )
-  }
-
-  fn apply_experiments(&mut self, development: bool, production: bool) -> Experiments {
-    self
-      .experiments
-      .take()
-      .unwrap_or_else(Experiments::builder)
-      .build(development, production)
-  }
-
-  // fn apply_output()
 }
 
 #[derive(Debug, Default)]
@@ -286,7 +272,7 @@ impl ModuleOptionsBuilder {
     &mut self,
     async_web_assembly: bool,
     css: bool,
-    target_properties: Option<&TargetProperties>,
+    target_properties: &TargetProperties,
   ) -> ModuleOptions {
     let parser = self.parser.get_or_insert(ParserOptionsMap::default());
 
@@ -344,7 +330,7 @@ impl ModuleOptionsBuilder {
       parser.insert("css/module".to_string(), css_module_parser_options);
 
       // CSS generator options
-      let exports_only = target_properties.map_or(true, |t| !t.document());
+      let exports_only = !target_properties.document();
 
       generator.insert(
         "css".to_string(),
@@ -926,18 +912,17 @@ impl OutputOptionsBuilder {
     self
   }
 
-  #[allow(clippy::too_many_arguments)]
+  #[allow(clippy::too_many_arguments, clippy::fn_params_excessive_bools)]
   pub fn build(
     &mut self,
-    context: Context,
-    output_module: Option<bool>,
+    context: &Context,
+    output_module: bool,
     target_properties: Option<&TargetProperties>,
     is_affected_by_browserslist: bool,
     development: bool,
     _entry: &IndexMap<String, EntryDescription>,
     _future_defaults: bool,
   ) -> OutputOptions {
-    let output_module = output_module.unwrap_or(false);
     let tp = target_properties;
 
     let path = f!(self.path.take(), || { context.as_path().join("dist") });
@@ -1321,6 +1306,10 @@ pub struct ExperimentsBuilder {
   top_level_await: Option<bool>,
   rspack_future: Option<RspackFuture>,
   cache: Option<ExperimentCacheOptions>,
+
+  // Builder specific
+  output_module: Option<bool>,
+  future_defaults: Option<bool>,
   css: Option<bool>,
   async_web_assembly: Option<bool>,
 }
@@ -1351,6 +1340,11 @@ impl ExperimentsBuilder {
     self
   }
 
+  pub fn future_defaults(&mut self, future_defaults: bool) -> &mut Self {
+    self.future_defaults = Some(future_defaults);
+    self
+  }
+
   pub fn css(&mut self, css: bool) -> &mut Self {
     self.css = Some(css);
     self
@@ -1371,14 +1365,20 @@ impl ExperimentsBuilder {
       }
     });
     let top_level_await = d!(self.top_level_await, true);
-    let rspack_future = d!(self.rspack_future.take(), RspackFuture {});
     let cache = f!(self.cache.take(), || {
       if development {
         ExperimentCacheOptions::Memory
       } else {
         ExperimentCacheOptions::Disabled
       }
     });
+    let rspack_future = d!(self.rspack_future.take(), RspackFuture {});
+
+    // Builder specific
+    let future_defaults = w!(self.future_defaults, false);
+    w!(self.css, *future_defaults);
+    w!(self.async_web_assembly, *future_defaults);
+    w!(self.output_module, false);
 
     Experiments {
       layers,