Turbopack: Remove fragile heuristics for detecting manually-configured sass or babel loaders, configure rules as a vec and not a map

Author: bgw

crates/next-core/src/next_client/context.rs

@@ -248,11 +248,11 @@ pub async fn get_client_module_options_context(
     let mut foreign_conditions = loader_conditions.clone();
     foreign_conditions.insert(WebpackLoaderBuiltinCondition::Foreign);
     let foreign_enable_webpack_loaders =
-        webpack_loader_options(project_path.clone(), next_config, foreign_conditions).await?;
+        *webpack_loader_options(project_path.clone(), next_config, foreign_conditions).await?;
 
     // Now creates a webpack rules that applies to all code.
     let enable_webpack_loaders =
-        webpack_loader_options(project_path.clone(), next_config, loader_conditions).await?;
+        *webpack_loader_options(project_path.clone(), next_config, loader_conditions).await?;
 
     let tree_shaking_mode_for_user_code = *next_config
         .tree_shaking_mode_for_user_code(next_mode.is_development())

crates/next-core/src/next_config.rs

@@ -14,7 +14,7 @@ use turbo_tasks_env::{EnvMap, ProcessEnv};
 use turbo_tasks_fetch::FetchClient;
 use turbo_tasks_fs::FileSystemPath;
 use turbopack::module_options::{
-    ConditionItem, ConditionPath, LoaderRuleItem, OptionWebpackRules,
+    ConditionItem, ConditionPath, LoaderRuleItem, WebpackRules,
     module_options_context::{MdxTransformOptions, OptionWebpackConditions},
 };
 use turbopack_core::{
@@ -868,6 +868,13 @@ pub struct ExperimentalConfig {
     turbopack_tree_shaking: Option<bool>,
     turbopack_scope_hoisting: Option<bool>,
     turbopack_use_system_tls_certs: Option<bool>,
+    /// Disable automatic configuration of the sass loader.
+    #[serde(default)]
+    turbopack_disable_builtin_sass: Option<bool>,
+    /// Disable automatic configuration of the babel loader when a babel configuration file is
+    /// present.
+    #[serde(default)]
+    turbopack_disable_builtin_babel: Option<bool>,
     // Whether to enable the global-not-found convention
     global_not_found: Option<bool>,
     /// Defaults to false in development mode, true in production mode.
@@ -1377,14 +1384,14 @@ impl NextConfig {
         &self,
         active_conditions: BTreeSet<WebpackLoaderBuiltinCondition>,
         project_path: FileSystemPath,
-    ) -> Result<Vc<OptionWebpackRules>> {
+    ) -> Result<Vc<WebpackRules>> {
         let Some(turbo_rules) = self.turbopack.as_ref().and_then(|t| t.rules.as_ref()) else {
-            return Ok(Vc::cell(None));
+            return Ok(Vc::cell(Vec::new()));
         };
         if turbo_rules.is_empty() {
-            return Ok(Vc::cell(None));
+            return Ok(Vc::cell(Vec::new()));
         }
-        let mut rules = FxIndexMap::default();
+        let mut rules = Vec::new();
         for (glob, rule) in turbo_rules.iter() {
             fn transform_loaders(loaders: &[LoaderItem]) -> ResolvedVc<WebpackLoaderItems> {
                 ResolvedVc::cell(
@@ -1440,14 +1447,14 @@ impl NextConfig {
             let config_file_path = || project_path.join(&self.config_file_name);
             match rule {
                 RuleConfigItemOrShortcut::Loaders(loaders) => {
-                    rules.insert(
+                    rules.push((
                         glob.clone(),
                         LoaderRuleItem {
                             loaders: transform_loaders(loaders),
                             rename_as: None,
                             condition: None,
                         },
-                    );
+                    ));
                 }
                 RuleConfigItemOrShortcut::Advanced(rule) => {
                     if let FindRuleResult::Found(RuleConfigItemOptions {
@@ -1489,19 +1496,19 @@ impl NextConfig {
                             None
                         };
 
-                        rules.insert(
+                        rules.push((
                             glob.clone(),
                             LoaderRuleItem {
                                 loaders: transform_loaders(loaders),
                                 rename_as: rename_as.clone(),
                                 condition,
                             },
-                        );
+                        ));
                     }
                 }
             }
         }
-        Ok(Vc::cell(Some(ResolvedVc::cell(rules))))
+        Ok(Vc::cell(rules))
     }
 
     #[turbo_tasks::function]
@@ -1638,6 +1645,16 @@ impl NextConfig {
         })
     }
 
+    #[turbo_tasks::function]
+    pub fn experimental_turbopack_disable_builtin_babel(&self) -> Vc<Option<bool>> {
+        Vc::cell(self.experimental.turbopack_disable_builtin_babel)
+    }
+
+    #[turbo_tasks::function]
+    pub fn experimental_turbopack_disable_builtin_sass(&self) -> Vc<Option<bool>> {
+        Vc::cell(self.experimental.turbopack_disable_builtin_sass)
+    }
+
     #[turbo_tasks::function]
     pub fn react_compiler(&self) -> Vc<OptionalReactCompilerOptions> {
         let options = &self.experimental.react_compiler;

crates/next-core/src/next_server/context.rs

@@ -493,11 +493,11 @@ pub async fn get_server_module_options_context(
     let mut foreign_conditions = loader_conditions.clone();
     foreign_conditions.insert(WebpackLoaderBuiltinCondition::Foreign);
     let foreign_enable_webpack_loaders =
-        webpack_loader_options(project_path.clone(), next_config, foreign_conditions).await?;
+        *webpack_loader_options(project_path.clone(), next_config, foreign_conditions).await?;
 
     // Now creates a webpack rules that applies to all code.
     let enable_webpack_loaders =
-        webpack_loader_options(project_path.clone(), next_config, loader_conditions).await?;
+        *webpack_loader_options(project_path.clone(), next_config, loader_conditions).await?;
 
     let tree_shaking_mode_for_user_code = *next_config
         .tree_shaking_mode_for_user_code(next_mode.is_development())

crates/next-core/src/next_shared/webpack_rules/babel.rs

@@ -1,15 +1,20 @@
+use std::sync::LazyLock;
+
 use anyhow::Result;
-use turbo_rcstr::rcstr;
+use regex::Regex;
+use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{ResolvedVc, Vc};
 use turbo_tasks_fs::{self, FileSystemEntryType, FileSystemPath};
-use turbopack::module_options::{LoaderRuleItem, OptionWebpackRules, WebpackRules};
+use turbopack::module_options::LoaderRuleItem;
 use turbopack_core::{
     issue::{Issue, IssueExt, IssueSeverity, IssueStage, OptionStyledString, StyledString},
     reference_type::{CommonJsReferenceSubType, ReferenceType},
     resolve::{node::node_cjs_resolve_options, parse::Request, pattern::Pattern, resolve},
 };
 use turbopack_node::transforms::webpack::WebpackLoaderItem;
 
+// https://babeljs.io/docs/config-files
+// TODO: Also support a `babel` key in a package.json file
 const BABEL_CONFIG_FILES: &[&str] = &[
     ".babelrc",
     ".babelrc.json",
@@ -22,94 +27,71 @@ const BABEL_CONFIG_FILES: &[&str] = &[
     "babel.config.cjs",
 ];
 
-/// If the user has a babel configuration file (see list above) alongside their
-/// `next.config.js` configuration, automatically add `babel-loader` as a
-/// webpack loader for each eligible file type if it doesn't already exist.
-#[turbo_tasks::function]
-pub async fn maybe_add_babel_loader(
-    project_root: FileSystemPath,
-    webpack_rules: Option<ResolvedVc<WebpackRules>>,
-) -> Result<Vc<OptionWebpackRules>> {
-    let has_babel_config = {
-        let mut has_babel_config = false;
-        for &filename in BABEL_CONFIG_FILES {
-            let filetype = *project_root.join(filename)?.get_type().await?;
-            if matches!(filetype, FileSystemEntryType::File) {
-                has_babel_config = true;
-                break;
-            }
-        }
-        has_babel_config
-    };
+static BABEL_LOADER_RE: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"(^|/)@?babel[-/]loader($|/|\.)").unwrap());
 
-    if has_babel_config {
-        let mut rules = if let Some(webpack_rules) = webpack_rules {
-            webpack_rules.owned().await?
-        } else {
-            Default::default()
-        };
-        let mut has_emitted_babel_resolve_issue = false;
-        let mut has_changed = false;
-        for pattern in ["*.js", "*.jsx", "*.ts", "*.tsx", "*.cjs", "*.mjs"] {
-            let rule = rules.get_mut(pattern);
-            let has_babel_loader = if let Some(rule) = rule.as_ref() {
-                rule.loaders
-                    .await?
-                    .iter()
-                    .any(|c| c.loader == "babel-loader")
-            } else {
-                false
-            };
-
-            if !has_babel_loader {
-                if !has_emitted_babel_resolve_issue
-                    && !*is_babel_loader_available(project_root.clone()).await?
-                {
-                    BabelIssue {
-                        path: project_root.clone(),
-                        title: StyledString::Text(rcstr!(
-                            "Unable to resolve babel-loader, but a babel config is present"
-                        ))
-                        .resolved_cell(),
-                        description: StyledString::Text(rcstr!(
-                            "Make sure babel-loader is installed via your package manager."
-                        ))
-                        .resolved_cell(),
-                        severity: IssueSeverity::Fatal,
-                    }
-                    .resolved_cell()
-                    .emit();
-
-                    has_emitted_babel_resolve_issue = true;
-                }
+pub async fn detect_likely_babel_loader(
+    webpack_rules: &[(RcStr, LoaderRuleItem)],
+) -> Result<Option<RcStr>> {
+    for (glob, rule) in webpack_rules {
+        if rule
+            .loaders
+            .await?
+            .iter()
+            .any(|item| BABEL_LOADER_RE.is_match(&item.loader))
+        {
+            return Ok(Some(glob.clone()));
+        }
+    }
+    Ok(None)
+}
 
-                let loader = WebpackLoaderItem {
-                    loader: rcstr!("babel-loader"),
-                    options: Default::default(),
-                };
-                if let Some(rule) = rule {
-                    let mut loaders = rule.loaders.owned().await?;
-                    loaders.push(loader);
-                    rule.loaders = ResolvedVc::cell(loaders);
-                } else {
-                    rules.insert(
-                        pattern.into(),
-                        LoaderRuleItem {
-                            loaders: ResolvedVc::cell(vec![loader]),
-                            rename_as: Some(rcstr!("*")),
-                            condition: None,
-                        },
-                    );
-                }
-                has_changed = true;
-            }
+/// If the user has a babel configuration file (see list above) alongside their `next.config.js`
+/// configuration, automatically add `babel-loader` as a webpack loader for each eligible file type
+/// if it doesn't already exist.
+pub async fn get_babel_loader_rules(
+    project_root: FileSystemPath,
+) -> Result<Vec<(RcStr, LoaderRuleItem)>> {
+    let mut has_babel_config = false;
+    for &filename in BABEL_CONFIG_FILES {
+        let filetype = *project_root.join(filename)?.get_type().await?;
+        if matches!(filetype, FileSystemEntryType::File) {
+            has_babel_config = true;
+            break;
         }
+    }
+    if !has_babel_config {
+        return Ok(Vec::new());
+    }
 
-        if has_changed {
-            return Ok(Vc::cell(Some(ResolvedVc::cell(rules))));
+    if !*is_babel_loader_available(project_root.clone()).await? {
+        BabelIssue {
+            path: project_root.clone(),
+            title: StyledString::Text(rcstr!(
+                "Unable to resolve babel-loader, but a babel config is present"
+            ))
+            .resolved_cell(),
+            description: StyledString::Text(rcstr!(
+                "Make sure babel-loader is installed via your package manager."
+            ))
+            .resolved_cell(),
+            severity: IssueSeverity::Fatal,
         }
+        .resolved_cell()
+        .emit();
     }
-    Ok(Vc::cell(webpack_rules))
+
+    Ok(vec![(
+        rcstr!("*.{js,jsx,ts,tsx,cjs,mjs,mts,cts}"),
+        LoaderRuleItem {
+            loaders: ResolvedVc::cell(vec![WebpackLoaderItem {
+                loader: rcstr!("babel-loader"),
+                options: Default::default(),
+            }]),
+            rename_as: Some(rcstr!("*")),
+            condition: None,
+        },
+    )])
 }
 
 #[turbo_tasks::function]