Connect Bazel sourcedb to the bazel-check command

grievejia · meta-codesync[bot] · commit 50ddd72922ea · 2026-07-09T13:56:23.000-07:00
Summary:
_integration_

The `bazel-check` subcommand was only a scaffold: it parsed the Bazel input and assembled the source database, but then always wrote an empty diagnostic file and reported success. This change makes it actually type check the target.

Results are surfaced in the two forms the build integration needs: a compact, per-target JSON file — each diagnostic tagged with the target label and an openable on-disk path — for downstream tooling, and human-readable rendered diagnostics on stderr under a target header for anyone reading the log.

The check runs hermetically: interpreter querying and search-path heuristics are disabled, so the outcome depends only on the source database and search paths Bazel provides, keeping results reproducible under the build. `--min-severity` gates what is emitted, but directives such as `reveal_type` always survive the filter; the command exits with a user error only when a genuine diagnostic — not a directive — meets the threshold, so informational output never fails a build.

Reviewed By: stroxler

Differential Revision: D110555019

fbshipit-source-id: 230b5d697071683ef76c2018ed389c83d897c035
diff --git a/pyrefly/lib/commands/bazel_check.rs b/pyrefly/lib/commands/bazel_check.rs
@@ -29,6 +29,7 @@ use pyrefly_python::module_path::ModuleStyle;
 use pyrefly_python::sys_info::PythonPlatform;
 use pyrefly_python::sys_info::PythonVersion;
 use pyrefly_python::sys_info::SysInfo;
+use pyrefly_util::arc_id::ArcId;
 use pyrefly_util::fs_anyhow;
 use pyrefly_util::thread_pool::ThreadCount;
 use serde::Deserialize;
@@ -37,7 +38,14 @@ use serde_json::Value;
 use starlark_map::small_map::SmallMap;
 use vec1::Vec1;
 
+use crate::commands::check::write_errors_to_stderr;
 use crate::commands::util::CommandExitStatus;
+use crate::config::config::ConfigFile;
+use crate::config::finder::ConfigFinder;
+use crate::error::error::Error;
+use crate::error::legacy::LegacyError;
+use crate::state::require::Require;
+use crate::state::state::State;
 
 /// Arguments for Bazel-powered type checking.
 #[derive(Debug, Clone, Parser)]
@@ -793,8 +801,65 @@ impl ModuleEnumerator for BazelCheckSourceDatabase {
 }
 
 #[derive(Debug, Serialize)]
