Consume diagnostics when emitting them.

Author: cjgillot

src/librustc_codegen_ssa/back/write.rs

@@ -1612,7 +1612,7 @@ impl SharedEmitterMain {
                     if let Some(code) = diag.code {
                         d.code(code);
                     }
-                    handler.emit_diagnostic(&d);
+                    handler.emit_diagnostic(d);
                 }
                 Ok(SharedEmitterMessage::InlineAsmError(cookie, msg)) => {
                     sess.span_err(ExpnId::from_u32(cookie).expn_data().call_site, &msg)

src/librustc_driver/lib.rs

@@ -1173,7 +1173,7 @@ pub fn report_ice(info: &panic::PanicInfo<'_>, bug_report_url: &str) {
     // it wants to print.
     if !info.payload().is::<rustc_errors::ExplicitBug>() {
         let d = rustc_errors::Diagnostic::new(rustc_errors::Level::Bug, "unexpected panic");
-        handler.emit_diagnostic(&d);
+        handler.emit_diagnostic(d);
     }
 
     let mut xs: Vec<Cow<'static, str>> = vec![

src/librustc_errors/diagnostic_builder.rs

@@ -97,8 +97,8 @@ impl<'a> DerefMut for DiagnosticBuilder<'a> {
 impl<'a> DiagnosticBuilder<'a> {
     /// Emit the diagnostic.
     pub fn emit(&mut self) {
-        self.0.handler.emit_diagnostic(&self);
-        self.cancel();
+        let diag = std::mem::replace(&mut self.0.diagnostic, Diagnostic::new(Level::Cancelled, ""));
+        self.0.handler.emit_diagnostic(diag);
     }
 
     /// Emit the diagnostic unless `delay` is true,
@@ -179,8 +179,8 @@ impl<'a> DiagnosticBuilder<'a> {
     /// locally in whichever way makes the most sense.
     pub fn delay_as_bug(&mut self) {
         self.level = Level::Bug;
-        self.0.handler.delay_as_bug(self.0.diagnostic.clone());
-        self.cancel();
+        let diag = std::mem::replace(&mut self.0.diagnostic, Diagnostic::new(Level::Cancelled, ""));
+        self.0.handler.delay_as_bug(diag);
     }
 
     /// Adds a span/label to be included in the resulting snippet.

src/librustc_errors/lib.rs

@@ -326,10 +326,12 @@ pub enum StashKey {
     ItemNoType,
 }
 
-fn default_track_diagnostic(_: &Diagnostic) {}
+fn default_track_diagnostic(d: Diagnostic) -> Diagnostic {
+    d
+}
 
-pub static TRACK_DIAGNOSTICS: AtomicRef<fn(&Diagnostic)> =
-    AtomicRef::new(&(default_track_diagnostic as fn(&_)));
+pub static TRACK_DIAGNOSTICS: AtomicRef<fn(Diagnostic) -> Diagnostic> =
+    AtomicRef::new(&(default_track_diagnostic as fn(_) -> _));
 
 #[derive(Copy, Clone, Default)]
 pub struct HandlerFlags {
@@ -359,8 +361,8 @@ impl Drop for HandlerInner {
         if !self.has_errors() {
             let bugs = std::mem::replace(&mut self.delayed_span_bugs, Vec::new());
             let has_bugs = !bugs.is_empty();
-            for bug in bugs {
-                self.emit_diagnostic(&bug);
+            for bug in bugs.into_iter() {
+                self.emit_diagnostic(bug);
             }
             if has_bugs {
                 panic!("no errors encountered even though `delay_span_bug` issued");
@@ -691,13 +693,14 @@ impl Handler {
         self.inner.borrow_mut().force_print_diagnostic(db)
     }
 
-    pub fn emit_diagnostic(&self, diagnostic: &Diagnostic) {
+    pub fn emit_diagnostic(&self, diagnostic: Diagnostic) {
         self.inner.borrow_mut().emit_diagnostic(diagnostic)
     }
 
     fn emit_diag_at_span(&self, mut diag: Diagnostic, sp: impl Into<MultiSpan>) {
         let mut inner = self.inner.borrow_mut();
-        inner.emit_diagnostic(diag.set_span(sp));
+        diag.set_span(sp);
+        inner.emit_diagnostic(diag);
     }
 
     pub fn emit_artifact_notification(&self, path: &Path, artifact_type: &str) {
@@ -721,10 +724,10 @@ impl HandlerInner {
     /// Emit all stashed diagnostics.
     fn emit_stashed_diagnostics(&mut self) {
         let diags = self.stashed_diagnostics.drain(..).map(|x| x.1).collect::<Vec<_>>();
-        diags.iter().for_each(|diag| self.emit_diagnostic(diag));
+        diags.into_iter().for_each(|diag| self.emit_diagnostic(diag));
     }
 
-    fn emit_diagnostic(&mut self, diagnostic: &Diagnostic) {
+    fn emit_diagnostic(&mut self, diagnostic: Diagnostic) {
         if diagnostic.cancelled() {
             return;
         }
@@ -733,7 +736,7 @@ impl HandlerInner {
             return;
         }
 
-        (*TRACK_DIAGNOSTICS)(diagnostic);
+        let diagnostic = (*TRACK_DIAGNOSTICS)(diagnostic);
 
         if let Some(ref code) = diagnostic.code {
             self.emitted_diagnostic_codes.insert(code.clone());
@@ -750,7 +753,7 @@ impl HandlerInner {
         // Only emit the diagnostic if we've been asked to deduplicate and
         // haven't already emitted an equivalent diagnostic.
         if !(self.flags.deduplicate_diagnostics && already_emitted(self)) {
-            self.emitter.emit_diagnostic(diagnostic);
+            self.emitter.emit_diagnostic(&diagnostic);
             if diagnostic.is_error() {
                 self.deduplicated_err_count += 1;
             } else if diagnostic.level == Warning {
@@ -789,7 +792,7 @@ impl HandlerInner {
 
         match (errors.len(), warnings.len()) {
             (0, 0) => return,
-            (0, _) => self.emit_diagnostic(&Diagnostic::new(Level::Warning, &warnings)),
+            (0, _) => self.emit_diagnostic(Diagnostic::new(Level::Warning, &warnings)),
             (_, 0) => {
                 let _ = self.fatal(&errors);
             }
@@ -865,7 +868,8 @@ impl HandlerInner {
     }
 
     fn emit_diag_at_span(&mut self, mut diag: Diagnostic, sp: impl Into<MultiSpan>) {
-        self.emit_diagnostic(diag.set_span(sp));
+        diag.set_span(sp);
+        self.emit_diagnostic(diag);
     }
 
     fn delay_span_bug(&mut self, sp: impl Into<MultiSpan>, msg: &str) {
@@ -882,7 +886,7 @@ impl HandlerInner {
     }
 
     fn failure(&mut self, msg: &str) {
-        self.emit_diagnostic(&Diagnostic::new(FailureNote, msg));
+        self.emit_diagnostic(Diagnostic::new(FailureNote, msg));
     }
 
     fn fatal(&mut self, msg: &str) -> FatalError {
@@ -899,17 +903,17 @@ impl HandlerInner {
         if self.treat_err_as_bug() {
             self.bug(msg);
         }
-        self.emit_diagnostic(&Diagnostic::new(level, msg));
+        self.emit_diagnostic(Diagnostic::new(level, msg));
     }
 
     fn bug(&mut self, msg: &str) -> ! {
-        self.emit_diagnostic(&Diagnostic::new(Bug, msg));
+        self.emit_diagnostic(Diagnostic::new(Bug, msg));
         panic!(ExplicitBug);
     }
 
     fn delay_as_bug(&mut self, diagnostic: Diagnostic) {
         if self.flags.report_delayed_bugs {
-            self.emit_diagnostic(&diagnostic);
+            self.emit_diagnostic(diagnostic.clone());
         }
         self.delayed_span_bugs.push(diagnostic);
     }

src/librustc_expand/proc_macro_server.rs

@@ -634,7 +634,7 @@ impl server::Diagnostic for Rustc<'_> {
         diag.sub(level.to_internal(), msg, MultiSpan::from_spans(spans), None);
     }
     fn emit(&mut self, diag: Self::Diagnostic) {
-        self.sess.span_diagnostic.emit_diagnostic(&diag);
+        self.sess.span_diagnostic.emit_diagnostic(diag);
     }
 }
 

src/librustc_interface/callbacks.rs

@@ -28,15 +28,16 @@ fn span_debug(span: rustc_span::Span, f: &mut fmt::Formatter<'_>) -> fmt::Result
 /// This is a callback from librustc_ast as it cannot access the implicit state
 /// in librustc_middle otherwise. It is used to when diagnostic messages are
 /// emitted and stores them in the current query, if there is one.
-fn track_diagnostic(diagnostic: &Diagnostic) {
+fn track_diagnostic(diagnostic: Diagnostic) -> Diagnostic {
     tls::with_context_opt(|icx| {
         if let Some(icx) = icx {
             if let Some(ref diagnostics) = icx.diagnostics {
                 let mut diagnostics = diagnostics.lock();
                 diagnostics.extend(Some(diagnostic.clone()));
             }
         }
-    })
+    });
+    diagnostic
 }
 
 /// This is a callback from librustc_hir as it cannot access the implicit state
@@ -57,5 +58,5 @@ fn def_id_debug(def_id: rustc_hir::def_id::DefId, f: &mut fmt::Formatter<'_>) ->
 pub fn setup_callbacks() {
     rustc_span::SPAN_DEBUG.swap(&(span_debug as fn(_, &mut fmt::Formatter<'_>) -> _));
     rustc_hir::def_id::DEF_ID_DEBUG.swap(&(def_id_debug as fn(_, &mut fmt::Formatter<'_>) -> _));
-    TRACK_DIAGNOSTICS.swap(&(track_diagnostic as fn(&_)));
+    TRACK_DIAGNOSTICS.swap(&(track_diagnostic as fn(_) -> _));
 }

src/librustc_mir/borrow_check/mod.rs

@@ -441,7 +441,7 @@ fn do_mir_borrowck<'a, 'tcx>(
         mbcx.errors_buffer.sort_by_key(|diag| diag.sort_span);
 
         for diag in mbcx.errors_buffer.drain(..) {
-            mbcx.infcx.tcx.sess.diagnostic().emit_diagnostic(&diag);
+            mbcx.infcx.tcx.sess.diagnostic().emit_diagnostic(diag);
         }
     }
 

src/librustc_parse/lib.rs

@@ -42,7 +42,7 @@ macro_rules! panictry_buffer {
             Ok(e) => e,
             Err(errs) => {
                 for e in errs {
-                    $handler.emit_diagnostic(&e);
+                    $handler.emit_diagnostic(e);
                 }
                 FatalError.raise()
             }
@@ -176,7 +176,7 @@ fn file_to_source_file(sess: &ParseSess, path: &Path, spanopt: Option<Span>) ->
     match try_file_to_source_file(sess, path, spanopt) {
         Ok(source_file) => source_file,
         Err(d) => {
-            sess.span_diagnostic.emit_diagnostic(&d);
+            sess.span_diagnostic.emit_diagnostic(d);
             FatalError.raise();
         }
     }

src/librustc_query_system/dep_graph/graph.rs

@@ -763,7 +763,7 @@ impl<K: DepKind> DepGraph<K> {
             let handle = tcx.diagnostic();
 
             for diagnostic in diagnostics {
-                handle.emit_diagnostic(&diagnostic);
+                handle.emit_diagnostic(diagnostic);
             }
 
             // Mark the node as green now that diagnostics are emitted

src/librustc_typeck/check/writeback.rs

@@ -403,7 +403,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
         if !errors_buffer.is_empty() {
             errors_buffer.sort_by_key(|diag| diag.span.primary_span());
             for diag in errors_buffer.drain(..) {
-                self.tcx().sess.diagnostic().emit_diagnostic(&diag);
+                self.tcx().sess.diagnostic().emit_diagnostic(diag);
             }
         }
     }