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

@@ -20,6 +20,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' }}
@@ -48,6 +49,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' }}
@@ -65,6 +67,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

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/command/lint.rs

@@ -46,6 +46,10 @@ pub struct LintCommand {
     #[bpaf(switch, hide_usage)]
     pub disable_nested_config: bool,
 
+    /// Enables rules that require type information.
+    #[bpaf(switch, hide_usage)]
+    pub type_aware: bool,
+
     #[bpaf(external)]
     pub inline_config_options: InlineConfigOptions,
 
@@ -573,6 +577,14 @@ mod lint_options {
         let options = get_lint_options(".");
         assert!(!options.disable_nested_config);
     }
+
+    #[test]
+    fn type_aware() {
+        let options = get_lint_options("--type-aware");
+        assert!(options.type_aware);
+        let options = get_lint_options(".");
+        assert!(!options.type_aware);
+    }
 }
 
 #[cfg(test)]

apps/oxlint/src/lib.rs

@@ -10,6 +10,7 @@ mod lint;
 mod output_formatter;
 mod result;
 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,
+    ResolvedLinterState, read_to_string,
 };
 use rustc_hash::{FxHashMap, FxHashSet};
 use serde_json::Value;
 
 use crate::{
     cli::{CliRunResult, LintCommand, MiscOptions, ReportUnusedDirectives, WarningOptions},
     output_formatter::{LintCommandInfo, OutputFormatter},
+    tsgolint::{
+        MessageType, TsGoLintInput, TsGoLintInputFile, TsGoLintState, parse_tsgolint_output,
+        try_find_tsgolint_executable,
+    },
     walk::Walk,
 };
 
@@ -290,19 +297,47 @@ impl LintRunner {
             }
         };
 
+        // Enable type-aware linting
+        // TODO: Add a warning message if `tsgolint` cannot be found, but type-aware rules are enabled
+        let type_aware = self.options.type_aware;
+
         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 (mut diagnostic_service, tx_error) =
+            Self::get_diagnostic_service(&output_formatter, &warning_options, &misc_options);
 
-        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_state = if type_aware {
+            Some(TsGoLintState {
+                error_sender: tx_error.clone(),
+                config_store: config_store.clone(),
+                executable_path: try_find_tsgolint_executable(options.cwd())
+                    .unwrap_or(PathBuf::from("tsgolint")),
+                cwd: options.cwd().to_path_buf(),
+                paths: paths.clone(),
+                rules: config_store
+                    .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 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() {
@@ -323,13 +358,147 @@ impl LintRunner {
             }
         }
 
-        let (mut diagnostic_service, tx_error) =
-            Self::get_diagnostic_service(&output_formatter, &warning_options, &misc_options);
-
         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
+            && !tsgolint_state.rules.is_empty()
+            && !tsgolint_state.paths.is_empty()
+        {
+            // 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 || {
+                let child = std::process::Command::new(tsgolint_state.executable_path)
+                    .arg("headless")
+                    .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 mut resolved_configs: FxHashMap<PathBuf, ResolvedLinterState> =
+                            FxHashMap::default();
+                        let mut severities: FxHashMap<String, Option<AllowWarnDeny>> =
+                            FxHashMap::default();
+
+                        let mut oxc_diagnostics: FxHashMap<PathBuf, Vec<OxcDiagnostic>> =
+                            FxHashMap::default();
+                        for tsgolint_diagnostic in parsed {
+                            // For now, ignore any `tsgolint` errors.
+                            if tsgolint_diagnostic.r#type == MessageType::Error {
+                                continue;
+                            }
+
+                            let path = tsgolint_diagnostic.file_path.clone();
+                            let resolved_config = resolved_configs
+                                .entry(path.clone())
+                                .or_insert_with(|| tsgolint_state.config_store.resolve(&path));
+
+                            let rule = tsgolint_diagnostic.rule.clone();
+                            let severity = severities.entry(rule).or_insert_with(|| {
+                                resolved_config.rules.iter().find_map(|(rule, status)| {
+                                    if rule.name() == tsgolint_diagnostic.rule {
+                                        Some(*status)
+                                    } else {
+                                        None
+                                    }
+                                })
+                            });
+
+                            let oxc_diagnostic: OxcDiagnostic = tsgolint_diagnostic.into();
+                            let Some(severity) = severity else {
+                                // If the severity is not found, we should not report the diagnostic
+                                continue;
+                            };
+                            let oxc_diagnostic =
+                                oxc_diagnostic.with_severity(if *severity == AllowWarnDeny::Deny {
+                                    Severity::Error
+                                } else {
+                                    Severity::Warning
+                                });
+
+                            oxc_diagnostics.entry(path.clone()).or_default().push(oxc_diagnostic);
+                        }
+
+                        for (file_path, diagnostics) in oxc_diagnostics {
+                            let diagnostics = DiagnosticService::wrap_diagnostics(
+                                tsgolint_state.cwd.clone(),
+                                file_path.clone(),
+                                &read_to_string(&file_path).unwrap_or_else(|_| String::new()),
+                                diagnostics,
+                            );
+                            tsgolint_state
+                                .error_sender
+                                .send((file_path.clone(), 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);
@@ -1203,4 +1372,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", "--type-aware"];
+        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,
         }
     }
 }