-struct BazelDiagnostics {
-    diagnostics: Vec<Value>,
+struct BazelDiagnostics<'a> {
+    diagnostics: Vec<BazelDiagnostic<'a>>,
+}
+
+#[derive(Debug, Serialize)]
+struct BazelDiagnostic<'a> {
+    target: &'a str,
+    #[serde(flatten)]
+    error: LegacyError,
+}
+
+fn keep_in_bazel_output(error: &Error, min_severity: Severity) -> bool {
+    error.error_kind().is_directive() || error.severity() >= min_severity
+}
+
+fn compute_bazel_errors(
+    parsed_config: &ParsedBazelConfig,
+    search_roots: &[BazelSearchRoot],
+    source_db: BazelCheckSourceDatabase,
+    thread_count: ThreadCount,
+) -> anyhow::Result<Vec<Error>> {
+    let modules_to_check = source_db.modules_to_check();
+    let mut config = ConfigFile::default();
+    config.python_environment.python_platform = Some(parsed_config.system_platform.clone());
+    config.python_environment.python_version = Some(parsed_config.python_version);
+    config.python_environment.site_package_path = Some(Vec::new());
+    config.search_path_from_file = search_roots
+        .iter()
+        .map(|root| root.physical.clone())
+        .collect();
+    config.source_db = Some(ArcId::new(Box::new(source_db)));
+    config.interpreters.skip_interpreter_query = true;
+    config.disable_search_path_heuristics = true;
+    config.preset = parsed_config.preset;
+    if let Some(errors) = &parsed_config.errors {
+        config.root.errors = Some(errors.clone());
+    }
+    config.configure();
+
+    let config = ArcId::new(config);
+    let state = State::new(ConfigFinder::new_constant(config), thread_count);
+    let mut transaction = state.new_transaction(Require::Errors, None);
+    transaction.run(&modules_to_check, Require::Errors, None);
+
+    Ok(transaction
+        .get_errors(&modules_to_check)
+        .collect_display_errors_with_unused_ignores())
+}
+
+fn bazel_diagnostics_from_errors<'a>(target: &'a str, errors: &[Error]) -> BazelDiagnostics<'a> {
+    BazelDiagnostics {
+        diagnostics: errors
+            .iter()
+            .map(|error| BazelDiagnostic {
+                target,
+                error: LegacyError::from_error(Path::new(""), error),
+            })
+            .collect(),
+    }
 }
 
 fn read_input_file(path: &Path) -> anyhow::Result<BazelCheckInput> {
@@ -803,15 +868,15 @@ fn read_input_file(path: &Path) -> anyhow::Result<BazelCheckInput> {
     BazelCheckInput::from_json_bytes(path, &data)
 }
 
-fn write_output(path: &Path, diagnostics: &BazelDiagnostics) -> anyhow::Result<()> {
+fn write_output(path: &Path, diagnostics: &BazelDiagnostics<'_>) -> anyhow::Result<()> {
     let output_bytes = serde_json::to_vec(diagnostics)
         .with_context(|| "failed to serialize Bazel diagnostic JSON value to bytes")?;
     fs_anyhow::write(path, &output_bytes)
 }
 
 impl BazelCheckArgs {
-    pub fn run(self, _thread_count: ThreadCount) -> anyhow::Result<CommandExitStatus> {
-        match self.run_inner() {
+    pub fn run(self, thread_count: ThreadCount) -> anyhow::Result<CommandExitStatus> {
+        match self.run_inner(thread_count) {
             Ok(status) => Ok(status),
             Err(error) => {
                 eprintln!("{error:?}");
@@ -820,29 +885,41 @@ impl BazelCheckArgs {
         }
     }
 
-    fn run_inner(self) -> anyhow::Result<CommandExitStatus> {
+    fn run_inner(self, thread_count: ThreadCount) -> anyhow::Result<CommandExitStatus> {
         let Self {
             input_path,
             output_path,
-            min_severity: _,
+            min_severity,
         } = self;
         let input = read_input_file(&input_path)?;
         let file_inputs = build_bazel_file_inputs(&input)?;
         let config = input.config.parse()?;
         let search_roots = build_search_roots(&input.search_path, config.python_version)?;
         let explicit_entries =
             build_explicit_entries(file_inputs, &search_roots, &input.target.label)?;
-        let _source_db = BazelCheckSourceDatabase::new(
+        let source_db = BazelCheckSourceDatabase::new(
             explicit_entries,
-            SysInfo::new(config.python_version, config.system_platform),
+            SysInfo::new(config.python_version, config.system_platform.clone()),
         );
-        write_output(
-            &output_path,
-            &BazelDiagnostics {
-                diagnostics: Vec::new(),
-            },
-        )?;
-        Ok(CommandExitStatus::Success)
+        let type_errors = compute_bazel_errors(&config, &search_roots, source_db, thread_count)?;
+        let displayed_errors = type_errors
+            .into_iter()
+            .filter(|error| keep_in_bazel_output(error, min_severity))
+            .collect::<Vec<_>>();
+        let diagnostics = bazel_diagnostics_from_errors(&input.target.label, &displayed_errors);
+        write_output(&output_path, &diagnostics)?;
+        if !displayed_errors.is_empty() {
+            eprintln!("Target {}", input.target.label);
+            write_errors_to_stderr(Path::new(""), &displayed_errors, true)?;
+        }
+        if displayed_errors
+            .iter()
+            .any(|error| !error.error_kind().is_directive())
+        {
+            Ok(CommandExitStatus::UserError)
+        } else {
+            Ok(CommandExitStatus::Success)
+        }
     }
 }
 
diff --git a/pyrefly/lib/commands/check.rs b/pyrefly/lib/commands/check.rs
@@ -19,6 +19,7 @@ use std::time::Duration;
 use std::time::Instant;
 
 use anstream::eprintln;
+use anstream::stderr;
 use anstream::stdout;
 use anyhow::Context as _;
 use clap::Parser;
@@ -482,6 +483,22 @@ fn write_error_text_to_console(
     Ok(())
 }
 
+pub(crate) fn write_errors_to_stderr(
+    relative_to: &Path,
+    errors: &[Error],
+    verbose: bool,
+) -> anyhow::Result<()> {
+    let stderr = stderr();
+    let color_choice = stderr.current_choice();
+    let mut renderer = ErrorRenderer::new(BufWriter::new(stderr.lock()), color_choice);
+    for error in errors {
+        renderer.write(error, relative_to, verbose)?;
+        renderer.flush()?;
+    }
+    renderer.flush()?;
+    Ok(())
+}
+
 fn write_error_json(
     writer: &mut impl Write,
     relative_to: &Path,
diff --git a/test/bazel_check.md b/test/bazel_check.md
@@ -7,3 +7,106 @@ $ $PYREFLY --help | grep -F "bazel-check"
 *bazel-check* (glob)
 [0]
 ```
+
+## Direct root error includes target in stderr and JSON
+
+```scrut {output_stream: stdout}
+$ mkdir -p $TMPDIR/bazel_error/pkg && cd $TMPDIR/bazel_error && \
+> echo "x: int = 'bad'" > pkg/app.py && \
+> printf '%s' '{"target":{"label":"//pkg:app","workspace_name":"_main","package":"pkg","name":"app","rule_kind":"py_binary"},"check_roots":{"sources":["pkg/app.py"]},"search_path":{"workspace_name":"_main","python_import_all_repositories":false},"config":{"python_version":"3.12","system_platform":"linux"}}' > input.json && \
+> $PYREFLY bazel-check --output out.json input.json > stdout.txt 2> stderr.txt; rc=$?; \
+> test ! -s stdout.txt && \
+> cat stderr.txt && \
+> $JQ -r '[(.diagnostics | length), .diagnostics[0].target, .diagnostics[0].path, .diagnostics[0].name] | join(" ")' out.json; \
+> exit $rc
+Target //pkg:app
+ERROR * [bad-assignment] (glob)
+*pkg/app.py* (glob)
+* (glob+)
+1 //pkg:app pkg/app.py bad-assignment
+[1]
+```
+
+## Dependency files are importable but not checked as roots
+
+```scrut {output_stream: stdout}
+$ mkdir -p $TMPDIR/bazel_dep/pkg && cd $TMPDIR/bazel_dep && \
+> echo "import pkg.dep" > pkg/app.py && \
+> echo "x: int = 'bad'" > pkg/dep.py && \
+> printf '%s' '{"target":{"label":"//pkg:app","workspace_name":"_main","package":"pkg","name":"app","rule_kind":"py_binary"},"check_roots":{"sources":["pkg/app.py"]},"search_path":{"workspace_name":"_main","python_import_all_repositories":false},"config":{"python_version":"3.12","system_platform":"linux"}}' > input.json && \
+> $PYREFLY bazel-check --output out.json input.json > stdout.txt 2> stderr.txt && \
+> test ! -s stdout.txt && test ! -s stderr.txt && \
+> $JQ '.diagnostics | length' out.json
+0
+[0]
+```
+
+## Dependency type can produce a root diagnostic
+
+```scrut {output_stream: stdout}
+$ mkdir -p $TMPDIR/bazel_dep_type/pkg && cd $TMPDIR/bazel_dep_type && \
+> echo "import pkg.dep; y: int = pkg.dep.x" > pkg/app.py && \
+> echo "x: str = 'typed'" > pkg/dep.py && \
+> printf '%s' '{"target":{"label":"//pkg:app","workspace_name":"_main","package":"pkg","name":"app","rule_kind":"py_binary"},"check_roots":{"sources":["pkg/app.py"]},"search_path":{"workspace_name":"_main","python_import_all_repositories":false},"config":{"python_version":"3.12","system_platform":"linux"}}' > input.json && \
+> $PYREFLY bazel-check --output out.json input.json > stdout.txt 2> stderr.txt; rc=$?; \
+> test ! -s stdout.txt && \
+> $JQ -r '[(.diagnostics | length), .diagnostics[0].path, .diagnostics[0].name] | join(" ")' out.json; \
+> exit $rc
+1 pkg/app.py bad-assignment
+[1]
+```
+
+## Generated check root reports physical path
+
+```scrut {output_stream: stdout}
+$ mkdir -p $TMPDIR/bazel_generated/bazel-out/darwin-fastbuild/bin && cd $TMPDIR/bazel_generated && \
+> echo "x: int = 'bad'" > bazel-out/darwin-fastbuild/bin/generated.py && \
+> printf '%s' '{"target":{"label":"//pkg:generated","workspace_name":"_main","package":"pkg","name":"generated","rule_kind":"py_library"},"check_roots":{"sources":["generated.py"]},"search_path":{"workspace_name":"_main","python_import_all_repositories":false},"path_overlays":[{"short_path":"generated.py","path":"bazel-out/darwin-fastbuild/bin/generated.py"}],"config":{"python_version":"3.12","system_platform":"linux"}}' > input.json && \
+> $PYREFLY bazel-check --output out.json input.json > stdout.txt 2> stderr.txt; rc=$?; \
+> test ! -s stdout.txt && \
+> cat stderr.txt && \
+> $JQ -r '[(.diagnostics | length), .diagnostics[0].path, .diagnostics[0].target] | join(" ")' out.json; \
+> exit $rc
+Target //pkg:generated
+ERROR * [bad-assignment] (glob)
+*bazel-out/darwin-fastbuild/bin/generated.py* (glob)
+* (glob+)
+1 bazel-out/darwin-fastbuild/bin/generated.py //pkg:generated
+[1]
+```
+
+## Warning threshold controls output and exit status
+
+```scrut {output_stream: stdout}
+$ mkdir -p $TMPDIR/bazel_warn/pkg && cd $TMPDIR/bazel_warn && \
+> echo "x: int = 'bad'" > pkg/app.py && \
+> printf '%s' '{"target":{"label":"//pkg:app","workspace_name":"_main","package":"pkg","name":"app","rule_kind":"py_binary"},"check_roots":{"sources":["pkg/app.py"]},"search_path":{"workspace_name":"_main","python_import_all_repositories":false},"config":{"python_version":"3.12","system_platform":"linux","error_severities":{"bad-assignment":"warn"}}}' > input.json && \
+> $PYREFLY bazel-check --output default.json input.json > default.stdout 2> default.stderr && \
+> test ! -s default.stdout && test ! -s default.stderr && \
+> $JQ '.diagnostics | length' default.json && \
+> $PYREFLY bazel-check --min-severity warn --output warn.json input.json > warn.stdout 2> warn.stderr; rc=$?; \
+> test ! -s warn.stdout && \
+> $JQ -r '[(.diagnostics | length), .diagnostics[0].name, .diagnostics[0].severity] | join(" ")' warn.json; \
+> exit $rc
+0
+1 bad-assignment warn
+[1]
+```
+
+## Directive output survives the default severity threshold
+
+```scrut {output_stream: stdout}
+$ mkdir -p $TMPDIR/bazel_reveal/pkg && cd $TMPDIR/bazel_reveal && \
+> echo "from typing import reveal_type; reveal_type(1)" > pkg/app.py && \
+> printf '%s' '{"target":{"label":"//pkg:app","workspace_name":"_main","package":"pkg","name":"app","rule_kind":"py_binary"},"check_roots":{"sources":["pkg/app.py"]},"search_path":{"workspace_name":"_main","python_import_all_repositories":false},"config":{"python_version":"3.12","system_platform":"linux"}}' > input.json && \
+> $PYREFLY bazel-check --output out.json input.json > stdout.txt 2> stderr.txt && \
+> test ! -s stdout.txt && \
+> cat stderr.txt && \
+> $JQ -r '[(.diagnostics | length), .diagnostics[0].path, .diagnostics[0].name] | join(" ")' out.json
+Target //pkg:app
+ INFO revealed type: Literal[1] [reveal-type]
+*pkg/app.py* (glob)
+* (glob+)
+1 pkg/app.py reveal-type
+[0]
+```
