Invert control in struct_lint_level.

Caller now passes in a `decorate` function, which is only run if the
lint is allowed.

Author: jumbatm

src/librustc/infer/error_reporting/mod.rs

@@ -1670,7 +1670,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         sub: Region<'tcx>,
     ) {
         self.construct_generic_bound_failure(region_scope_tree, span, origin, bound_kind, sub)
-            .emit()
+            .emit();
     }
 
     pub fn construct_generic_bound_failure(

src/librustc/lint.rs

@@ -11,6 +11,7 @@ use rustc_span::hygiene::MacroKind;
 use rustc_span::source_map::{DesugaringKind, ExpnKind, MultiSpan};
 use rustc_span::{Span, Symbol};
 
+
 /// How a lint level was set.
 #[derive(Clone, Copy, PartialEq, Eq, HashStable)]
 pub enum LintSource {
@@ -174,20 +175,37 @@ impl<'a> HashStable<StableHashingContext<'a>> for LintLevelMap {
     }
 }
 
-pub fn struct_lint_level<'a>(
-    sess: &'a Session,
+
+pub struct LintDiagnosticBuilder<'a>(DiagnosticBuilder<'a>);
+
+impl<'a> LintDiagnosticBuilder<'a> {
+    /// Return the inner DiagnosticBuilder, first setting the primary message to `msg`.
+    pub fn build(mut self, msg: &str) -> DiagnosticBuilder<'a> {
+        self.0.set_primary_message(msg);
+        self.0
+    }
+
+    /// Create a LintDiagnosticBuilder from some existing DiagnosticBuilder.
+    pub fn new(err: DiagnosticBuilder<'a>) -> LintDiagnosticBuilder<'a>{
+        LintDiagnosticBuilder(err)
+    }
+}
+
+pub fn struct_lint_level<'s>(
+    sess: &'s Session,
     lint: &'static Lint,
     level: Level,
     src: LintSource,
     span: Option<MultiSpan>,
-    msg: &str,
-) -> DiagnosticBuilder<'a> {
+    decorate: impl for<'a> FnOnce(LintDiagnosticBuilder<'a>)) {
+
+    // FIXME: Move the guts of this function into a fn which takes dyn Fn to reduce code bloat.
     let mut err = match (level, span) {
-        (Level::Allow, _) => return sess.diagnostic().struct_dummy(),
-        (Level::Warn, Some(span)) => sess.struct_span_warn(span, msg),
-        (Level::Warn, None) => sess.struct_warn(msg),
-        (Level::Deny, Some(span)) | (Level::Forbid, Some(span)) => sess.struct_span_err(span, msg),
-        (Level::Deny, None) | (Level::Forbid, None) => sess.struct_err(msg),
+        (Level::Allow, _) => { return; },
+        (Level::Warn, Some(span)) => sess.struct_span_warn(span, ""),
+        (Level::Warn, None) => sess.struct_warn(""),
+        (Level::Deny, Some(span)) | (Level::Forbid, Some(span)) => sess.struct_span_err(span, ""),
+        (Level::Deny, None) | (Level::Forbid, None) => sess.struct_err(""),
     };
 
     // Check for future incompatibility lints and issue a stronger warning.
@@ -209,7 +227,7 @@ pub fn struct_lint_level<'a>(
             err.cancel();
             // Don't continue further, since we don't want to have
             // `diag_span_note_once` called for a diagnostic that isn't emitted.
-            return err;
+            return;
         }
     }
 
@@ -299,7 +317,8 @@ pub fn struct_lint_level<'a>(
         err.note(&citation);
     }
 
-    return err;
+    // Finally, run `decorate`. This function is also responsible for emitting the diagnostic.
+    decorate(LintDiagnosticBuilder::new(err));
 }
 
 /// Returns whether `span` originates in a foreign crate's external macro.

src/librustc/middle/stability.rs

@@ -222,11 +222,13 @@ fn late_report_deprecation(
         return;
     }
 
-    let mut diag = tcx.struct_span_lint_hir(lint, hir_id, span, message);
-    if let hir::Node::Expr(_) = tcx.hir().get(hir_id) {
-        deprecation_suggestion(&mut diag, suggestion, span);
-    }
-    diag.emit();
+    tcx.struct_span_lint_hir(lint, hir_id, span, |lint| {
+        let mut diag = lint.build(message);
+        if let hir::Node::Expr(_) = tcx.hir().get(hir_id) {
+            deprecation_suggestion(&mut diag, suggestion, span);
+        }
+        diag.emit()
+    });
     if hir_id == hir::DUMMY_HIR_ID {
         span_bug!(span, "emitted a {} lint with dummy HIR id: {:?}", lint.name, def_id);
     }
