Add auto-commonjs and update swc (#30661)

Closes #30596



## Bug

- [ ] Related issues linked using `fixes #number`
- [ ] Integration tests added
- [ ] Errors have helpful link attached, see `contributing.md`

## Feature

- [ ] Implements an existing feature request or RFC. Make sure the feature request has been accepted for implementation before opening a PR.
- [ ] Related issues linked using `fixes #number`
- [ ] Integration tests added
- [ ] Documentation added
- [ ] Telemetry added. In case of a feature if it's used or not.
- [ ] Errors have helpful link attached, see `contributing.md`

## Documentation / Examples

- [ ] Make sure the linting passes by running `yarn lint`


 - This patch contains several patches from swc.

This includes swc-project/swc#2581, which allows customizing the import path for regenerator.

 - This adds auto-detection of common js.

If `module.exports` is found and module config is not set, module config becomes common js.

 - As bonus, this includes some performance improvements

The logic for analyzing the input source file and parsing options as json is moved from the js thread to a background worker thread.

Author: kdy1

packages/next/build/swc/Cargo.lock

@@ -17,12 +17,12 @@ path-clean = "0.1"
 regex = "1.5"
 serde = "1"
 serde_json = "1"
-swc = "0.79.0"
+swc = "0.80.0"
 swc_atoms = "0.2.7"
 swc_common = { version = "0.14.2", features = ["concurrent", "sourcemap"] }
 swc_css = "0.20.0"
-swc_ecmascript = { version = "0.82.0", features = ["codegen", "minifier", "optimization", "parser", "react", "transforms", "typescript", "utils", "visit"] }
-swc_ecma_preset_env = "0.61.0"
+swc_ecmascript = { version = "0.83.0", features = ["codegen", "minifier", "optimization", "parser", "react", "transforms", "typescript", "utils", "visit"] }
+swc_ecma_preset_env = "0.62.0"
 swc_node_base = "0.5.1"
 swc_stylis = "0.17.0"
 fxhash = "0.2.1"
@@ -36,9 +36,9 @@ tracing = { version = "0.1.28", features = ["release_max_level_off"] }
 napi-build = "1"
 
 [dev-dependencies]
-swc_ecma_transforms_testing = "0.42.0"
-testing = "0.15.0"
+swc_ecma_transforms_testing = "0.42.1"
+testing = "0.15.1"
 walkdir = "2.3.2"
 
 [profile.release]
-# lto = true
+lto = true

packages/next/build/swc/Cargo.toml

@@ -0,0 +1,46 @@
+use swc_common::DUMMY_SP;
+use swc_ecmascript::{
+    ast::*,
+    visit::{Node, Visit, VisitWith},
+};
+
+pub(crate) fn contains_cjs(m: &Module) -> bool {
+    let mut v = CjsFinder::default();
+    m.visit_with(&Invalid { span: DUMMY_SP }, &mut v);
+    v.found
+}
+
+#[derive(Copy, Clone, Default)]
+struct CjsFinder {
+    found: bool,
+}
+
+/// This visitor implementation supports typescript, because the api of `swc`
+/// does not support changing configuration based on content of the file.
+impl Visit for CjsFinder {
+    fn visit_member_expr(&mut self, e: &MemberExpr, _: &dyn Node) {
+        if !e.computed {
+            match &e.obj {
+                ExprOrSuper::Super(_) => {}
+                ExprOrSuper::Expr(obj) => match &**obj {
+                    Expr::Ident(obj) => match &*e.prop {
+                        Expr::Ident(prop) => {
+                            if &*obj.sym == "module" && &*prop.sym == "exports" {
+                                self.found = true;
+                                return;
+                            }
+                        }
+                        _ => {}
+                    },
+                    _ => {}
+                },
+            }
+        }
+
+        e.obj.visit_with(e, self);
+
+        if e.computed {
+            e.prop.visit_with(e, self);
+        }
+    }
+}

packages/next/build/swc/src/auto_cjs/mod.rs

@@ -34,15 +34,22 @@ extern crate napi_derive;
 /// Explicit extern crate to use allocator.
 extern crate swc_node_base;
 
+use auto_cjs::contains_cjs;
 use backtrace::Backtrace;
 use napi::{CallContext, Env, JsObject, JsUndefined};
 use serde::Deserialize;
 use std::{env, panic::set_hook, path::PathBuf, sync::Arc};
-use swc::{Compiler, TransformOutput};
+use swc::{config::ModuleConfig, Compiler, TransformOutput};
+use swc_common::SourceFile;
 use swc_common::{self, chain, pass::Optional, sync::Lazy, FileName, FilePathMapping, SourceMap};
-use swc_ecmascript::visit::Fold;
+use swc_ecmascript::ast::EsVersion;
+use swc_ecmascript::{
+    parser::{lexer::Lexer, Parser, StringInput},
+    visit::Fold,
+};
 
 pub mod amp_attributes;
+mod auto_cjs;
 pub mod hook_optimizer;
 pub mod minify;
 pub mod next_dynamic;
@@ -52,7 +59,7 @@ pub mod styled_jsx;
 mod transform;
 mod util;
 
-#[derive(Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TransformOptions {
     #[serde(flatten)]
@@ -126,4 +133,27 @@ pub fn complete_output(env: &Env, output: TransformOutput) -> napi::Result<JsObj
     env.to_js_value(&output)?.coerce_to_object()
 }
 
