Allow process_wrapper to output diagnostics to a file.

Author: matts1

util/process_wrapper/main.rs

@@ -89,20 +89,35 @@ fn main() {
 
     let mut child_stderr = child.stderr.take().unwrap();
 
+    let mut output_file: Box<Option<std::fs::File>> =
+        Box::new(opts.output_file.clone().map(|output_file_name| {
+            OpenOptions::new()
+                .create(true)
+                .truncate(true)
+                .write(true)
+                .open(output_file_name)
+                .expect("process wrapper error: unable to open output_file")
+        }));
+
     let mut was_killed = false;
     let result = if let Some(format) = opts.rustc_output_format {
         let quit_on_rmeta = opts.rustc_quit_on_rmeta;
         // Process json rustc output and kill the subprocess when we get a signal
         // that we emitted a metadata file.
         let mut me = false;
         let metadata_emitted = &mut me;
-        let result = process_output(&mut child_stderr, stderr.as_mut(), move |line| {
-            if quit_on_rmeta {
-                rustc::stop_on_rmeta_completion(line, format, metadata_emitted)
-            } else {
-                rustc::process_json(line, format)
-            }
-        });
+        let result = process_output(
+            &mut child_stderr,
+            stderr.as_mut(),
+            output_file.as_mut(),
+            move |line| {
+                if quit_on_rmeta {
+                    rustc::stop_on_rmeta_completion(line, format, metadata_emitted)
+                } else {
+                    rustc::process_json(line, format)
+                }
+            },
+        );
         if me {
             // If recv returns Ok(), a signal was sent in this channel so we should terminate the child process.
             // We can safely ignore the Result from kill() as we don't care if the process already terminated.
@@ -112,7 +127,12 @@ fn main() {
         result
     } else {
         // Process output normally by forwarding stderr
-        process_output(&mut child_stderr, stderr.as_mut(), LineOutput::Message)
+        process_output(
+            &mut child_stderr,
+            stderr.as_mut(),
+            output_file.as_mut(),
+            LineOutput::Message,
+        )
     };
     result.expect("process wrapper error: failed to process stderr");
 

util/process_wrapper/options.rs

@@ -41,6 +41,9 @@ pub(crate) struct Options {
     pub(crate) stdout_file: Option<String>,
     // If set, redirects the child process stderr to this file.
     pub(crate) stderr_file: Option<String>,
+    // If set, also logs all unprocessed output from the rustc output to this file.
+    // Meant to be used to get json output out of rustc for tooling usage.
+    pub(crate) output_file: Option<String>,
     // If set, it configures rustc to emit an rmeta file and then
     // quit.
     pub(crate) rustc_quit_on_rmeta: bool,
@@ -60,6 +63,7 @@ pub(crate) fn options() -> Result<Options, OptionError> {
     let mut copy_output_raw = None;
     let mut stdout_file = None;
     let mut stderr_file = None;
+    let mut output_file = None;
     let mut rustc_quit_on_rmeta_raw = None;
     let mut rustc_output_format_raw = None;
     let mut flags = Flags::new();
@@ -92,6 +96,11 @@ pub(crate) fn options() -> Result<Options, OptionError> {
         "Redirect subprocess stderr in this file.",
         &mut stderr_file,
     );
+    flags.define_flag(
+        "--output-file",
+        "Log all unprocessed subprocess stderr in this file.",
+        &mut output_file,
+    );
     flags.define_flag(
         "--rustc-quit-on-rmeta",
         "If enabled, this wrapper will terminate rustc after rmeta has been emitted.",
@@ -200,6 +209,7 @@ pub(crate) fn options() -> Result<Options, OptionError> {
         copy_output,
         stdout_file,
         stderr_file,
+        output_file,
         rustc_quit_on_rmeta,
         rustc_output_format,
     })

util/process_wrapper/output.rs

@@ -32,22 +32,27 @@ pub(crate) enum LineOutput {
 /// to write_end.
 pub(crate) fn process_output<F>(
     read_end: &mut dyn Read,
-    write_end: &mut dyn Write,
+    output_write_end: &mut dyn Write,
+    opt_file_write_end: &mut Option<std::fs::File>,
     mut process_line: F,
 ) -> io::Result<()>
 where
     F: FnMut(String) -> LineOutput,
 {
     let mut reader = io::BufReader::new(read_end);
-    let mut writer = io::LineWriter::new(write_end);
+    let mut output_writer = io::LineWriter::new(output_write_end);
+    let mut file_writer = opt_file_write_end.as_mut().map(io::LineWriter::new);
     loop {
         let mut line = String::new();
         let read_bytes = reader.read_line(&mut line)?;
         if read_bytes == 0 {
             break;
         }
+        if let Some(ref mut file) = file_writer {
+            file.write_all(line.as_bytes())?
+        }
         match process_line(line) {
-            LineOutput::Message(to_write) => writer.write_all(to_write.as_bytes())?,
+            LineOutput::Message(to_write) => output_writer.write_all(to_write.as_bytes())?,
             LineOutput::Skip => {}
             LineOutput::Terminate => return Ok(()),
         };

util/process_wrapper/rustc.rs

@@ -73,7 +73,9 @@ pub(crate) fn process_json(line: String, error_format: ErrorFormat) -> LineOutpu
         )
     });
     match parsed.try_into() {
-        Ok(RustcMessage::Message(rendered)) => output_based_on_error_format(line, rendered, error_format),
+        Ok(RustcMessage::Message(rendered)) => {
+            output_based_on_error_format(line, rendered, error_format)
+        }
         _ => LineOutput::Skip,
     }
 }
@@ -100,7 +102,9 @@ pub(crate) fn stop_on_rmeta_completion(
             *kill = true;
             LineOutput::Terminate
         }
-        Ok(RustcMessage::Message(rendered)) => output_based_on_error_format(line, rendered, error_format),
+        Ok(RustcMessage::Message(rendered)) => {
+            output_based_on_error_format(line, rendered, error_format)
+        }
         _ => LineOutput::Skip,
     }
 }