Make --output-format=json take effect when --output is not specified

Summary:
When `--output-format=json` is specified, the JSON formatting currently only takes effect when we write type errors to files. If type errors get written into console, the flag would get ignored. See [Github Issue](#157) .

This diff attempts to make `--output-format` consistently apply both in file writing and in console writing.

NOTE: For JSON format, I'm directly the console output to `stdout` so we could avoid clobbering with the `tracing` logger outputs and so downstream CLI tooling could have an easier way of extracting the data. For text format, I'm leaving the default console output to `stderr` still since I sense that one would be a more contentious decision and expect it to be addressed separately.

Reviewed By: ndmitchell

Differential Revision: D74208375

fbshipit-source-id: e3f5aae791f2854a64eee530a294b593df7c2839

Author: grievejia

pyrefly/lib/commands/check.rs

@@ -158,23 +158,50 @@ impl OutputFormat {
         Ok(())
     }
 
+    fn write_error_text_to_console(errors: &[Error]) -> anyhow::Result<()> {
+        print_errors(errors);
+        Ok(())
+    }
+
+    fn write_error_json(writer: &mut impl Write, errors: &[Error]) -> anyhow::Result<()> {
+        let legacy_errors = LegacyErrors::from_errors(errors);
+        serde_json::to_writer_pretty(writer, &legacy_errors)?;
+        Ok(())
+    }
+
+    fn buffered_write_error_json(writer: impl Write, errors: &[Error]) -> anyhow::Result<()> {
+        let mut writer = BufWriter::new(writer);
+        Self::write_error_json(&mut writer, errors)?;
+        writer.flush()?;
+        Ok(())
+    }
+
     fn write_error_json_to_file(path: &Path, errors: &[Error]) -> anyhow::Result<()> {
         fn f(path: &Path, errors: &[Error]) -> anyhow::Result<()> {
-            let legacy_errors = LegacyErrors::from_errors(errors);
-            let mut file = BufWriter::new(File::create(path)?);
-            serde_json::to_writer_pretty(&mut file, &legacy_errors)?;
-            Ok(file.flush()?)
+            let file = File::create(path)?;
+            OutputFormat::buffered_write_error_json(file, errors)
         }
         f(path, errors)
             .with_context(|| format!("while writing JSON errors to `{}`", path.display()))
     }
 
+    fn write_error_json_to_console(errors: &[Error]) -> anyhow::Result<()> {
+        Self::buffered_write_error_json(std::io::stdout(), errors)
+    }
+
     fn write_errors_to_file(&self, path: &Path, errors: &[Error]) -> anyhow::Result<()> {
         match self {
             Self::Text => Self::write_error_text_to_file(path, errors),
             Self::Json => Self::write_error_json_to_file(path, errors),
         }
     }
+
+    fn write_errors_to_console(&self, errors: &[Error]) -> anyhow::Result<()> {
+        match self {
+            Self::Text => Self::write_error_text_to_console(errors),
+            Self::Json => Self::write_error_json_to_console(errors),
+        }
+    }
 }
 
 /// A data structure to facilitate the creation of handles for all the files we want to check.
@@ -523,7 +550,7 @@ impl Args {
             self.output_format
                 .write_errors_to_file(path, &errors.shown)?;
         } else {
-            print_errors(&errors.shown);
+            self.output_format.write_errors_to_console(&errors.shown)?;
         }
         memory_trace.stop();
         if let Some(limit) = self.count_errors {

test/basic.md

@@ -16,6 +16,14 @@ $ $PYREFLY check $TEST_PY -a
 [0]
 ```
 
+## JSON output
+
+```scrut
+$ echo "x: str = 42" > $TMPDIR/test.py && $PYREFLY check $TMPDIR/test.py --output-format json | $JQ '.[] | length'
+1
+[0]
+```
+
 ## Error on a non-existent file
 
 ```scrut {output_stream: stderr}