Turbopack: Remove undocumented legacy syntax for built-in conditions (e.g. foreign, browser)

Author: bgw

crates/next-core/src/next_config.rs

@@ -1,4 +1,4 @@
-use std::{collections::BTreeSet, str::FromStr, sync::LazyLock};
+use std::sync::LazyLock;
 
 use anyhow::{Context, Result, bail};
 use rustc_hash::FxHashSet;
@@ -670,7 +670,7 @@ impl TryFrom<ConfigConditionItem> for ConditionItem {
     Clone, Debug, PartialEq, Eq, Serialize, Deserialize, TraceRawVcs, NonLocalValue, OperationValue,
 )]
 #[serde(rename_all = "camelCase")]
-pub struct RuleConfigItemOptions {
+pub struct RuleConfigItem {
     pub loaders: Vec<LoaderItem>,
     #[serde(default, alias = "as")]
     pub rename_as: Option<RcStr>,
@@ -687,16 +687,6 @@ pub enum RuleConfigItemOrShortcut {
     Advanced(RuleConfigItem),
 }
 
-#[derive(
-    Clone, Debug, PartialEq, Eq, Serialize, Deserialize, TraceRawVcs, NonLocalValue, OperationValue,
-)]
-#[serde(rename_all = "camelCase", untagged)]
-pub enum RuleConfigItem {
-    Options(RuleConfigItemOptions),
-    LegacyConditional(FxIndexMap<RcStr, RuleConfigItem>),
-    LegacyBoolean(bool),
-}
-
 #[derive(
     Clone, Debug, PartialEq, Eq, Serialize, Deserialize, TraceRawVcs, NonLocalValue, OperationValue,
 )]
@@ -1378,7 +1368,6 @@ impl NextConfig {
     #[turbo_tasks::function]
     pub async fn webpack_rules(
         &self,
-        active_conditions: BTreeSet<WebpackLoaderBuiltinCondition>,
         project_path: FileSystemPath,
     ) -> Result<Vc<OptionWebpackRules>> {
         let Some(turbo_rules) = self.turbopack.as_ref().and_then(|t| t.rules.as_ref()) else {
@@ -1403,43 +1392,6 @@ impl NextConfig {
                         .collect(),
                 )
             }
-            enum FindRuleResult<'a> {
-                Found(&'a RuleConfigItemOptions),
-                NotFound,
-                Break,
-            }
-            // This logic is needed for the `LegacyConditional`/`LegacyBoolean` configuration
-            // syntax. This is technically public syntax, but was never documented and it is
-            // unlikely that anyone is depending on it (outside of some Next.js internals).
-            fn find_rule<'a>(
-                rule: &'a RuleConfigItem,
-                active_conditions: &BTreeSet<WebpackLoaderBuiltinCondition>,
-            ) -> FindRuleResult<'a> {
-                match rule {
-                    RuleConfigItem::Options(rule) => FindRuleResult::Found(rule),
-                    RuleConfigItem::LegacyConditional(map) => {
-                        for (condition, rule) in map.iter() {
-                            let condition = WebpackLoaderBuiltinCondition::from_str(condition);
-                            if let Ok(condition) = condition
-                                && (condition == WebpackLoaderBuiltinCondition::Default
-                                    || active_conditions.contains(&condition))
-                            {
-                                match find_rule(rule, active_conditions) {
-                                    FindRuleResult::Found(rule) => {
-                                        return FindRuleResult::Found(rule);
-                                    }
-                                    FindRuleResult::Break => {
-                                        return FindRuleResult::Break;
-                                    }
-                                    FindRuleResult::NotFound => {}
-                                }
-                            }
-                        }
-                        FindRuleResult::NotFound
-                    }
-                    RuleConfigItem::LegacyBoolean(_) => FindRuleResult::Break,
-                }
-            }
             let config_file_path = || project_path.join(&self.config_file_name);
             match rule {
                 RuleConfigItemOrShortcut::Loaders(loaders) => {
@@ -1452,55 +1404,52 @@ impl NextConfig {
                         },
                     );
                 }