@@ -387,8 +389,11 @@ impl<'tcx> TyCtxt<'tcx> {
     /// Additionally, this function will also check if the item is deprecated. If so, and `id` is
     /// not `None`, a deprecated lint attached to `id` will be emitted.
     pub fn check_stability(self, def_id: DefId, id: Option<HirId>, span: Span) {
-        let soft_handler =
-            |lint, span, msg: &_| self.lint_hir(lint, id.unwrap_or(hir::CRATE_HIR_ID), span, msg);
+        let soft_handler = |lint, span, msg: &_| {
+            self.struct_span_lint_hir(lint, id.unwrap_or(hir::CRATE_HIR_ID), span, |lint| {
+                lint.build(msg).emit()
+            })
+        };
         match self.eval_stability(def_id, id, span) {
             EvalResult::Allow => {}
             EvalResult::Deny { feature, reason, issue, is_soft } => {

src/librustc/mir/interpret/error.rs

@@ -83,18 +83,15 @@ impl<'tcx> ConstEvalErr<'tcx> {
         &self,
         tcx: TyCtxtAt<'tcx>,
         message: &str,
-    ) -> Result<DiagnosticBuilder<'tcx>, ErrorHandled> {
-        self.struct_generic(tcx, message, None)
+        emit: impl FnOnce(DiagnosticBuilder<'_>),
+    ) -> Result<(), ErrorHandled> {
+        self.struct_generic(tcx, message, emit, None)
     }
 
     pub fn report_as_error(&self, tcx: TyCtxtAt<'tcx>, message: &str) -> ErrorHandled {
-        let err = self.struct_error(tcx, message);
-        match err {
-            Ok(mut err) => {
-                err.emit();
-                ErrorHandled::Reported
-            }
-            Err(err) => err,
+        match self.struct_error(tcx, message, |mut e| e.emit()) {
+            Ok(_) => ErrorHandled::Reported,
+            Err(x) => x,
         }
     }
 
@@ -105,9 +102,11 @@ impl<'tcx> ConstEvalErr<'tcx> {
         lint_root: hir::HirId,
         span: Option<Span>,
     ) -> ErrorHandled {
-        let lint = self.struct_generic(tcx, message, Some(lint_root));
-        match lint {
-            Ok(mut lint) => {
+        match self.struct_generic(
+            tcx,
+            message,
+            |mut lint: DiagnosticBuilder<'_>| {
+                // Apply the span.
                 if let Some(span) = span {
                     let primary_spans = lint.span.primary_spans().to_vec();
                     // point at the actual error as the primary span
@@ -121,18 +120,26 @@ impl<'tcx> ConstEvalErr<'tcx> {
                     }
                 }
                 lint.emit();
+            }
+        , Some(lint_root)) {
+            Ok(_) => {
                 ErrorHandled::Reported
             }
             Err(err) => err,
         }
     }
 
+   /// Sets the message passed in via `message`, then adds the span labels for you, before applying
+   /// further modifications in `emit`. It's up to you to call emit(), stash(..), etc. within the
+   /// `emit` method. If you don't need to do any additional processing, just use
+   /// struct_generic.
     fn struct_generic(
         &self,
         tcx: TyCtxtAt<'tcx>,
         message: &str,
+        emit: impl FnOnce(DiagnosticBuilder<'_>),
         lint_root: Option<hir::HirId>,
-    ) -> Result<DiagnosticBuilder<'tcx>, ErrorHandled> {
+    ) -> Result<(), ErrorHandled> {
         let must_error = match self.error {
             InterpError::MachineStop(_) => bug!("CTFE does not stop"),
             err_inval!(Layout(LayoutError::Unknown(_))) | err_inval!(TooGeneric) => {
@@ -143,7 +150,22 @@ impl<'tcx> ConstEvalErr<'tcx> {
             _ => false,
         };
         trace!("reporting const eval failure at {:?}", self.span);
-        let mut err = if let (Some(lint_root), false) = (lint_root, must_error) {
+
+        let add_span_labels = |err: &mut DiagnosticBuilder<'_>| {
+            if !must_error {
+                err.span_label(self.span, self.error.to_string());
+            }
+            // Skip the last, which is just the environment of the constant.  The stacktrace
+            // is sometimes empty because we create "fake" eval contexts in CTFE to do work
+            // on constant values.
+            if self.stacktrace.len() > 0 {
+                for frame_info in &self.stacktrace[..self.stacktrace.len() - 1] {
+                    err.span_label(frame_info.call_site, frame_info.to_string());
+                }
+            }
+        };
+
+        if let (Some(lint_root), false) = (lint_root, must_error) {
             let hir_id = self
                 .stacktrace
                 .iter()
@@ -155,25 +177,22 @@ impl<'tcx> ConstEvalErr<'tcx> {
                 rustc_session::lint::builtin::CONST_ERR,
                 hir_id,
                 tcx.span,
-                message,
-            )
-        } else if must_error {
-            struct_error(tcx, &self.error.to_string())
+                |lint| {
+                    let mut err = lint.build(message);
+                    add_span_labels(&mut err);
+                    emit(err);
+                },
+            );
         } else {
-            struct_error(tcx, message)
+            let mut err = if must_error {
+                struct_error(tcx, &self.error.to_string())
+            } else {
+                struct_error(tcx, message)
+            };
+            add_span_labels(&mut err);
+            emit(err);
         };
-        if !must_error {
-            err.span_label(self.span, self.error.to_string());
-        }
-        // Skip the last, which is just the environment of the constant.  The stacktrace
-        // is sometimes empty because we create "fake" eval contexts in CTFE to do work
-        // on constant values.
-        if self.stacktrace.len() > 0 {
-            for frame_info in &self.stacktrace[..self.stacktrace.len() - 1] {
-                err.span_label(frame_info.call_site, frame_info.to_string());
-            }
-        }
-        Ok(err)
+        Ok(())
     }
 }
 

src/librustc/traits/object_safety.rs

@@ -183,13 +183,16 @@ fn object_safety_violations_for_trait(
                     WHERE_CLAUSES_OBJECT_SAFETY,
                     hir::CRATE_HIR_ID,
                     *span,
-                    &format!(
-                        "the trait `{}` cannot be made into an object",
-                        tcx.def_path_str(trait_def_id)
-                    ),
-                )
-                .note(&violation.error_msg())
-                .emit();
+                    |lint| {
+                        lint.build(
+                        &format!(
+                            "the trait `{}` cannot be made into an object",
+                            tcx.def_path_str(trait_def_id)
+                        ))
+                        .note(&violation.error_msg())
+                        .emit()
+                    },
+                );
                 false
             } else {
                 true