feat(transformer, minifier, syntax)!: remove ESTarget::ES5 (#12448)

* close #11296

Both `Transformer` and `Minifier` have a minimum ES version support of `ES2015`. However, we can set the `ESTarget` to `ES5` now, which might mislead users into thinking we already support `ES5`, so for now, let's remove the `ESTarget::ES5` option to eliminate the confusion.

Suggested by @shulaoda

Author: Dunqing

.github/workflows/ci.yml

@@ -30,6 +30,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: taiki-e/checkout-action@b13d20b7cda4e2f325ef19895128f7ff735c0b3d # v1.3.1
+      - uses: oxc-project/setup-node@f42e3bda950c7454575e78ee4eaac880a077700c # v1.0.0
       - uses: oxc-project/setup-rust@cd82e1efec7fef815e2c23d296756f31c7cdc03d # v1.0.0
         with:
           save-cache: ${{ github.ref_name == 'main' }}
@@ -45,6 +46,7 @@ jobs:
     if: ${{ github.ref_name == 'main' }}
     steps:
       - uses: taiki-e/checkout-action@b13d20b7cda4e2f325ef19895128f7ff735c0b3d # v1.3.1
+      - uses: oxc-project/setup-node@f42e3bda950c7454575e78ee4eaac880a077700c # v1.0.0
       - uses: oxc-project/setup-rust@cd82e1efec7fef815e2c23d296756f31c7cdc03d # v1.0.0
         with:
           save-cache: ${{ github.ref_name == 'main' }}
@@ -62,6 +64,7 @@ jobs:
       # Unsung heros of the internet, who led me here to speed up window's slowness:
       # https://github.com/actions/cache/issues/752#issuecomment-1847036770
       # https://github.com/astral-sh/uv/blob/502e04200d52de30d3159894833b3db4f0d6644d/.github/workflows/ci.yml#L158
+      - uses: oxc-project/setup-node@f42e3bda950c7454575e78ee4eaac880a077700c # v1.0.0
       - uses: samypr100/setup-dev-drive@750bec535eb7e4833d6a4c86c5738751f9887575 # v3.4.2
         with:
           workspace-copy: true

.gitignore

@@ -7,6 +7,7 @@ target/
 
 # node_modules
 /node_modules/
+/apps/oxlint/node_modules/
 /website/node_modules/
 /benchmark/node_modules/
 /tasks/benchmark/codspeed/node_modules/

apps/oxlint/fixtures/tsgolint/no-floating-promises/.oxlintrc.json

@@ -0,0 +1,8 @@
+{
+  "categories": {
+    "correctness": "off"
+  },
+  "rules": {
+    "typescript/no-floating-promises": "error"
+  }
+}

apps/oxlint/fixtures/tsgolint/no-floating-promises/index.ts

@@ -0,0 +1,14 @@
+const promise = new Promise((resolve, _reject) => resolve("value"));
+promise;
+
+async function returnsPromise() {
+  return "value";
+}
+
+returnsPromise().then(() => {});
+
+Promise.reject("value").catch();
+
+Promise.reject("value").finally();
+
+[1, 2, 3].map(async (x) => x + 1);

apps/oxlint/fixtures/tsgolint/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "es2016",
+    "lib": ["ES2024"],
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true
+  }
+}

apps/oxlint/src/lib.rs

@@ -4,6 +4,7 @@ mod output_formatter;
 mod result;
 mod runner;
 mod tester;
