Turbopack: Merge babel-loader and react-compiler configuration logic to avoid running babel twice

Author: bgw

crates/next-api/src/app.rs

@@ -1337,9 +1337,7 @@ impl AppEndpoint {
 
         // polyfill-nomodule.js is a pre-compiled asset distributed as part of next,
         // load it as a RawModule.
-        let next_package = get_next_package(project.project_path().owned().await?)
-            .owned()
-            .await?;
+        let next_package = get_next_package(project.project_path().owned().await?).await?;
         let polyfill_source =
             FileSource::new(next_package.join("dist/build/polyfills/polyfill-nomodule.js")?);
         let polyfill_output_path = client_chunking_context

crates/next-core/src/next_build.rs

@@ -16,7 +16,7 @@ pub async fn get_postcss_package_mapping(
             .resolved_cell(),
         ImportMapping::PrimaryAlternative(
             rcstr!("postcss"),
-            Some(get_next_package(project_path.clone()).owned().await?),
+            Some(get_next_package(project_path.clone()).await?),
         )
         .resolved_cell(),
     ])

crates/next-core/src/next_config.rs

@@ -736,21 +736,42 @@ pub enum MdxRsOptions {
 #[turbo_tasks::value(shared, operation)]
 #[derive(Clone, Debug)]
 #[serde(rename_all = "camelCase")]
-pub enum ReactCompilerMode {
+pub enum ReactCompilerCompilationMode {
     Infer,
     Annotation,
     All,
 }
 
-/// Subset of react compiler options
+impl Default for ReactCompilerCompilationMode {
+    fn default() -> Self {
+        Self::Infer
+    }
+}
+
 #[turbo_tasks::value(shared, operation)]
 #[derive(Clone, Debug)]
+#[serde(rename_all = "snake_case")]
+pub enum ReactCompilerPanicThreshold {
+    None,
+    CriticalErrors,
+    AllErrors,
+}
+
+impl Default for ReactCompilerPanicThreshold {
+    fn default() -> Self {
+        Self::None
+    }
+}
+
+/// Subset of react compiler options
+#[turbo_tasks::value(shared, operation)]
+#[derive(Clone, Debug, Default)]
 #[serde(rename_all = "camelCase")]
 pub struct ReactCompilerOptions {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub compilation_mode: Option<ReactCompilerMode>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub panic_threshold: Option<RcStr>,
+    #[serde(default)]
+    pub compilation_mode: ReactCompilerCompilationMode,
+    #[serde(default)]
+    pub panic_threshold: ReactCompilerPanicThreshold,
 }
 
 #[derive(
@@ -1303,6 +1324,14 @@ impl NextConfig {
         Ok(config.cell())
     }
 
+    #[turbo_tasks::function]
+    pub async fn config_file_path(
+        &self,
+        project_path: FileSystemPath,
+    ) -> Result<Vc<FileSystemPath>> {
+        Ok(project_path.join(&self.config_file_name)?.cell())
+    }
+
     #[turbo_tasks::function]
     pub fn bundle_pages_router_dependencies(&self) -> Vc<bool> {
         Vc::cell(self.bundle_pages_router_dependencies.unwrap_or_default())
@@ -1387,8 +1416,12 @@ impl NextConfig {
     }
 
     #[turbo_tasks::function]
-    pub async fn webpack_rules(&self, project_path: FileSystemPath) -> Result<Vc<WebpackRules>> {
-        let Some(turbo_rules) = self.turbopack.as_ref().and_then(|t| t.rules.as_ref()) else {
+    pub async fn webpack_rules(
+        self: Vc<Self>,
+        project_path: FileSystemPath,
+    ) -> Result<Vc<WebpackRules>> {
+        let this = self.await?;
+        let Some(turbo_rules) = this.turbopack.as_ref().and_then(|t| t.rules.as_ref()) else {
             return Ok(Vc::cell(Vec::new()));
         };
         if turbo_rules.is_empty() {
@@ -1411,7 +1444,6 @@ impl NextConfig {
                         .collect(),
                 )
             }
-            let config_file_path = || project_path.join(&self.config_file_name);
             for item in &rule_collection.0 {
                 match item {
                     RuleConfigCollectionItem::Shorthand(loaders) => {
@@ -1438,7 +1470,10 @@ impl NextConfig {
                         {
                             InvalidLoaderRuleRenameAsIssue {
                                 glob: glob.clone(),
-                                config_file_path: config_file_path()?,
+                                config_file_path: self
+                                    .config_file_path(project_path.clone())
+                                    .owned()
+                                    .await?,
                                 rename_as: rename_as.clone(),
                             }
                             .resolved_cell()
@@ -1453,7 +1488,10 @@ impl NextConfig {
                             } else {
                                 InvalidLoaderRuleConditionIssue {
                                     condition: condition.clone(),
-                                    config_file_path: config_file_path()?,
+                                    config_file_path: self
+                                        .config_file_path(project_path.clone())
+                                        .owned()
+                                        .await?,
                                 }
                                 .resolved_cell()
                                 .emit();
@@ -1604,18 +1642,12 @@ impl NextConfig {
     }
 
     #[turbo_tasks::function]
-    pub fn react_compiler(&self) -> Vc<OptionalReactCompilerOptions> {
+    pub fn react_compiler_options(&self) -> Vc<OptionalReactCompilerOptions> {
         let options = &self.experimental.react_compiler;
 
         let options = match options {
             Some(ReactCompilerOptionsOrBoolean::Boolean(true)) => {
-                OptionalReactCompilerOptions(Some(
-                    ReactCompilerOptions {
-                        compilation_mode: None,
-                        panic_threshold: None,
-                    }
-                    .resolved_cell(),
-                ))
+                OptionalReactCompilerOptions(Some(ReactCompilerOptions::default().resolved_cell()))
             }
             Some(ReactCompilerOptionsOrBoolean::Option(options)) => OptionalReactCompilerOptions(
                 Some(ReactCompilerOptions { ..options.clone() }.resolved_cell()),

crates/next-core/src/next_import_map.rs

@@ -25,7 +25,7 @@ use crate::{
     embed_js::{VIRTUAL_PACKAGE_NAME, next_js_fs},
     mode::NextMode,
     next_client::context::ClientContextType,
-    next_config::NextConfig,
+    next_config::{NextConfig, OptionFileSystemPath},
     next_edge::unsupported::NextEdgeUnsupportedModuleReplacer,
     next_font::google::{
         GOOGLE_FONTS_INTERNAL_PREFIX, NextFontGoogleCssModuleReplacer,
@@ -710,7 +710,7 @@ async fn insert_next_server_special_aliases(
         ServerContextType::AppSSR { app_dir }
         | ServerContextType::AppRSC { app_dir, .. }
         | ServerContextType::AppRoute { app_dir, .. } => {
-            let next_package = get_next_package(app_dir.clone()).owned().await?;
+            let next_package = get_next_package(app_dir.clone()).await?;
             import_map.insert_exact_alias(
                 rcstr!("styled-jsx"),
                 request_to_import_mapping(next_package.clone(), rcstr!("styled-jsx")),
@@ -1142,7 +1142,7 @@ async fn insert_next_shared_aliases(
         .resolved_cell(),
     );
 
-    let next_package = get_next_package(project_path.clone()).owned().await?;
+    let next_package = get_next_package(project_path.clone()).await?;
     import_map.insert_singleton_alias(rcstr!("@swc/helpers"), next_package.clone());
     import_map.insert_singleton_alias(rcstr!("styled-jsx"), next_package.clone());
     import_map.insert_singleton_alias(rcstr!("next"), project_path.clone());
@@ -1241,19 +1241,28 @@ async fn insert_next_shared_aliases(
     Ok(())
 }
 
+pub async fn get_next_package(context_directory: FileSystemPath) -> Result<FileSystemPath> {
+    try_get_next_package(context_directory)
+        .owned()
+        .await?
+        .context("Next.js package not found")
+}
+
 #[turbo_tasks::function]
-pub async fn get_next_package(context_directory: FileSystemPath) -> Result<Vc<FileSystemPath>> {
+pub async fn try_get_next_package(
+    context_directory: FileSystemPath,
+) -> Result<Vc<OptionFileSystemPath>> {
     let result = resolve(
         context_directory.clone(),
         ReferenceType::CommonJs(CommonJsReferenceSubType::Undefined),
         Request::parse(Pattern::Constant(rcstr!("next/package.json"))),
         node_cjs_resolve_options(context_directory.root().owned().await?),
     );
-    let source = result
-        .first_source()
-        .await?
-        .context("Next.js package not found")?;
-    Ok(source.ident().path().await?.parent().cell())
+    if let Some(source) = &*result.first_source().await? {
+        Ok(Vc::cell(Some(source.ident().path().await?.parent())))
+    } else {
+        Ok(Vc::cell(None))
+    }
 }
 
 pub async fn insert_alias_option<const N: usize>(