feat(es/transform): Add experimental .d.ts generation (#9093)

crates/swc/Cargo.toml

@@ -107,6 +107,7 @@ swc_plugin_proxy = { version = "0.44.0", path = "../swc_plugin_proxy", optional
 swc_plugin_runner = { version = "0.109.0", path = "../swc_plugin_runner", optional = true, default-features = false }
 swc_timer = { version = "0.22.0", path = "../swc_timer" }
 swc_transform_common = { version = "0.1.1", path = "../swc_transform_common" }
+swc_typescript = { version = "0.1.1", path = "../swc_typescript" }
 swc_visit = { version = "0.5.14", path = "../swc_visit" }
 
   [dependencies.tokio]

crates/swc/src/config/mod.rs

@@ -782,6 +782,7 @@ impl Options {
             emit_assert_for_import_attributes: experimental
                 .emit_assert_for_import_attributes
                 .into_bool(),
+            emit_isolated_dts: experimental.emit_isolated_dts.into_bool(),
         })
     }
 }
@@ -1088,6 +1089,8 @@ pub struct BuiltInput<P: swc_ecma_visit::Fold> {
 
     pub output: JscOutputConfig,
     pub emit_assert_for_import_attributes: bool,
+
+    pub emit_isolated_dts: bool,
 }
 
 impl<P> BuiltInput<P>
@@ -1117,6 +1120,7 @@ where
             emit_source_map_columns: self.emit_source_map_columns,
             output: self.output,
             emit_assert_for_import_attributes: self.emit_assert_for_import_attributes,
+            emit_isolated_dts: self.emit_isolated_dts,
         }
     }
 }
@@ -1211,6 +1215,12 @@ pub struct JscExperimental {
 
     #[serde(default)]
     pub disable_builtin_transforms_for_internal_testing: BoolConfig<false>,
+
+    /// Emit TypeScript definitions for `.ts`, `.tsx` files.
+    ///
+    /// This requires `isolatedDeclartion` feature of TypeScript 5.5.
+    #[serde(default)]
+    pub emit_isolated_dts: BoolConfig<false>,
 }
 
 #[derive(Debug, Clone, Copy, Serialize, Deserialize)]

crates/swc/src/lib.rs

@@ -136,7 +136,7 @@ use swc_common::{
 pub use swc_compiler_base::{PrintArgs, TransformOutput};
 pub use swc_config::config_types::{BoolConfig, BoolOr, BoolOrDataConfig};
 use swc_ecma_ast::{EsVersion, Program};
-use swc_ecma_codegen::Node;
+use swc_ecma_codegen::{to_code, Node};
 use swc_ecma_loader::resolvers::{
     lru::CachingResolver, node::NodeModulesResolver, tsc::TsConfigResolver,
 };
@@ -155,6 +155,8 @@ use swc_ecma_visit::{FoldWith, VisitMutWith, VisitWith};
 pub use swc_error_reporters::handler::{try_with_handler, HandlerOpts};
 pub use swc_node_comments::SwcComments;
 use swc_timer::timer;
+use swc_transform_common::output::emit;
+use swc_typescript::fast_dts::FastDts;
 use tracing::warn;
 use url::Url;
 
@@ -731,7 +733,7 @@ impl Compiler {
                 None
             };
 
-            self.apply_transforms(handler, orig, config)
+            self.apply_transforms(handler, fm.clone(), orig, config)
         })
     }
 
