process_wrapper: Convert non-JSON diagnostics from LLVM to JSON. (#3309)

Even when rustc is run with `--error-format=json`, LLVM may still
[output
human-readable
diagnostics](https://github.com/llvm/llvm-project/blob/680391f07a45272bb9bfd385cf4c6846b8be32dd/llvm/lib/MC/MCSubtargetInfo.cpp#L82)
that are not formatted as JSON. So far, process_wrapper has choked on
these.

This patch detects these lines and converts them to JSON so that they
can be
processed like JSON diagnostics from rustc itself.

The correct fundamental fix would likely be to teach rustc itself to
perform
this conversion, but this is a change that would require some time to
implement,
so we're putting this fix in place instead.

Author: martinboehme

util/process_wrapper/main.rs

@@ -18,13 +18,17 @@ mod output;
 mod rustc;
 mod util;
 
+use std::collections::HashMap;
 use std::fmt;
 use std::fs::{copy, OpenOptions};
 use std::io;
 use std::process::{exit, Command, ExitStatus, Stdio};
 
+use tinyjson::JsonValue;
+
 use crate::options::options;
 use crate::output::{process_output, LineOutput};
+use crate::rustc::ErrorFormat;
 
 #[cfg(windows)]
 fn status_code(status: ExitStatus, was_killed: bool) -> i32 {
@@ -69,6 +73,48 @@ macro_rules! log {
     };
 }
 
+fn json_warning(line: &str) -> JsonValue {
+    JsonValue::Object(HashMap::from([
+        (
+            "$message_type".to_string(),
+            JsonValue::String("diagnostic".to_string()),
+        ),
+        ("message".to_string(), JsonValue::String(line.to_string())),
+        ("code".to_string(), JsonValue::Null),
+        (
+            "level".to_string(),
+            JsonValue::String("warning".to_string()),
+        ),
+        ("spans".to_string(), JsonValue::Array(Vec::new())),
+        ("children".to_string(), JsonValue::Array(Vec::new())),
+        ("rendered".to_string(), JsonValue::String(line.to_string())),
+    ]))
+}
+
+fn process_line(
+    mut line: String,
+    quit_on_rmeta: bool,
+    format: ErrorFormat,
+    metadata_emitted: &mut bool,
+) -> Result<LineOutput, String> {
+    // LLVM can emit lines that look like the following, and these will be interspersed
+    // with the regular JSON output. Arguably, rustc should be fixed not to emit lines
+    // like these (or to convert them to JSON), but for now we convert them to JSON
+    // ourselves.
+    if line.contains("is not a recognized feature for this target (ignoring feature)") {
+        if let Ok(json_str) = json_warning(&line).stringify() {
+            line = json_str;
+        } else {
+            return Ok(LineOutput::Skip);
+        }
+    }
+    if quit_on_rmeta {
+        rustc::stop_on_rmeta_completion(line, format, metadata_emitted)
+    } else {
+        rustc::process_json(line, format)
+    }
+}
+
 fn main() -> Result<(), ProcessWrapperError> {
     let opts = options().map_err(|e| ProcessWrapperError(e.to_string()))?;
 
@@ -135,13 +181,7 @@ fn main() -> Result<(), ProcessWrapperError> {
             &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)
-                }
-            },
+            move |line| process_line(line, quit_on_rmeta, format, metadata_emitted),
         );
         if me {
             // If recv returns Ok(), a signal was sent in this channel so we should terminate the child process.
@@ -188,3 +228,141 @@ fn main() -> Result<(), ProcessWrapperError> {
 
     exit(code)
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    fn parse_json(json_str: &str) -> Result<JsonValue, String> {
+        json_str.parse::<JsonValue>().map_err(|e| e.to_string())
+    }
+
+    #[test]
+    fn test_process_line_diagnostic_json() -> Result<(), String> {
+        let mut metadata_emitted = false;
+        let LineOutput::Message(msg) = process_line(
+            r#"
+                {
+                    "$message_type": "diagnostic",
+                    "rendered": "Diagnostic message"
+                }
+            "#
+            .to_string(),
+            false,
+            ErrorFormat::Json,
+            &mut metadata_emitted,
+        )?
+        else {
+            return Err("Expected a LineOutput::Message".to_string());
+        };
+        assert_eq!(
+            parse_json(&msg)?,
+            parse_json(
+                r#"
+                {
+                    "$message_type": "diagnostic",
+                    "rendered": "Diagnostic message"
+                }
+            "#
+            )?
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_process_line_diagnostic_rendered() -> Result<(), String> {
+        let mut metadata_emitted = false;
+        let LineOutput::Message(msg) = process_line(
+            r#"
+                {
+                    "$message_type": "diagnostic",
+                    "rendered": "Diagnostic message"
+                }
+            "#
+            .to_string(),
+            /*quit_on_rmeta=*/ false,
+            ErrorFormat::Rendered,
+            &mut metadata_emitted,
+        )?
+        else {
+            return Err("Expected a LineOutput::Message".to_string());
+        };
+        assert_eq!(msg, "Diagnostic message");
+        Ok(())
+    }
+
+    #[test]
+    fn test_process_line_llvm_feature_warning() -> Result<(), String> {
+        let mut metadata_emitted = false;
+        let LineOutput::Message(msg) = process_line(
+            "'+zaamo' is not a recognized feature for this target (ignoring feature)".to_string(),
+            /*quit_on_rmeta=*/ false,
+            ErrorFormat::Json,
+            &mut metadata_emitted,
+        )?
+        else {
+            return Err("Expected a LineOutput::Message".to_string());
+        };
+        assert_eq!(
+            parse_json(&msg)?,
+            parse_json(
+                r#"
+                {
+                    "$message_type": "diagnostic",
+                    "message": "'+zaamo' is not a recognized feature for this target (ignoring feature)",
+                    "code": null,
+                    "level": "warning",
+                    "spans": [],
+                    "children": [],
+                    "rendered": "'+zaamo' is not a recognized feature for this target (ignoring feature)"
+                }
+            "#
+            )?
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_process_line_emit_link() -> Result<(), String> {
+        let mut metadata_emitted = false;
+        assert!(matches!(
+            process_line(
+                r#"
+                {
+                    "$message_type": "artifact",
+                    "emit": "link"
+                }
+            "#
+                .to_string(),
+                /*quit_on_rmeta=*/ true,
+                ErrorFormat::Rendered,
+                &mut metadata_emitted,
+            )?,
+            LineOutput::Skip
+        ));
+        assert!(!metadata_emitted);
+        Ok(())
+    }
+
+    #[test]
+    fn test_process_line_emit_metadata() -> Result<(), String> {
+        let mut metadata_emitted = false;
+        assert!(matches!(
+            process_line(
+                r#"
+                {
+                    "$message_type": "artifact",
+                    "emit": "metadata"
+                }
+            "#
+                .to_string(),
+                /*quit_on_rmeta=*/ true,
+                ErrorFormat::Rendered,
+                &mut metadata_emitted,
+            )?,
+            LineOutput::Terminate
+        ));
+        assert!(metadata_emitted);
+        Ok(())
+    }
+}