feat(check): wire lint phase to 3-phase matrix via from_flags and sidecar

Author: jong-kyung

packages/cli/binding/src/check/analysis.rs

@@ -40,22 +40,12 @@ pub(super) enum LintMessageKind {
     LintOnly,
     LintAndTypeCheck,
     // Used when lint rules are skipped but type-check still runs.
-    #[allow(dead_code)]
     TypeCheckOnly,
 }
 
 impl LintMessageKind {
-    pub(super) fn from_lint_config(lint_config: Option<&serde_json::Value>) -> Self {
-        if lint_config_type_check_enabled(lint_config) {
-            Self::LintAndTypeCheck
-        } else {
-            Self::LintOnly
-        }
-    }
-
     // Selects a variant from the `(lint, type-check)` enabled tuple callers have
     // already resolved, avoiding a second config lookup inside the helper.
-    #[allow(dead_code)]
     pub(super) fn from_flags(lint_enabled: bool, type_check_enabled: bool) -> Self {
         match (lint_enabled, type_check_enabled) {
             (true, true) => Self::LintAndTypeCheck,
@@ -250,34 +240,3 @@ pub(super) fn analyze_lint_output(output: &str) -> Option<Result<LintSuccess, Li
 
     Some(Err(LintFailure { summary, warnings, errors, diagnostics }))
 }
-
-#[cfg(test)]
-mod tests {
-    use serde_json::json;
-
-    use super::LintMessageKind;
-
-    #[test]
-    fn lint_message_kind_defaults_to_lint_only_without_typecheck() {
-        assert_eq!(LintMessageKind::from_lint_config(None), LintMessageKind::LintOnly);
-        assert_eq!(
-            LintMessageKind::from_lint_config(Some(&json!({ "options": {} }))),
-            LintMessageKind::LintOnly
-        );
-    }
-
-    #[test]
-    fn lint_message_kind_detects_typecheck_from_vite_config() {
-        let kind = LintMessageKind::from_lint_config(Some(&json!({
-            "options": {
-                "typeAware": true,
-                "typeCheck": true
-            }
-        })));
-
-        assert_eq!(kind, LintMessageKind::LintAndTypeCheck);
-        assert_eq!(kind.success_label(), "Found no warnings, lint errors, or type errors");
-        assert_eq!(kind.warning_heading(), "Lint or type warnings found");
-        assert_eq!(kind.issue_heading(), "Lint or type issues found");
-    }
-}

packages/cli/binding/src/check/mod.rs

@@ -9,10 +9,13 @@ use vite_path::{AbsolutePath, AbsolutePathBuf};
 use vite_shared::output;
 use vite_task::ExitStatus;
 
-use self::analysis::{
-    LintMessageKind, analyze_fmt_check_output, analyze_lint_output, format_count, format_elapsed,
-    lint_config_type_check_enabled, print_error_block, print_pass_line, print_stdout_block,
-    print_summary_line,
+use self::{
+    analysis::{
+        LintMessageKind, analyze_fmt_check_output, analyze_lint_output, format_count,
+        format_elapsed, lint_config_type_check_enabled, print_error_block, print_pass_line,
+        print_stdout_block, print_summary_line,
+    },
+    sidecar::write_no_type_check_sidecar,
 };
 use crate::cli::{
     CapturedCommandOutput, SubcommandResolver, SynthesizableSubcommand, resolve_and_capture_output,
@@ -31,14 +34,6 @@ pub(crate) async fn execute_check(
     cwd: &AbsolutePathBuf,
     cwd_arc: &Arc<AbsolutePath>,
 ) -> Result<ExitStatus, Error> {
-    if no_fmt && no_lint {
-        output::error("No checks enabled");
-        print_summary_line(
-            "`vp check` did not run because both `--no-fmt` and `--no-lint` were set",
-        );
-        return Ok(ExitStatus(1));
-    }
-
     let mut status = ExitStatus::SUCCESS;
     let has_paths = !paths.is_empty();
     // In --fix mode with file paths (the lint-staged use case), implicitly suppress
@@ -50,13 +45,22 @@ pub(crate) async fn execute_check(
     let resolved_vite_config = resolver.resolve_universal_vite_config().await?;
 
     // Per-phase enabled booleans derived from the raw flags plus the resolved
-    // config's `typeCheck` setting. Currently only the guard immediately below
-    // reads these; the fmt/lint phase conditions further down still consult the
-    // raw `no_fmt`/`no_lint` flags.
+    // config's `typeCheck` setting. `run_lint_phase` drives whether the lint
+    // subprocess starts at all — true when lint rules should run, or when
+    // type-check should run via oxlint's type-check-only path.
     let config_type_check_enabled =
         lint_config_type_check_enabled(resolved_vite_config.lint.as_ref());
     let type_check_enabled = !no_type_check && config_type_check_enabled;
     let lint_enabled = !no_lint;
+    let run_lint_phase = lint_enabled || type_check_enabled;
+
+    if no_fmt && !run_lint_phase {
+        output::error("No checks enabled");
+        print_summary_line(
+            "`vp check` did not run because all checks were disabled by the provided flags",
+        );
+        return Ok(ExitStatus(1));
+    }
 
     // Reject `--fix --no-lint` when the project enables type-check. With lint
     // rules skipped, oxlint would take the type-check-only path which it
@@ -74,6 +78,18 @@ pub(crate) async fn execute_check(
         return Ok(ExitStatus(1));
     }
 
+    // Build the `--no-type-check` sidecar up front, before any fmt side effects.
+    // If temp-dir write fails (full tmpfs, read-only mount, permission denied),
+    // we surface the error before fmt modifies files, mirroring the
+    // transactional guarantee of the hard-error guard above. The returned
+    // guard lives through both fmt and lint phases and is dropped at function
+    // exit, cleaning up the temp file.
+    let sidecar = if lint_enabled && no_type_check && config_type_check_enabled {
+        write_no_type_check_sidecar(&resolved_vite_config)?
+    } else {
+        None
+    };
+
     if !no_fmt {
         let mut args = if fix { vec![] } else { vec!["--check".to_string()] };
         if suppress_unmatched {
@@ -137,7 +153,7 @@ pub(crate) async fn execute_check(
             }
         }
 
-        if fix && no_lint && status == ExitStatus::SUCCESS {
+        if fix && !run_lint_phase && status == ExitStatus::SUCCESS {
             print_pass_line(
                 "Formatting completed for checked files",
                 Some(&format!("({})", format_elapsed(fmt_start.elapsed()))),
@@ -155,13 +171,23 @@ pub(crate) async fn execute_check(
         }
     }
 
-    if !no_lint {
-        let lint_message_kind =
-            LintMessageKind::from_lint_config(resolved_vite_config.lint.as_ref());
+    if run_lint_phase {
+        let lint_message_kind = LintMessageKind::from_flags(lint_enabled, type_check_enabled);
         let mut args = Vec::new();
-        if fix {
+        // Hard-error guard above rejects (fix && !lint_enabled && type_check_enabled),
+        // so when this branch runs with `fix`, lint_enabled is always true. The
+        // `lint_enabled` check is defense-in-depth against future guard changes.
+        if fix && lint_enabled {
             args.push("--fix".to_string());
         }
+        // `--type-check-only` suppresses lint rules and runs only type-check
+        // diagnostics. oxlint accepts this as a hidden flag (oxc#21184). When
+        // config `typeCheck` is false this flag forces type-check ON, so we
+        // only emit it on the `--no-lint` + `typeCheck: true` path and skip
+        // the lint phase entirely when type_check_enabled is false.
+        if !lint_enabled && type_check_enabled {
+            args.push("--type-check-only".to_string());
+        }
         // `vp check` parses oxlint's human-readable summary output to print
         // unified pass/fail lines. When `GITHUB_ACTIONS=true`, oxlint auto-switches
         // to the GitHub reporter, which omits that summary on success and makes the
@@ -174,10 +200,17 @@ pub(crate) async fn execute_check(
         if has_paths {
             args.extend(paths.iter().cloned());
         }
+
+        // `sidecar` was built up front to surface temp-dir write failures
+        // before fmt made any changes. Borrow its config here to route oxlint
+        // through the override when present; otherwise use the resolved
+        // config unchanged.
+        let lint_vite_config = sidecar.as_ref().map(|s| &s.config).unwrap_or(&resolved_vite_config);
+
         let captured = resolve_and_capture_output(
             resolver,
             SynthesizableSubcommand::Lint { args },
-            Some(&resolved_vite_config),
+            Some(lint_vite_config),
             envs,
             cwd,
             cwd_arc,

packages/cli/snap-tests/check-all-skipped/snap.txt

@@ -1,4 +1,4 @@
 [1]> vp check --no-fmt --no-lint
 error: No checks enabled
 
-`vp check` did not run because both `--no-fmt` and `--no-lint` were set
+`vp check` did not run because all checks were disabled by the provided flags