+mod tsgolint;
 mod walk;
 
 pub mod cli {

apps/oxlint/src/lint.rs

@@ -11,17 +11,24 @@ use std::{
 use cow_utils::CowUtils;
 use ignore::{gitignore::Gitignore, overrides::OverrideBuilder};
 use oxc_allocator::AllocatorPool;
-use oxc_diagnostics::{DiagnosticSender, DiagnosticService, GraphicalReportHandler, OxcDiagnostic};
+use oxc_diagnostics::{
+    DiagnosticSender, DiagnosticService, GraphicalReportHandler, OxcDiagnostic, Severity,
+};
 use oxc_linter::{
     AllowWarnDeny, Config, ConfigStore, ConfigStoreBuilder, ExternalLinter, ExternalPluginStore,
     InvalidFilterKind, LintFilter, LintOptions, LintService, LintServiceOptions, Linter, Oxlintrc,
+    read_to_string,
 };
 use rustc_hash::{FxHashMap, FxHashSet};
 use serde_json::Value;
 
 use crate::{
     cli::{CliRunResult, LintCommand, MiscOptions, ReportUnusedDirectives, Runner, WarningOptions},
     output_formatter::{LintCommandInfo, OutputFormatter},
+    tsgolint::{
+        MessageType, TsGoLintInput, TsGoLintInputFile, TsGoLintState, parse_tsgolint_output,
+        try_find_tsgolint_executable,
+    },
     walk::Walk,
 };
 
@@ -280,19 +287,43 @@ impl Runner for LintRunner {
 
         let lint_config = config_builder.build();
 
+        // Enable type-aware linting if `--tsconfig` is passed
+        // TODO: Add a warning message if `tsgolint` cannot be found, but type-aware rules are enabled
+        let tsgolint_path =
+            try_find_tsgolint_executable(options.cwd()).unwrap_or(PathBuf::from("tsgolint"));
+        let type_aware = basic_options.tsconfig.is_some();
+
+        let tsgolint_state = if type_aware {
+            Some(TsGoLintState {
+                cwd: options.cwd().to_path_buf(),
+                paths: paths.clone(),
+                rules: lint_config
+                    .rules()
+                    .iter()
+                    .filter_map(|(rule, status)| {
+                        if status.is_warn_deny() && rule.is_tsgolint_rule() {
+                            Some((*status, rule.clone()))
+                        } else {
+                            None
+                        }
+                    })
+                    .collect(),
+            })
+        } else {
+            None
+        };
+
         let report_unused_directives = match inline_config_options.report_unused_directives {
             ReportUnusedDirectives::WithoutSeverity(true) => Some(AllowWarnDeny::Warn),
             ReportUnusedDirectives::WithSeverity(Some(severity)) => Some(severity),
             _ => None,
         };
 
-        let linter = Linter::new(
-            LintOptions::default(),
-            ConfigStore::new(lint_config, nested_configs, external_plugin_store),
-            self.external_linter,
-        )
-        .with_fix(fix_options.fix_kind())
-        .with_report_unused_directives(report_unused_directives);
+        let config_store = ConfigStore::new(lint_config, nested_configs, external_plugin_store);
+        let tsgolint_config_store = if type_aware { Some(config_store.clone()) } else { None };
+        let linter = Linter::new(LintOptions::default(), config_store, self.external_linter)
+            .with_fix(fix_options.fix_kind())
+            .with_report_unused_directives(report_unused_directives);
 
         let tsconfig = basic_options.tsconfig;
         if let Some(path) = tsconfig.as_ref() {
@@ -315,11 +346,171 @@ impl Runner for LintRunner {
 
         let (mut diagnostic_service, tx_error) =
             Self::get_diagnostic_service(&output_formatter, &warning_options, &misc_options);
+        let tsgolint_error_sender = if type_aware { Some(tx_error.clone()) } else { None };
 
         let number_of_rules = linter.number_of_rules();
 
         let allocator_pool = AllocatorPool::new(rayon::current_num_threads());
 
+        if type_aware
+            && let Some(tsgolint_state) = tsgolint_state
+            && let Some(tsgolint_config_store) = tsgolint_config_store
+            && let Some(tsconfig) = tsconfig
+            && let Some(tsgolint_error_sender) = tsgolint_error_sender
+            && tsgolint_state.rules.len() > 0
+            && tsgolint_state.paths.len() > 0
+        {
+            // Feed JSON into STDIN of tsgolint in this format:
+            // ```
+            // {
+            //   "files": [
+            //     {
+            //       "file_path": "/absolute/path/to/file.ts",
+            //       "rules": ["rule-1", "another-rule"]
+            //     }
+            //   ]
+            // }
+            // ```
+            let json_input = TsGoLintInput {
+                files: tsgolint_state
+                    .paths
+                    .iter()
+                    .map(|path| TsGoLintInputFile {
+                        file_path: path.to_string_lossy().to_string(),
+                        rules: tsgolint_state
+                            .rules
+                            .iter()
+                            .map(|(_, r)| r.name().to_owned())
+                            .collect(),
+                    })
+                    .collect(),
+            };
+
+            let handler = std::thread::spawn(move || {
+                // `./tsgolint headless --tsconfig /path/to/project/tsconfig.json --cwd /path/to/project
+                let child = std::process::Command::new(tsgolint_path)
+                    .arg("headless")
+                    .arg("--tsconfig")
+                    .arg(tsconfig)
+                    .arg("--cwd")
+                    .arg(&tsgolint_state.cwd)
+                    .stdin(std::process::Stdio::piped())
+                    .stdout(std::process::Stdio::piped())
+                    .spawn();
+
+                let Ok(mut child) = child else {
+                    // For now, silently ignore errors if `tsgolint` does not appear to be installed, or cannot
+                    // be spawned correctly.
+                    return Ok(());
+                };
+
+                let mut stdin = child.stdin.take().expect("Failed to open tsgolint stdin");
+
+                std::thread::spawn(move || {
+                    let json =
+                        serde_json::to_string(&json_input).expect("Failed to serialize JSON");
+
+                    stdin.write_all(json.as_bytes()).expect("Failed to write to tsgolint stdin");
+                });
+
+                // TODO: Stream diagnostics as they are emitted, rather than waiting
+                let output = child.wait_with_output().expect("Failed to wait for tsgolint process");
+
+                match parse_tsgolint_output(&output.stdout) {
+                    Ok(parsed) => {
+                        let oxc_diagnostics = parsed
+                            .into_iter()
+                            .filter_map(|tsgolint_diagnostic| {
+                                // For now, ignore any `tsgolint` errors.
+                                if tsgolint_diagnostic.r#type == MessageType::Error {
+                                    return None;
+                                }
+                                // Resolve this config if not already stored
+                                // TODO(perf): do not re-resolve the same file path multiple times, instead cache the config
+                                let path = tsgolint_diagnostic.file_path.clone();
+                                let resolved_config = tsgolint_config_store.resolve(&path);
+                                // TODO(perf): build a map of rule->severity, rather than doing a linear search
+                                let severity =
+                                    resolved_config.rules.iter().find_map(|(rule, status)| {
+                                        if rule.name() == tsgolint_diagnostic.rule {
+                                            Some((*status, rule))
+                                        } else {
+                                            None
+                                        }
+                                    });
+
+                                let oxc_diagnostic: OxcDiagnostic = tsgolint_diagnostic.into();
+                                if severity.is_none() {
+                                    // If the severity is not found, we should not report the diagnostic
+                                    return None;
+                                }
+                                let oxc_diagnostic = oxc_diagnostic.with_severity(severity.map_or(
+                                    Severity::Warning,
+                                    |(severity, _)| {
+                                        if severity == AllowWarnDeny::Deny {
+                                            Severity::Error
+                                        } else {
+                                            Severity::Warning
+                                        }
+                                    },
+                                ));
+
+                                Some((path, oxc_diagnostic))
+                            })
+                            // group diagnostics by file path
+                            .fold(
+                                FxHashMap::default(),
+                                |mut acc: FxHashMap<PathBuf, Vec<OxcDiagnostic>>,
+                                 (file_path, diagnostic)| {
+                                    acc.entry(file_path).or_default().push(diagnostic);
+
+                                    acc
+                                },
+                            )
+                            .into_iter()
+                            .map(|(file_path, diagnostics)| {
+                                (
+                                    file_path.clone(),
+                                    DiagnosticService::wrap_diagnostics(
+                                        tsgolint_state.cwd.clone(),
+                                        file_path.clone(),
+                                        &read_to_string(&file_path)
+                                            .unwrap_or_else(|_| String::new()),
+                                        0,
+                                        diagnostics,
+                                    ),
+                                )
+                            })
+                            .collect::<FxHashMap<_, _>>();
+
+                        for (file_path, diagnostics) in oxc_diagnostics {
+                            tsgolint_error_sender
+                                .send((file_path, diagnostics))
+                                .expect("Failed to send diagnostic");
+                        }
+
+                        Ok(())
+                    }
+
+                    Err(err) => Err(format!("Failed to parse tsgolint output: {err}")),
+                }
+            });
+
+            match handler.join() {
+                Ok(Ok(())) => {
+                    // Successfully ran tsgolint
+                }
+                Ok(Err(err)) => {
+                    print_and_flush_stdout(stdout, &format!("Error running tsgolint: {err:?}"));
+                    return CliRunResult::TsGoLintError;
+                }
+                Err(err) => {
+                    print_and_flush_stdout(stdout, &format!("Error running tsgolint: {err:?}"));
+                    return CliRunResult::TsGoLintError;
+                }
+            }
+        }
+
         // Spawn linting in another thread so diagnostics can be printed immediately from diagnostic_service.run.
         rayon::spawn(move || {
             let mut lint_service = LintService::new(linter, allocator_pool, options);
@@ -1195,4 +1386,10 @@ mod test {
         let args = &["-c", ".oxlintrc.json"];
         Tester::new().with_cwd("fixtures/issue_11644".into()).test_and_snapshot(args);
     }
+
+    #[test]
+    fn test_tsgolint() {
+        let args = &["fixtures/tsgolint", "--tsconfig", "fixtures/tsgolint/tsconfig.json"];
+        Tester::new().test_and_snapshot(args);
+    }
 }

apps/oxlint/src/result.rs

@@ -16,6 +16,7 @@ pub enum CliRunResult {
     PrintConfigResult,
     ConfigFileInitFailed,
     ConfigFileInitSucceeded,
+    TsGoLintError,
 }
 
 impl Termination for CliRunResult {
@@ -35,7 +36,8 @@ impl Termination for CliRunResult {
             | Self::InvalidOptionTsConfig
             | Self::InvalidOptionSeverityWithoutFilter
             | Self::InvalidOptionSeverityWithoutPluginName
-            | Self::InvalidOptionSeverityWithoutRuleName => ExitCode::FAILURE,
+            | Self::InvalidOptionSeverityWithoutRuleName
+            | Self::TsGoLintError => ExitCode::FAILURE,
         }
     }
 }

apps/oxlint/src/snapshots/_--ignore-path fixtures__linter__.customignore --no-ignore fixtures__linter__nan.js@oxlint.snap

@@ -14,7 +14,7 @@ working directory:
   help: Use the isNaN function to compare with NaN.
 
 Found 1 warning and 0 errors.
-Finished in <variable>ms on 1 file with 87 rules using 1 threads.
+Finished in <variable>ms on 1 file with 88 rules using 1 threads.
 ----------
 CLI result: LintSucceeded
 ----------

apps/oxlint/src/snapshots/_--ignore-pattern _____.js --ignore-pattern _____.vue fixtures__linter@oxlint.snap

@@ -6,7 +6,7 @@ arguments: --ignore-pattern **/*.js --ignore-pattern **/*.vue fixtures/linter
 working directory: 
 ----------
 Found 0 warnings and 0 errors.
-Finished in <variable>ms on 0 files with 87 rules using 1 threads.
+Finished in <variable>ms on 0 files with 88 rules using 1 threads.
 ----------
 CLI result: LintSucceeded
 ----------