+impl TransformOptions {
+    pub fn patch(mut self, fm: &SourceFile) -> Self {
+        self.swc.swcrc = false;
+
+        let should_enable_commonjs =
+            self.swc.config.module.is_none() && fm.src.contains("module.exports") && {
+                let syntax = self.swc.config.jsc.syntax.unwrap_or_default();
+                let target = self.swc.config.jsc.target.unwrap_or(EsVersion::latest());
+                let lexer = Lexer::new(syntax, target, StringInput::from(&*fm), None);
+                let mut p = Parser::new_from(lexer);
+                p.parse_module()
+                    .map(|m| contains_cjs(&m))
+                    .unwrap_or_default()
+            };
+
+        if should_enable_commonjs {
+            self.swc.config.module = Some(ModuleConfig::CommonJs(Default::default()));
+        }
+
+        self
+    }
+}
+
 pub type ArcCompiler = Arc<Compiler>;

packages/next/build/swc/src/lib.rs

@@ -28,7 +28,7 @@ DEALINGS IN THE SOFTWARE.
 
 use crate::{
     complete_output, custom_before_pass, get_compiler,
-    util::{CtxtExt, MapErr},
+    util::{deserialize_json, CtxtExt, MapErr},
     TransformOptions,
 };
 use anyhow::{anyhow, Context as _, Error};
@@ -46,13 +46,13 @@ use swc_ecmascript::transforms::pass::noop;
 #[derive(Debug)]
 pub enum Input {
     /// Raw source code.
-    Source(Arc<SourceFile>),
+    Source { src: String },
 }
 
 pub struct TransformTask {
     pub c: Arc<Compiler>,
     pub input: Input,
-    pub options: TransformOptions,
+    pub options: String,
 }
 
 impl Task for TransformTask {
@@ -62,13 +62,25 @@ impl Task for TransformTask {
     fn compute(&mut self) -> napi::Result<Self::Output> {
         let res = catch_unwind(AssertUnwindSafe(|| {
             try_with_handler(self.c.cm.clone(), true, |handler| {
-                self.c.run(|| match self.input {
-                    Input::Source(ref s) => {
-                        let before_pass = custom_before_pass(&s.name, &self.options);
+                self.c.run(|| match &self.input {
+                    Input::Source { src } => {
+                        let options: TransformOptions = deserialize_json(&self.options)?;
+
+                        let filename = if options.swc.filename.is_empty() {
+                            FileName::Anon
+                        } else {
+                            FileName::Real(options.swc.filename.clone().into())
+                        };
+
+                        let fm = self.c.cm.new_source_file(filename, src.to_string());
+
+                        let options = options.patch(&fm);
+
+                        let before_pass = custom_before_pass(&fm.name, &options);
                         self.c.process_js_with_custom_pass(
-                            s.clone(),
+                            fm.clone(),
                             &handler,
-                            &self.options.swc,
+                            &options.swc,
                             before_pass,
                             noop(),
                         )
@@ -101,15 +113,15 @@ impl Task for TransformTask {
 /// returns `compiler, (src / path), options, plugin, callback`
 pub fn schedule_transform<F>(cx: CallContext, op: F) -> napi::Result<JsObject>
 where
-    F: FnOnce(&Arc<Compiler>, String, bool, TransformOptions) -> TransformTask,
+    F: FnOnce(&Arc<Compiler>, String, bool, String) -> TransformTask,
 {
     let c = get_compiler(&cx);
 
-    let s = cx.get::<JsString>(0)?.into_utf8()?.as_str()?.to_owned();
+    let src = cx.get::<JsString>(0)?.into_utf8()?.as_str()?.to_owned();
     let is_module = cx.get::<JsBoolean>(1)?;
-    let options: TransformOptions = cx.get_deserialized(2)?;
+    let options = cx.get_buffer_as_string(2)?;
 
-    let task = op(&c, s, is_module.get_value()?, options);
+    let task = op(&c, src, is_module.get_value()?, options);
 
     cx.env.spawn(task).map(|t| t.promise_object())
 }
@@ -145,17 +157,8 @@ where
 
 #[js_function(4)]
 pub fn transform(cx: CallContext) -> napi::Result<JsObject> {
-    schedule_transform(cx, |c, src, _, mut options| {
-        options.swc.swcrc = false;
-
-        let input = Input::Source(c.cm.new_source_file(
-            if options.swc.filename.is_empty() {
-                FileName::Anon
-            } else {
-                FileName::Real(options.swc.filename.clone().into())
-            },
-            src,
-        ));
+    schedule_transform(cx, |c, src, _, options| {
+        let input = Input::Source { src };
 
         TransformTask {
             c: c.clone(),