-                RuleConfigItemOrShortcut::Advanced(rule) => {
-                    if let FindRuleResult::Found(RuleConfigItemOptions {
-                        loaders,
-                        rename_as,
-                        condition,
-                    }) = find_rule(rule, &active_conditions)
+                RuleConfigItemOrShortcut::Advanced(RuleConfigItem {
+                    loaders,
+                    rename_as,
+                    condition,
+                }) => {
+                    // If the extension contains a wildcard, and the rename_as does not,
+                    // emit an issue to prevent users from encountering duplicate module names.
+                    if glob.contains("*")
+                        && let Some(rename_as) = rename_as.as_ref()
+                        && !rename_as.contains("*")
                     {
-                        // If the extension contains a wildcard, and the rename_as does not,
-                        // emit an issue to prevent users from encountering duplicate module names.
-                        if glob.contains("*")
-                            && let Some(rename_as) = rename_as.as_ref()
-                            && !rename_as.contains("*")
-                        {
-                            InvalidLoaderRuleRenameAsIssue {
-                                glob: glob.clone(),
+                        InvalidLoaderRuleRenameAsIssue {
+                            glob: glob.clone(),
+                            config_file_path: config_file_path()?,
+                            rename_as: rename_as.clone(),
+                        }
+                        .resolved_cell()
+                        .emit();
+                    }
+
+                    // convert from Next.js-specific condition type to internal Turbopack
+                    // condition type
+                    let condition = if let Some(condition) = condition {
+                        if let Ok(cond) = ConditionItem::try_from(condition.clone()) {
+                            Some(cond)
+                        } else {
+                            InvalidLoaderRuleConditionIssue {
+                                condition: condition.clone(),
                                 config_file_path: config_file_path()?,
-                                rename_as: rename_as.clone(),
                             }
                             .resolved_cell()
                             .emit();
+                            None
                         }
+                    } else {
+                        None
+                    };
 
-                        // convert from Next.js-specific condition type to internal Turbopack
-                        // condition type
-                        let condition = if let Some(condition) = condition {
-                            if let Ok(cond) = ConditionItem::try_from(condition.clone()) {
-                                Some(cond)
-                            } else {
-                                InvalidLoaderRuleConditionIssue {
-                                    condition: condition.clone(),
-                                    config_file_path: config_file_path()?,
-                                }
-                                .resolved_cell()
-                                .emit();
-                                None
-                            }
-                        } else {
-                            None
-                        };
-
-                        rules.insert(
-                            glob.clone(),
-                            LoaderRuleItem {
-                                loaders: transform_loaders(loaders),
-                                rename_as: rename_as.clone(),
-                                condition,
-                            },
-                        );
-                    }
+                    rules.insert(
+                        glob.clone(),
+                        LoaderRuleItem {
+                            loaders: transform_loaders(loaders),
+                            rename_as: rename_as.clone(),
+                            condition,
+                        },
+                    );
                 }
             }
         }
@@ -1963,11 +1912,11 @@ mod tests {
             }
         });
 
