Overhaul rustc_codegen_ssa::back::write::Diagnostic.

- Make it more closely match `rustc_errors::Diagnostic`, by making the
  field names match, and adding `children`, which requires adding
  `rustc_codegen_ssa::back::write::Subdiagnostic`.
- Check that we aren't missing important info when converting
  diagnostics.
- Add better comments.
- Tweak `rustc_errors::Diagnostic::replace_args` so that we don't need
  to do any cloning when converting diagnostics.

Author: nnethercote

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -17,7 +17,7 @@ use rustc_errors::emitter::Emitter;
 use rustc_errors::translation::Translate;
 use rustc_errors::{
     DiagCtxt, DiagnosticArgName, DiagnosticArgValue, DiagnosticBuilder, DiagnosticMessage, ErrCode,
-    FatalError, FluentBundle, Level, Style,
+    FatalError, FluentBundle, Level, MultiSpan, Style,
 };
 use rustc_fs_util::link_or_copy;
 use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
@@ -999,11 +999,28 @@ pub(crate) enum Message<B: WriteBackendMethods> {
 /// process another codegen unit.
 pub struct CguMessage;
 
+// A cut-down version of `rustc_errors::Diagnostic` that impls `Send`, which
+// can be used to send diagnostics from codegen threads to the main thread.
+// It's missing the following fields from `rustc_errors::Diagnostic`.
+// - `span`: because `MultiSpan` doesn't impl `Send`.
+// - `suggestions`: because it doesn't impl `Send`, and is not worth the complexity.
+// - `sort_span`: because `Span` doesn't impl `Send`.
+// - `is_lint`: because lints aren't relevant during codegen.
+// - `emitted_at`: not worth the complexity.
 struct Diagnostic {
-    msgs: Vec<(DiagnosticMessage, Style)>,
-    args: FxHashMap<DiagnosticArgName, DiagnosticArgValue>,
+    level: Level,
+    messages: Vec<(DiagnosticMessage, Style)>,
     code: Option<ErrCode>,
-    lvl: Level,
+    children: Vec<Subdiagnostic>,
+    args: FxHashMap<DiagnosticArgName, DiagnosticArgValue>,
+}
+
+// A cut-down version of `rustc_errors::SubDiagnostic` that impls `Send`. It's
+// missing the following fields from `rustc_errors::SubDiagnostic`.
+// - `span`: because `MultiSpan` doesn't impl `Send`.
+pub struct Subdiagnostic {
+    level: Level,
+    messages: Vec<(DiagnosticMessage, Style)>,
 }
 
 #[derive(PartialEq, Clone, Copy, Debug)]
@@ -1812,23 +1829,29 @@ impl Translate for SharedEmitter {
 }
 
 impl Emitter for SharedEmitter {
-    fn emit_diagnostic(&mut self, diag: rustc_errors::Diagnostic) {
-        let args: FxHashMap<DiagnosticArgName, DiagnosticArgValue> =
-            diag.args().map(|(name, arg)| (name.clone(), arg.clone())).collect();
-        drop(self.sender.send(SharedEmitterMessage::Diagnostic(Diagnostic {
-            msgs: diag.messages.clone(),
-            args: args.clone(),
-            code: diag.code,
-            lvl: diag.level(),
-        })));
-        for child in &diag.children {
-            drop(self.sender.send(SharedEmitterMessage::Diagnostic(Diagnostic {
-                msgs: child.messages.clone(),
-                args: args.clone(),
-                code: None,
-                lvl: child.level,
-            })));
-        }
+    fn emit_diagnostic(&mut self, mut diag: rustc_errors::Diagnostic) {
+        // Check that we aren't missing anything interesting when converting to
+        // the cut-down local `Diagnostic`.
+        assert_eq!(diag.span, MultiSpan::new());
+        assert_eq!(diag.suggestions, Ok(vec![]));
+        assert_eq!(diag.sort_span, rustc_span::DUMMY_SP);
+        assert_eq!(diag.is_lint, None);
+        // No sensible check for `diag.emitted_at`.
+
+        let args = diag.replace_args(FxHashMap::default());
+        drop(
+            self.sender.send(SharedEmitterMessage::Diagnostic(Diagnostic {
+                level: diag.level(),
+                messages: diag.messages,
+                code: diag.code,
+                children: diag
+                    .children
+                    .into_iter()
+                    .map(|child| Subdiagnostic { level: child.level, messages: child.messages })
+                    .collect(),
+                args,
+            })),
+        );
         drop(self.sender.send(SharedEmitterMessage::AbortIfErrors));
     }
 
@@ -1854,11 +1877,21 @@ impl SharedEmitterMain {
 
             match message {
                 Ok(SharedEmitterMessage::Diagnostic(diag)) => {
+                    // The diagnostic has been received on the main thread.
+                    // Convert it back to a full `Diagnostic` and emit.
                     let dcx = sess.dcx();
-                    let mut d = rustc_errors::Diagnostic::new_with_messages(diag.lvl, diag.msgs);
-                    if let Some(code) = diag.code {
-                        d.code(code);
-                    }
+                    let mut d =
+                        rustc_errors::Diagnostic::new_with_messages(diag.level, diag.messages);
+                    d.code = diag.code;
+                    d.children = diag
+                        .children
+                        .into_iter()
+                        .map(|sub| rustc_errors::SubDiagnostic {
+                            level: sub.level,
+                            messages: sub.messages,
+                            span: MultiSpan::new(),
+                        })
+                        .collect();
                     d.replace_args(diag.args);
                     dcx.emit_diagnostic(d);
                 }

compiler/rustc_errors/src/diagnostic.rs

@@ -105,6 +105,9 @@ pub struct Diagnostic {
     pub span: MultiSpan,
     pub children: Vec<SubDiagnostic>,
     pub suggestions: Result<Vec<CodeSuggestion>, SuggestionsDisabled>,
+
+    // Non-`pub` so that the getter method can be marked with
+    // `#[allow(rustc::potential_query_instability)]`.
     args: FxHashMap<DiagnosticArgName, DiagnosticArgValue>,
 
     /// This is not used for highlighting or rendering any error message. Rather, it can be used
@@ -914,8 +917,11 @@ impl Diagnostic {
         self
     }
 
-    pub fn replace_args(&mut self, args: FxHashMap<DiagnosticArgName, DiagnosticArgValue>) {
-        self.args = args;
+    pub fn replace_args(
+        &mut self,
+        args: FxHashMap<DiagnosticArgName, DiagnosticArgValue>,
+    ) -> FxHashMap<DiagnosticArgName, DiagnosticArgValue> {
+        std::mem::replace(&mut self.args, args)
     }
 
     /// Helper function that takes a `SubdiagnosticMessage` and returns a `DiagnosticMessage` by

tests/ui/lto/issue-11154.stderr

@@ -1,6 +1,6 @@
 error: cannot prefer dynamic linking when performing LTO
-
-note: only 'staticlib', 'bin', and 'cdylib' outputs are supported with LTO
+   |
+   = note: only 'staticlib', 'bin', and 'cdylib' outputs are supported with LTO
 
 error: aborting due to 1 previous error