@@ -949,11 +951,13 @@ impl Compiler {
     fn apply_transforms(
         &self,
         handler: &Handler,
+        fm: Arc<SourceFile>,
         orig: Option<sourcemap::SourceMap>,
         config: BuiltInput<impl swc_ecma_visit::Fold>,
     ) -> Result<TransformOutput, Error> {
         self.run(|| {
             let program = config.program;
+            let emit_dts = config.syntax.typescript() && config.emit_isolated_dts;
             let source_map_names = if config.source_maps.enabled() {
                 let mut v = swc_compiler_base::IdentCollector {
                     names: Default::default(),
@@ -966,8 +970,34 @@ impl Compiler {
                 Default::default()
             };
 
+            let dts_code = if emit_dts && program.is_module() {
+                let mut checker = FastDts::new(fm.name.clone().into());
+                let mut module = program.clone().expect_module();
+
+                let issues = checker.transform(&mut module);
+
+                for issue in issues {
+                    let range = issue.range();
+
+                    handler
+                        .struct_span_err(range.span, &issue.to_string())
+                        .emit();
+                }
+                let dts_code = to_code(&module);
+                Some(dts_code)
+            } else {
+                None
+            };
+
             let mut pass = config.pass;
             let (program, output) = swc_transform_common::output::capture(|| {
+                if let Some(dts_code) = dts_code {
+                    emit(
+                        "__swc_isolated_declarations__".into(),
+                        serde_json::Value::String(dts_code),
+                    );
+                }
+
                 helpers::HELPERS.set(&Helpers::new(config.external_helpers), || {
                     HANDLER.set(handler, || {
                         // Fold module

crates/swc/tests/fixture/issues-2xxx/2020/case1/input/index.swc-stderr

@@ -0,0 +1,11 @@
+
+  x cannot reassign to a variable declared with `const`
+   ,-[$DIR/tests/fixture/issues-2xxx/2020/case1/input/index.js:1:1]
+ 1 | const createRegisterItems = (registerType) => async (a, b) => {
+   :                                                      |
+   :                                                      `-- cannot reassign
+ 2 |     const a = root?.test;
+   :           |
+   :           `-- const variable was declared here
+ 3 | };
+   `----

crates/swc/tests/fixture/issues-8xxx/8935/input/src/button.swc-stderr

@@ -0,0 +1,12 @@
+
+  x the name `Button` is defined multiple times
+   ,-[$DIR/tests/fixture/issues-8xxx/8935/input/src/button.jsx:1:1]
+ 1 | export function Button(props) {
+   :                 ^^^|^^
+   :                    `-- previous definition of `Button` here
+ 2 |     return <button {...props} />;
+ 3 |   }export function Button(props) {
+   :                    ^^^|^^
+   :                       `-- `Button` redefined here
+ 4 |   return <button {...props} />;
+   `----

crates/swc/tests/fixture/module/ignore-dynamic/1/input/index.swc-stderr

@@ -0,0 +1,12 @@
+
+  x the name `foo` is defined multiple times
+   ,-[$DIR/tests/fixture/module/ignore-dynamic/1/input/index.js:1:1]
+ 1 | import foo from "foo";
+   :        ^|^
+   :         `-- previous definition of `foo` here
+ 2 | 
+ 3 | async function foo() {
+   :                ^|^
+   :                 `-- `foo` redefined here
+ 4 |     await import("foo");
+   `----

crates/swc/tests/projects.rs

@@ -776,83 +776,119 @@ fn should_visit() {
 #[testing::fixture("tests/fixture/**/input/")]
 #[testing::fixture("tests/vercel/**/input/")]
 fn fixture(input_dir: PathBuf) {
-    tests(input_dir)
+    tests(input_dir, Some(IsModule::Unknown));
 }
 
-fn tests(input_dir: PathBuf) {
-    let output = input_dir.parent().unwrap().join("output");
+#[testing::fixture("tests/ts-isolated-declaration/**/input/")]
+fn ts_id(input_dir: PathBuf) {
+    tests(input_dir, Some(IsModule::Bool(true)));
+}
 
-    Tester::new()
-        .print_errors(|cm, handler| {
-            let c = Compiler::new(cm.clone());
+fn tests(input_dir: PathBuf, is_module: Option<IsModule>) {
+    let output_dir = input_dir.parent().unwrap().join("output");
 
-            for entry in WalkDir::new(&input_dir) {
-                let entry = entry.unwrap();
-                if entry.metadata().unwrap().is_dir() {
-                    continue;
-                }
-                println!("File: {}", entry.path().to_string_lossy());
+    for entry in WalkDir::new(&input_dir) {
+        let entry = entry.unwrap();
 
-                if !entry.file_name().to_string_lossy().ends_with(".ts")
-                    && !entry.file_name().to_string_lossy().ends_with(".js")
-                    && !entry.file_name().to_string_lossy().ends_with(".jsx")
-                    && !entry.file_name().to_string_lossy().ends_with(".tsx")
-                {
-                    continue;
-                }
+        let errors = Tester::new().print_errors(|cm, handler| {
+            let c = Compiler::new(cm.clone());
 
-                let rel_path = entry
-                    .path()
-                    .strip_prefix(&input_dir)
-                    .expect("failed to strip prefix");
+            if entry.metadata().unwrap().is_dir() {
+                return Ok(());
+            }
+            println!("File: {}", entry.path().to_string_lossy());
+
+            if !entry.file_name().to_string_lossy().ends_with(".ts")
+                && !entry.file_name().to_string_lossy().ends_with(".js")
+                && !entry.file_name().to_string_lossy().ends_with(".jsx")
+                && !entry.file_name().to_string_lossy().ends_with(".tsx")
+            {
+                return Ok(());
+            }
 
-                let fm = cm.load_file(entry.path()).expect("failed to load file");
-                match c.process_js_file(
-                    fm,
-                    &handler,
-                    &Options {
-                        swcrc: true,
-                        output_path: Some(output.join(entry.file_name())),
-                        config: Config {
-                            jsc: JscConfig {
-                                external_helpers: true.into(),
-                                ..Default::default()
-                            },
-                            is_module: Some(IsModule::Unknown),
+            let rel_path = entry
+                .path()
+                .strip_prefix(&input_dir)
+                .expect("failed to strip prefix");
+
+            let fm = cm.load_file(entry.path()).expect("failed to load file");
+            match c.process_js_file(
+                fm,
+                &handler,
+                &Options {
+                    swcrc: true,
+                    output_path: Some(output_dir.join(entry.file_name())),
+                    config: Config {
+                        jsc: JscConfig {
+                            external_helpers: true.into(),
                             ..Default::default()
                         },
-
+                        is_module,
                         ..Default::default()
                     },
-                ) {
-                    Ok(v) => {
-                        NormalizedOutput::from(v.code)
-                            .compare_to_file(output.join(rel_path))
-                            .unwrap();
-
-                        let _ = create_dir_all(output.join(rel_path).parent().unwrap());
-
-                        let map = v.map.map(|json| {
-                            let json: serde_json::Value = serde_json::from_str(&json).unwrap();
-                            serde_json::to_string_pretty(&json).unwrap()
-                        });
-
-                        NormalizedOutput::from(map.unwrap_or_default())
-                            .compare_to_file(
-                                output.join(rel_path.with_extension("map").file_name().unwrap()),
-                            )
-                            .unwrap();
+
+                    ..Default::default()
+                },
+            ) {
+                Ok(v) => {
+                    NormalizedOutput::from(v.code)
+                        .compare_to_file(output_dir.join(rel_path))
+                        .unwrap();
+
+                    let _ = create_dir_all(output_dir.join(rel_path).parent().unwrap());
+
+                    let map = v.map.map(|json| {
+                        let json: serde_json::Value = serde_json::from_str(&json).unwrap();
+                        serde_json::to_string_pretty(&json).unwrap()
+                    });
+
+                    NormalizedOutput::from(map.unwrap_or_default())
+                        .compare_to_file(
+                            output_dir.join(rel_path.with_extension("map").file_name().unwrap()),
+                        )
+                        .unwrap();
+
+                    if let Some(extra) = v.output {
+                        let mut value: serde_json::Map<_, serde_json::Value> =
+                            serde_json::from_str(&extra).unwrap();
+
+                        if let Some(v) = value.remove("__swc_isolated_declarations__") {
+                            let code = v
+                                .as_str()
+                                .expect("isolated declaration pass should emit string");
+
+                            NormalizedOutput::from(code.to_string())
+                                .compare_to_file(output_dir.join(rel_path).with_extension("d.ts"))
+                                .unwrap();
+                        }
+
+                        if !value.is_empty() {
+                            let extra = serde_json::to_string_pretty(&value).unwrap();
+
+                            NormalizedOutput::from(extra)
+                                .compare_to_file(
+                                    output_dir.join(rel_path.with_extension("extra.json")),
+                                )
+                                .unwrap();
+                        }
                     }
-                    Err(ref err) if format!("{:?}", err).contains("not matched") => {}
-                    Err(ref err) if format!("{:?}", err).contains("Syntax Error") => return Err(()),
-                    Err(err) => panic!("Error: {:?}", err),
                 }
+                Err(ref err) if format!("{:?}", err).contains("not matched") => {}
+                Err(ref err) if format!("{:?}", err).contains("Syntax Error") => return Err(()),
+                Err(err) => panic!("Error: {:?}", err),
+            }
+            if handler.has_errors() {
+                Err(())
+            } else {
+                Ok(())
             }
+        });
 
-            Ok(())
-        })
-        .map(|_| ())
-        .expect("failed");
+        if let Err(err) = errors {
+            err.compare_to_file(output_dir.join(entry.path().with_extension("swc-stderr")))
+                .unwrap();
+        }
+    }
 }
 
 #[test]

crates/swc/tests/ts-isolated-declaration/error/.swcrc

@@ -0,0 +1,10 @@
+{
+    "jsc": {
+        "parser": {
+            "syntax": "typescript"
+        },
+        "experimental": {
+            "emitIsolatedDts": true
+        }
+    }
+}

crates/swc/tests/ts-isolated-declaration/oxc/README.md

@@ -0,0 +1,3 @@
+### TypeScript Isolated Declaration test cases
+
+These tests are copied from [oxc](https://github.com/oxc-project/oxc/tree/58e54f4aea89c5d548c7976caba80a484260a979/crates/oxc_isolated_declarations/tests/fixtures)

crates/swc/tests/ts-isolated-declaration/oxc/input/.swcrc

@@ -0,0 +1,11 @@
+{
+    "jsc": {
+        "parser": {
+            "syntax": "typescript"
+        },
+        "experimental": {
+            "emitIsolatedDts": true
+        }
+    },
+    "isModule": true
+}

crates/swc/tests/ts-isolated-declaration/oxc/input/arrow-function-return-type.ts

@@ -0,0 +1,9 @@
+function A() {
+  return () => {
+    return C;
+  }
+}
+
+const B = () => { return B };
+
+const C = function () {}