-        let rule_config: RuleConfigItemOptions = serde_json::from_value(json_value).unwrap();
+        let rule_config: RuleConfigItem = serde_json::from_value(json_value).unwrap();
 
         assert_eq!(
             rule_config,
-            RuleConfigItemOptions {
+            RuleConfigItem {
                 loaders: vec![],
                 rename_as: Some(rcstr!("*.js")),
                 condition: Some(ConfigConditionItem::All(

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

@@ -196,9 +196,7 @@ pub async fn webpack_loader_options(
     next_config: Vc<NextConfig>,
     builtin_conditions: BTreeSet<WebpackLoaderBuiltinCondition>,
 ) -> Result<Option<ResolvedVc<WebpackLoadersOptions>>> {
-    let mut rules = *next_config
-        .webpack_rules(builtin_conditions.clone(), project_path.clone())
-        .await?;
+    let mut rules = *next_config.webpack_rules(project_path.clone()).await?;
     rules = *maybe_add_sass_loader(next_config.sass_config(), rules.map(|v| *v)).await?;
     if !builtin_conditions.contains(&WebpackLoaderBuiltinCondition::Foreign) {
         rules = *maybe_add_babel_loader(project_path.clone(), rules.map(|v| *v)).await?;

packages/next/src/build/swc/index.ts

@@ -15,7 +15,6 @@ import type {
   TurbopackLoaderItem,
   TurbopackRuleCondition,
   TurbopackRuleConfigItem,
-  TurbopackRuleConfigItemOptions,
   TurbopackRuleConfigItemOrShortcut,
 } from '../../server/config-shared'
 import { isDeepStrictEqual } from 'util'
@@ -836,29 +835,32 @@ function bindingToApi(
 
         for (const key of ruleKeys) {
           nextConfig.turbopack.conditions[`#reactCompiler/${key}`] = {
-            path: key,
-            content:
-              options.compilationMode === 'annotation'
-                ? /['"]use memo['"]/
-                : !options.compilationMode ||
-                    options.compilationMode === 'infer'
-                  ? // Matches declaration or useXXX or </ (closing jsx) or /> (self closing jsx)
-                    /['"]use memo['"]|\Wuse[A-Z]|<\/|\/>/
-                  : undefined,
+            all: [
+              'browser',
+              { not: 'foreign' },
+              {
+                path: key,
+                content:
+                  options.compilationMode === 'annotation'
+                    ? /['"]use memo['"]/
+                    : !options.compilationMode ||
+                        options.compilationMode === 'infer'
+                      ? // Matches declaration or useXXX or </ (closing jsx) or /> (self closing jsx)
+                        /['"]use memo['"]|\Wuse[A-Z]|<\/|\/>/
+                      : undefined,
+              },
+            ],
           }
           nextConfig.turbopack.rules[`#reactCompiler/${key}`] = {
-            browser: {
-              foreign: false,
-              loaders: [
-                getReactCompilerLoader(
-                  reactCompilerOptions,
-                  projectPath,
-                  nextConfig.dev,
-                  /* isServer */ false,
-                  /* reactCompilerExclude */ undefined
-                ),
-              ],
-            },
+            loaders: [
+              getReactCompilerLoader(
+                reactCompilerOptions,
+                projectPath,
+                nextConfig.dev,
+                /* isServer */ false,
+                /* reactCompilerExclude */ undefined
+              ),
+            ],
           }
         }
       }
@@ -1034,23 +1036,11 @@ function bindingToApi(
     ): any {
       if (!rule) return rule
       let serializedRule: any = rule
-      if ('loaders' in rule) {
-        const narrowedRule = rule as TurbopackRuleConfigItemOptions
-        checkLoaderItems(narrowedRule.loaders, glob)
-        if (narrowedRule.condition != null) {
-          serializedRule = {
-            ...rule,
-            condition: serializeRuleCondition(narrowedRule.condition),
-          }
-        }
-      } else {
-        serializedRule = {}
-        for (const [key, value] of Object.entries(rule)) {
-          if (typeof value === 'object' && value) {
-            serializedRule[key] = serializeConfigItem(value, glob)
-          } else {
-            serializedRule[key] = value
-          }
+      checkLoaderItems(rule.loaders, glob)
+      if (rule.condition != null) {
+        serializedRule = {
+          ...rule,
+          condition: serializeRuleCondition(rule.condition),
         }
       }
       return serializedRule

packages/next/src/server/config-schema.ts

@@ -11,7 +11,6 @@ import type {
   DeprecatedExperimentalTurboOptions,
   TurbopackOptions,
   TurbopackRuleConfigItem,
-  TurbopackRuleConfigItemOptions,
   TurbopackRuleConfigItemOrShortcut,
   TurbopackRuleCondition,
   TurbopackLoaderBuiltinCondition,
@@ -135,21 +134,13 @@ const zTurbopackCondition: zod.ZodType<TurbopackRuleCondition> = z.union([
   }),
 ])
 
-const zTurbopackRuleConfigItemOptions: zod.ZodType<TurbopackRuleConfigItemOptions> =
-  z.object({
+const zTurbopackRuleConfigItem: zod.ZodType<TurbopackRuleConfigItem> = z.object(
+  {
     loaders: z.array(zTurbopackLoaderItem),
     as: z.string().optional(),
     condition: zTurbopackCondition.optional(),
-  })
-
-const zTurbopackRuleConfigItem: zod.ZodType<TurbopackRuleConfigItem> = z.union([
-  z.literal(false),
-  z.record(
-    zTurbopackLoaderBuiltinCondition,
-    z.lazy(() => zTurbopackRuleConfigItem)
-  ),
-  zTurbopackRuleConfigItemOptions,
-])
+  }
+)
 
 const zTurbopackRuleConfigItemOrShortcut: zod.ZodType<TurbopackRuleConfigItemOrShortcut> =
   z.union([z.array(zTurbopackLoaderItem), zTurbopackRuleConfigItem])

packages/next/src/server/config-shared.ts

@@ -281,17 +281,12 @@ export type TurbopackRuleCondition =
       content?: RegExp
     }
 
-export type TurbopackRuleConfigItemOptions = {
+export type TurbopackRuleConfigItem = {
   loaders: TurbopackLoaderItem[]
   as?: string
   condition?: TurbopackRuleCondition
 }
 
-export type TurbopackRuleConfigItem =
-  | TurbopackRuleConfigItemOptions
-  | { [condition in TurbopackLoaderBuiltinCondition]?: TurbopackRuleConfigItem }
-  | false
-
 export type TurbopackRuleConfigItemOrShortcut =
   | TurbopackLoaderItem[]
   | TurbopackRuleConfigItem