perf(turbopack): Reduce needless allocations for SWC plugins (#75275)

kdy1 · web-flow · commit e3e337b78c85 · 2025-01-24T15:44:40.000+01:00
### What? Reduce allocations for SWC plugins, by applying swc-project/plugins#393 ### Why? Those are actually noop so they should not allocate too much.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -101,10 +101,10 @@ testing = { version = "5.0.0" }
 browserslist-rs = { version = "0.16.0" }
 miette = { version = "5.10.0", features = ["fancy"] }
 mdxjs = "0.2.15"
-modularize_imports = { version = "0.70.1" }
-styled_components = { version = "0.98.2" }
-styled_jsx = { version = "0.75.2" }
-swc_emotion = { version = "0.74.2" }
+modularize_imports = { version = "0.71.0" }
+styled_components = { version = "0.99.0" }
+styled_jsx = { version = "0.76.0" }
+swc_emotion = { version = "0.75.0" }
 swc_relay = { version = "0.46.1" }
 
 # General Deps
diff --git a/crates/next-core/src/next_shared/transforms/modularize_imports.rs b/crates/next-core/src/next_shared/transforms/modularize_imports.rs
@@ -1,8 +1,6 @@
-use std::collections::HashMap;
-
 use anyhow::Result;
 use async_trait::async_trait;
-use modularize_imports::{modularize_imports, PackageConfig};
+use modularize_imports::{modularize_imports, Config, PackageConfig};
 use serde::{Deserialize, Serialize};
 use swc_core::ecma::ast::Program;
 use turbo_tasks::{trace::TraceRawVcs, FxIndexMap, NonLocalValue, OperationValue, ResolvedVc};
@@ -71,35 +69,39 @@ pub fn get_next_modularize_imports_rule(
 
 #[derive(Debug)]
 struct ModularizeImportsTransformer {
-    packages: HashMap<String, PackageConfig>,
+    config: Config,
 }
 
 impl ModularizeImportsTransformer {
     fn new(packages: &FxIndexMap<String, ModularizeImportPackageConfig>) -> Self {
         Self {
-            packages: packages
-                .iter()
-                .map(|(k, v)| {
-                    (
-                        k.clone(),
-                        PackageConfig {
-                            transform: match &v.transform {
-                                Transform::String(s) => {
-                                    modularize_imports::Transform::String(s.clone())
-                                }
-                                Transform::Vec(v) => modularize_imports::Transform::Vec(v.clone()),
-                                Transform::None => {
-                                    panic!("Missing transform value for package {}", k)
-                                }
+            config: Config {
+                packages: packages
+                    .iter()
+                    .map(|(k, v)| {
+                        (
+                            k.clone(),
+                            PackageConfig {
+                                transform: match &v.transform {
+                                    Transform::String(s) => {
+                                        modularize_imports::Transform::String(s.clone())
+                                    }
+                                    Transform::Vec(v) => {
+                                        modularize_imports::Transform::Vec(v.clone())
+                                    }
+                                    Transform::None => {
+                                        panic!("Missing transform value for package {}", k)
+                                    }
+                                },
+                                prevent_full_import: v.prevent_full_import,
+                                skip_default_conversion: v.skip_default_conversion,
+                                handle_default_import: false,
+                                handle_namespace_import: false,
                             },
-                            prevent_full_import: v.prevent_full_import,
-                            skip_default_conversion: v.skip_default_conversion,
-                            handle_default_import: false,
-                            handle_namespace_import: false,
-                        },
-                    )
-                })
-                .collect(),
+                        )
+                    })
+                    .collect(),
+            },
         }
     }
 }
@@ -108,9 +110,7 @@ impl ModularizeImportsTransformer {
 impl CustomTransformer for ModularizeImportsTransformer {
     #[tracing::instrument(level = tracing::Level::TRACE, name = "modularize_imports", skip_all)]
     async fn transform(&self, program: &mut Program, _ctx: &TransformContext<'_>) -> Result<()> {
-        program.mutate(modularize_imports(modularize_imports::Config {
-            packages: self.packages.clone(),
-        }));
+        program.mutate(modularize_imports(&self.config));
 
         Ok(())
     }
diff --git a/crates/next-custom-transforms/src/chain_transforms.rs b/crates/next-custom-transforms/src/chain_transforms.rs
@@ -13,9 +13,9 @@ use swc_core::{
         FileName, Mark, SourceFile, SourceMap, SyntaxContext,
     },
     ecma::{
-        ast::{noop_pass, EsVersion, Pass},
+        ast::{fn_pass, noop_pass, EsVersion, Pass},
         parser::parse_file_as_module,
-        visit::{fold_pass, visit_mut_pass},
+        visit::visit_mut_pass,
     },
 };
 
@@ -149,13 +149,6 @@ where
         }
     };
 
-    let modularize_imports_config = match &opts.modularize_imports {
-        Some(config) => config.clone(),
-        None => modularize_imports::Config {
-            packages: std::collections::HashMap::new(),
-        },
-    };
-
     let target_browsers = opts
         .swc
         .config
@@ -164,20 +157,69 @@ where
         .map(|env| targets_to_versions(env.targets.clone()).expect("failed to parse env.targets"))
         .unwrap_or_default();
 
-    let styled_jsx = if let Some(config) = opts.styled_jsx.to_option() {
-        Either::Left(styled_jsx::visitor::styled_jsx(
-            cm.clone(),
-            (*file.name).clone(),
-            styled_jsx::visitor::Config {
-                use_lightningcss: config.use_lightningcss,
-                browsers: target_browsers,
-            },
-            styled_jsx::visitor::NativeConfig { process_css: None },
-        ))
-    } else {
-        Either::Right(noop_pass())
+    let styled_jsx = {
+        let cm = cm.clone();
+        let file = file.clone();
+
+        fn_pass(move |program| {
+            if let Some(config) = opts.styled_jsx.to_option() {
+                program.mutate(styled_jsx::visitor::styled_jsx(
+                    cm.clone(),
+                    &file.name,
+                    &styled_jsx::visitor::Config {
+                        use_lightningcss: config.use_lightningcss,
+                        browsers: target_browsers,
+                    },
+                    &styled_jsx::visitor::NativeConfig { process_css: None },
+                ))
+            }
+        })
     };
 
+    let styled_components = {
+        let file = file.clone();
+
+        fn_pass(move |program| {
+            if let Some(config) = &opts.styled_components {
+                program.mutate(styled_components::styled_components(
+                    &file.name,
+                    file.src_hash,
+                    config,
+                    NoopComments,
+                ))
+            }
+        })
+    };
+
+    let emotion = {
+        let cm = cm.clone();
+        let file = file.clone();
+        let comments = comments.clone();
+
+        fn_pass(move |program| {
+            if let Some(config) = opts.emotion.as_ref() {
+                if !config.enabled.unwrap_or(false) {
+                    return;
+                }
+                if let FileName::Real(path) = &*file.name {
+                    program.mutate(swc_emotion::emotion(
+                        config,
+                        path,
+                        file.src_hash as u32,
+                        cm.clone(),
+                        comments.clone(),
+                    ));
+                }
+            }
+        })
+    };
+
+    let modularize_imports = fn_pass(move |program| {
+        if let Some(config) = opts.modularize_imports.as_ref() {
+            program.mutate(modularize_imports::modularize_imports(config));
+        }
+    });
+
     (
         (
             crate::transforms::disallow_re_export_all_in_page::disallow_re_export_all_in_page(
@@ -195,15 +237,7 @@ where
                 _ => Either::Right(noop_pass()),
             },
             styled_jsx,
-            match &opts.styled_components {
-                Some(config) => Either::Left(styled_components::styled_components(
-                    file.name.clone(),
-                    file.src_hash,
-                    config.clone(),
-                    NoopComments,
-                )),
-                None => Either::Right(noop_pass()),
-            },
+            styled_components,
             Optional::new(
                 crate::transforms::next_ssg::next_ssg(eliminated_packages),
                 !opts.disable_next_ssg,
@@ -274,28 +308,8 @@ where
                 ),
                 _ => Either::Right(noop_pass()),
             },
-            opts.emotion
-                .as_ref()
-                .and_then(|config| {
-                    if !config.enabled.unwrap_or(false) {
-                        return None;
-                    }
-                    if let FileName::Real(path) = &*file.name {
-                        path.to_str().map(|_| {
-                            Either::Left(fold_pass(swc_emotion::EmotionTransformer::new(
-                                config.clone(),
-                                path,
-                                file.src_hash as u32,
-                                cm,
-                                comments.clone(),
-                            )))
-                        })
-                    } else {
-                        None
-                    }
-                })
-                .unwrap_or_else(|| Either::Right(noop_pass())),
-            modularize_imports::modularize_imports(modularize_imports_config),
+            emotion,
+            modularize_imports,
             match &opts.font_loaders {
                 Some(config) => Either::Left(next_font_loaders(config.clone())),
                 None => Either::Right(noop_pass()),
diff --git a/turbopack/crates/turbopack-ecmascript-plugins/src/transform/emotion.rs b/turbopack/crates/turbopack-ecmascript-plugins/src/transform/emotion.rs
@@ -104,7 +104,7 @@ impl CustomTransformer for EmotionTransformer {
                 hasher.finish()
             };
             program.mutate(swc_emotion::emotion(
-                self.config.clone(),
+                &self.config,
                 Path::new(ctx.file_name_str),
                 hash as u32,
                 ctx.source_map.clone(),
diff --git a/turbopack/crates/turbopack-ecmascript-plugins/src/transform/modularize_imports.rs b/turbopack/crates/turbopack-ecmascript-plugins/src/transform/modularize_imports.rs
@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-
 use anyhow::Result;
 use async_trait::async_trait;
 use modularize_imports::{modularize_imports, Config, PackageConfig};
@@ -20,27 +18,31 @@ pub struct ModularizeImportPackageConfig {
 
 #[derive(Debug)]
 pub struct ModularizeImportsTransformer {
-    packages: HashMap<String, PackageConfig>,
+    config: Config,
 }
 
 impl ModularizeImportsTransformer {
     pub fn new(packages: &FxIndexMap<String, ModularizeImportPackageConfig>) -> Self {
         Self {
-            packages: packages
-                .iter()
-                .map(|(k, v)| {
-                    (
-                        k.clone(),
-                        PackageConfig {
-                            transform: modularize_imports::Transform::String(v.transform.clone()),
-                            prevent_full_import: v.prevent_full_import,
-                            skip_default_conversion: v.skip_default_conversion,
-                            handle_default_import: false,
-                            handle_namespace_import: false,
-                        },
-                    )
-                })
-                .collect(),
+            config: Config {
+                packages: packages
+                    .iter()
+                    .map(|(k, v)| {
+                        (
+                            k.clone(),
+                            PackageConfig {
+                                transform: modularize_imports::Transform::String(
+                                    v.transform.clone(),
+                                ),
+                                prevent_full_import: v.prevent_full_import,
+                                skip_default_conversion: v.skip_default_conversion,
+                                handle_default_import: false,
+                                handle_namespace_import: false,
+                            },
+                        )
+                    })
+                    .collect(),
+            },
         }
     }
 }
@@ -49,9 +51,7 @@ impl ModularizeImportsTransformer {
 impl CustomTransformer for ModularizeImportsTransformer {
     #[tracing::instrument(level = tracing::Level::TRACE, name = "modularize_imports", skip_all)]
     async fn transform(&self, program: &mut Program, _ctx: &TransformContext<'_>) -> Result<()> {
-        program.mutate(modularize_imports(Config {
-            packages: self.packages.clone(),
-        }));
+        program.mutate(modularize_imports(&self.config));
 
         Ok(())
     }
diff --git a/turbopack/crates/turbopack-ecmascript-plugins/src/transform/styled_components.rs b/turbopack/crates/turbopack-ecmascript-plugins/src/transform/styled_components.rs
@@ -92,9 +92,9 @@ impl CustomTransformer for StyledComponentsTransformer {
     #[tracing::instrument(level = tracing::Level::TRACE, name = "styled_components", skip_all)]
     async fn transform(&self, program: &mut Program, ctx: &TransformContext<'_>) -> Result<()> {
         program.mutate(styled_components::styled_components(
-            FileName::Real(PathBuf::from(ctx.file_path_str)).into(),
+            &FileName::Real(PathBuf::from(ctx.file_path_str)),
             ctx.file_name_hash,
-            self.config.clone(),
+            &self.config,
             NoopComments,
         ));
 
diff --git a/turbopack/crates/turbopack-ecmascript-plugins/src/transform/styled_jsx.rs b/turbopack/crates/turbopack-ecmascript-plugins/src/transform/styled_jsx.rs
