Make cx.span_lint methods lazy

jumbatm · jumbatm · commit eaf8fa7d4179 · 2020-02-03T21:21:02.000+10:00
- Make report_unsafe take decorate function
- Remove span_lint, replacing calls with struct_span_lint, as caller is
now responsible for emitting.
- Remove lookup_and_emit, replacing with just lookup which takes a
decorate function.
- Remove span_lint_note, span_lint_help.  These methods aren't easily
made lazy as standalone methods, private, and unused. If this
functionality is needed, to be lazy, they can easily be made into
Fn(&amp;mut DiagnosticBuilder) that are meant to be called _within_ the
decorate function.
- Rename lookup_and_emit_with_diagnostics to lookup_with_diagnostics to
better reflect the fact that it doesn't emit for you.
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
@@ -28,6 +28,7 @@ use rustc::ty::{self, layout::VariantIdx, Ty, TyCtxt};
 use rustc_ast_pretty::pprust::{self, expr_to_string};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::{Applicability, DiagnosticBuilder};
+use rustc::lint::LintDiagnosticBuilder;
 use rustc_feature::Stability;
 use rustc_feature::{deprecated_attributes, AttributeGate, AttributeTemplate, AttributeType};
 use rustc_hir as hir;
@@ -106,8 +107,7 @@ impl BoxPointers {
     fn check_heap_type(&self, cx: &LateContext<'_, '_>, span: Span, ty: Ty<'_>) {
         for leaf_ty in ty.walk() {
             if leaf_ty.is_box() {
-                let m = format!("type uses owned (Box type) pointers: {}", ty);
-                cx.span_lint(BOX_POINTERS, span, &m);
+                cx.struct_span_lint(BOX_POINTERS, span, |lint| lint.build(&format!("type uses owned (Box type) pointers: {}", ty)).emit());
             }
         }
     }
@@ -214,13 +214,13 @@ declare_lint! {
 declare_lint_pass!(UnsafeCode => [UNSAFE_CODE]);
 
 impl UnsafeCode {
-    fn report_unsafe(&self, cx: &EarlyContext<'_>, span: Span, desc: &'static str) {
+    fn report_unsafe(&self, cx: &EarlyContext<'_>, span: Span, decorate: impl for<'a> FnOnce(LintDiagnosticBuilder<'a>)) {
         // This comes from a macro that has `#[allow_internal_unsafe]`.
         if span.allows_unsafe() {
             return;
         }
 
-        cx.span_lint(UNSAFE_CODE, span, desc);
+        cx.struct_span_lint(UNSAFE_CODE, span, decorate);
     }
 }
 
@@ -230,9 +230,9 @@ impl EarlyLintPass for UnsafeCode {
             self.report_unsafe(
                 cx,
                 attr.span,
-                "`allow_internal_unsafe` allows defining \
+                |lint| lint.build("`allow_internal_unsafe` allows defining \
                                                macros using unsafe without triggering \
-                                               the `unsafe_code` lint at their call site",
+                                               the `unsafe_code` lint at their call site").emit(),
             );
         }
     }
@@ -241,19 +241,19 @@ impl EarlyLintPass for UnsafeCode {
         if let ast::ExprKind::Block(ref blk, _) = e.kind {
             // Don't warn about generated blocks; that'll just pollute the output.
             if blk.rules == ast::BlockCheckMode::Unsafe(ast::UserProvided) {
-                self.report_unsafe(cx, blk.span, "usage of an `unsafe` block");
+                self.report_unsafe(cx, blk.span, |lint| lint.build("usage of an `unsafe` block").emit());
             }
         }
     }
 
     fn check_item(&mut self, cx: &EarlyContext<'_>, it: &ast::Item) {
         match it.kind {
             ast::ItemKind::Trait(_, ast::Unsafety::Unsafe, ..) => {
-                self.report_unsafe(cx, it.span, "declaration of an `unsafe` trait")
+                self.report_unsafe(cx, it.span, |lint| lint.build("declaration of an `unsafe` trait").emit())
             }
 
             ast::ItemKind::Impl { unsafety: ast::Unsafety::Unsafe, .. } => {
-                self.report_unsafe(cx, it.span, "implementation of an `unsafe` trait")
+                self.report_unsafe(cx, it.span, |lint| lint.build("implementation of an `unsafe` trait").emit())
             }
 
             _ => return,
@@ -270,12 +270,12 @@ impl EarlyLintPass for UnsafeCode {
     ) {
         match fk {
             FnKind::ItemFn(_, ast::FnHeader { unsafety: ast::Unsafety::Unsafe, .. }, ..) => {
-                self.report_unsafe(cx, span, "declaration of an `unsafe` function")
+                self.report_unsafe(cx, span, |lint| lint.build("declaration of an `unsafe` function").emit())
             }
 
             FnKind::Method(_, sig, ..) => {
                 if sig.header.unsafety == ast::Unsafety::Unsafe {
-                    self.report_unsafe(cx, span, "implementation of an `unsafe` method")
+                    self.report_unsafe(cx, span, |lint| lint.build("implementation of an `unsafe` method").emit())
                 }
             }
 
@@ -286,7 +286,7 @@ impl EarlyLintPass for UnsafeCode {
     fn check_trait_item(&mut self, cx: &EarlyContext<'_>, item: &ast::AssocItem) {
         if let ast::AssocItemKind::Fn(ref sig, None) = item.kind {
             if sig.header.unsafety == ast::Unsafety::Unsafe {
-                self.report_unsafe(cx, item.span, "declaration of an `unsafe` method")
+                self.report_unsafe(cx, item.span, |lint| lint.build("declaration of an `unsafe` method").emit())
             }
         }
     }
@@ -372,10 +372,10 @@ impl MissingDoc {
 
         let has_doc = attrs.iter().any(|a| has_doc(a));
         if !has_doc {
-            cx.span_lint(
+            cx.struct_span_lint(
                 MISSING_DOCS,
                 cx.tcx.sess.source_map().def_span(sp),
-                &format!("missing documentation for {}", desc),
+                |lint| lint.build(&format!("missing documentation for {}", desc)).emit(),
             );
         }
     }
@@ -404,10 +404,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {
         for macro_def in krate.exported_macros {
             let has_doc = macro_def.attrs.iter().any(|a| has_doc(a));
             if !has_doc {
-                cx.span_lint(
+                cx.struct_span_lint(
                     MISSING_DOCS,
                     cx.tcx.sess.source_map().def_span(macro_def.span),
-                    "missing documentation for macro",
+                    |lint| lint.build("missing documentation for macro").emit(),
                 );
             }
         }
@@ -555,11 +555,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingCopyImplementations {
             return;
         }
         if can_type_implement_copy(cx.tcx, param_env, ty).is_ok() {
-            cx.span_lint(
+            cx.struct_span_lint(
                 MISSING_COPY_IMPLEMENTATIONS,
                 item.span,
-                "type could implement `Copy`; consider adding `impl \
-                          Copy`",
+                |lint| lint.build("type could implement `Copy`; consider adding `impl \
+                          Copy`").emit(),
             )
         }
     }
@@ -609,11 +609,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDebugImplementations {
         }
 
         if !self.impling_types.as_ref().unwrap().contains(&item.hir_id) {
-            cx.span_lint(
+            cx.struct_span_lint(
                 MISSING_DEBUG_IMPLEMENTATIONS,
                 item.span,
-                "type does not implement `fmt::Debug`; consider adding `#[derive(Debug)]` \
-                          or a manual implementation",
+                |lint| lint.build("type does not implement `fmt::Debug`; consider adding `#[derive(Debug)]` \
+                          or a manual implementation").emit(),
             )
         }
     }
@@ -912,7 +912,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MutableTransmutes {
         match get_transmute_from_to(cx, expr).map(|(ty1, ty2)| (&ty1.kind, &ty2.kind)) {
             Some((&ty::Ref(_, _, from_mt), &ty::Ref(_, _, to_mt))) => {
                 if to_mt == hir::Mutability::Mut && from_mt == hir::Mutability::Not {
-                    cx.span_lint(MUTABLE_TRANSMUTES, expr.span, msg);
+                    cx.struct_span_lint(MUTABLE_TRANSMUTES, expr.span, |lint| lint.build(msg).emit());
                 }
             }
             _ => (),
@@ -962,7 +962,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnstableFeatures {
         if attr.check_name(sym::feature) {
             if let Some(items) = attr.meta_item_list() {
                 for item in items {
-                    ctx.span_lint(UNSTABLE_FEATURES, item.span(), "unstable feature");
+                    ctx.struct_span_lint(UNSTABLE_FEATURES, item.span(), |lint| lint.build("unstable feature").emit());
                 }
             }
         }
@@ -1244,14 +1244,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TrivialConstraints {
                     ConstEvaluatable(..) => continue,
                 };
                 if predicate.is_global() {
-                    cx.span_lint(
+                    cx.struct_span_lint(
                         TRIVIAL_BOUNDS,
                         span,
-                        &format!(
+                        |lint| lint.build(&format!(
                             "{} bound {} does not depend on any type \
                                 or lifetime parameters",
                             predicate_kind_name, predicate
-                        ),
+                        )).emit(),
                     );
                 }
             }
diff --git a/src/librustc_lint/context.rs b/src/librustc_lint/context.rs
@@ -474,19 +474,18 @@ pub trait LintContext: Sized {
     fn sess(&self) -> &Session;
     fn lints(&self) -> &LintStore;
 
-    fn lookup_and_emit<S: Into<MultiSpan>>(&self, lint: &'static Lint, span: Option<S>, msg: &str) {
-        self.lookup(lint, span, |lint| lint.build(msg).emit());
-    }
-
-    fn lookup_and_emit_with_diagnostics<S: Into<MultiSpan>>(
+    fn lookup_with_diagnostics<S: Into<MultiSpan>>(
         &self,
         lint: &'static Lint,
         span: Option<S>,
-        msg: &str,
+        decorate: impl for<'a> FnOnce(LintDiagnosticBuilder<'a>),
         diagnostic: BuiltinLintDiagnostics,
     ) {
         self.lookup(lint, span, |lint| {
-            let mut db = lint.build(msg);
+            // We first generate a blank diagnostic.
+            let mut db = lint.build("");
+
+            // Now, set up surrounding context.
             let sess = self.sess();
             match diagnostic {
                 BuiltinLintDiagnostics::Normal => (),
@@ -567,8 +566,8 @@ pub trait LintContext: Sized {
                     stability::deprecation_suggestion(&mut db, suggestion, span)
                 }
             }
-
-            db.emit();
+            // Rewrap `db`, and pass control to the user.
+            decorate(LintDiagnosticBuilder::new(db));
         });
     }
 
@@ -579,11 +578,6 @@ pub trait LintContext: Sized {
         decorate: impl for<'a> FnOnce(LintDiagnosticBuilder<'a>),
     );
 
-    /// Emit a lint at the appropriate level, for a particular span.
-    fn span_lint<S: Into<MultiSpan>>(&self, lint: &'static Lint, span: S, msg: &str) {
-        self.lookup_and_emit(lint, Some(span), msg);
-    }
-
     fn struct_span_lint<S: Into<MultiSpan>>(
         &self,
         lint: &'static Lint,
@@ -592,40 +586,9 @@ pub trait LintContext: Sized {
     ) {
         self.lookup(lint, Some(span), decorate);
     }
-
-    /// Emit a lint and note at the appropriate level, for a particular span.
-    fn span_lint_note(
-        &self,
-        lint: &'static Lint,
-        span: Span,
-        msg: &str,
-        note_span: Span,
-        note: &str,
-    ) {
-        self.lookup(lint, Some(span), |lint| {
-            let mut err = lint.build(msg);
-            if note_span == span {
-                err.note(note);
-            } else {
-                err.span_note(note_span, note);
-            }
-            err.emit();
-        });
-    }
-
-    /// Emit a lint and help at the appropriate level, for a particular span.
-    fn span_lint_help(&self, lint: &'static Lint, span: Span, msg: &str, help: &str) {
-        self.lookup(lint, Some(span), |err| {
-            let mut err = err.build(msg);
-            self.span_lint(lint, span, msg);
-            err.span_help(span, help);
-            err.emit();
-        });
-    }
-
     /// Emit a lint at the appropriate level, with no associated span.
-    fn lint(&self, lint: &'static Lint, msg: &str) {
-        self.lookup_and_emit(lint, None as Option<Span>, msg);
+    fn lint(&self, lint: &'static Lint, decorate: impl for<'a> FnOnce(LintDiagnosticBuilder<'a>)) {
+        self.lookup(lint, None as Option<Span>, decorate);
     }
 }
 
diff --git a/src/librustc_lint/early.rs b/src/librustc_lint/early.rs
@@ -37,11 +37,12 @@ struct EarlyContextAndPass<'a, T: EarlyLintPass> {
 impl<'a, T: EarlyLintPass> EarlyContextAndPass<'a, T> {
     fn check_id(&mut self, id: ast::NodeId) {
         for early_lint in self.context.buffered.take(id) {
-            self.context.lookup_and_emit_with_diagnostics(
+            let rustc_session::lint::BufferedEarlyLint { span, msg, node_id: _, lint_id: _, diagnostic } = early_lint;
+            self.context.lookup_with_diagnostics(
                 early_lint.lint_id.lint,
-                Some(early_lint.span.clone()),
-                &early_lint.msg,
-                early_lint.diagnostic,
+                Some(span),
+                |lint| lint.build(&msg).emit(),
+                diagnostic,
             );
         }
     }
diff --git a/src/librustc_lint/types.rs b/src/librustc_lint/types.rs
@@ -266,10 +266,10 @@ fn lint_int_literal<'a, 'tcx>(
             }
         }
 
-        cx.span_lint(
+        cx.struct_span_lint(
             OVERFLOWING_LITERALS,
             e.span,
-            &format!("literal out of range for `{}`", t.name_str()),
+            |lint| lint.build(&format!("literal out of range for `{}`", t.name_str())).emit(),
         );
     }
 }
@@ -321,10 +321,10 @@ fn lint_uint_literal<'a, 'tcx>(
             report_bin_hex_error(cx, e, attr::IntType::UnsignedInt(t), repr_str, lit_val, false);
             return;
         }
-        cx.span_lint(
+        cx.struct_span_lint(
             OVERFLOWING_LITERALS,
             e.span,
-            &format!("literal out of range for `{}`", t.name_str()),
+            |lint| lint.build(&format!("literal out of range for `{}`", t.name_str())).emit(),
         );
     }
 }
@@ -355,10 +355,10 @@ fn lint_literal<'a, 'tcx>(
                 _ => bug!(),
             };
             if is_infinite == Ok(true) {
-                cx.span_lint(
+                cx.struct_span_lint(
                     OVERFLOWING_LITERALS,
                     e.span,
-                    &format!("literal out of range for `{}`", t.name_str()),
+                    |lint| lint.build(&format!("literal out of range for `{}`", t.name_str())).emit(),
                 );
             }
         }
@@ -377,10 +377,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeLimits {
             }
             hir::ExprKind::Binary(binop, ref l, ref r) => {
                 if is_comparison(binop) && !check_limits(cx, binop, &l, &r) {
-                    cx.span_lint(
+                    cx.struct_span_lint(
                         UNUSED_COMPARISONS,
                         e.span,
-                        "comparison is useless due to type limits",
+                        |lint| lint.build("comparison is useless due to type limits").emit(),
                     );
                 }
             }
@@ -1055,14 +1055,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for VariantSizeDifferences {
             // We only warn if the largest variant is at least thrice as large as
             // the second-largest.
             if largest > slargest * 3 && slargest > 0 {
-                cx.span_lint(
+                cx.struct_span_lint(
                     VARIANT_SIZE_DIFFERENCES,
                     enum_definition.variants[largest_index].span,
-                    &format!(
+                    |lint| lint.build(&format!(
                         "enum variant is more than three times \
                                           larger ({} bytes) than the next largest",
                         largest
-                    ),
+                    )).emit(),
                 );
             }
         }
diff --git a/src/librustc_lint/unused.rs b/src/librustc_lint/unused.rs

Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,7 @@ use rustc::ty::{self, layout::VariantIdx, Ty, TyCtxt};`
`28`	`28`	`use rustc_ast_pretty::pprust::{self, expr_to_string};`
`29`	`29`	`use rustc_data_structures::fx::FxHashSet;`
`30`	`30`	`use rustc_errors::{Applicability, DiagnosticBuilder};`
	`31`	`+use rustc::lint::LintDiagnosticBuilder;`
`31`	`32`	`use rustc_feature::Stability;`
`32`	`33`	`use rustc_feature::{deprecated_attributes, AttributeGate, AttributeTemplate, AttributeType};`
`33`	`34`	`use rustc_hir as hir;`
`@@ -106,8 +107,7 @@ impl BoxPointers {`
`106`	`107`	`fn check_heap_type(&self, cx: &LateContext<'_, '_>, span: Span, ty: Ty<'_>) {`
`107`	`108`	`for leaf_ty in ty.walk() {`
`108`	`109`	`if leaf_ty.is_box() {`
`109`		`- let m = format!("type uses owned (Box type) pointers: {}", ty);`
`110`		`- cx.span_lint(BOX_POINTERS, span, &m);`
	`110`	`+ cx.struct_span_lint(BOX_POINTERS, span, \|lint\| lint.build(&format!("type uses owned (Box type) pointers: {}", ty)).emit());`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`	`}`
`@@ -214,13 +214,13 @@ declare_lint! {`
`214`	`214`	`declare_lint_pass!(UnsafeCode => [UNSAFE_CODE]);`
`215`	`215`
`216`	`216`	`impl UnsafeCode {`
`217`		`- fn report_unsafe(&self, cx: &EarlyContext<'_>, span: Span, desc: &'static str) {`
	`217`	`+ fn report_unsafe(&self, cx: &EarlyContext<'_>, span: Span, decorate: impl for<'a> FnOnce(LintDiagnosticBuilder<'a>)) {`
`218`	`218`	// This comes from a macro that has `#[allow_internal_unsafe]`.
`219`	`219`	`if span.allows_unsafe() {`
`220`	`220`	`return;`
`221`	`221`	`}`
`222`	`222`
`223`		`- cx.span_lint(UNSAFE_CODE, span, desc);`
	`223`	`+ cx.struct_span_lint(UNSAFE_CODE, span, decorate);`
`224`	`224`	`}`
`225`	`225`	`}`
`226`	`226`
`@@ -230,9 +230,9 @@ impl EarlyLintPass for UnsafeCode {`
`230`	`230`	`self.report_unsafe(`
`231`	`231`	`cx,`
`232`	`232`	`attr.span,`
`233`		- "`allow_internal_unsafe` allows defining \
	`233`	+ \|lint\| lint.build("`allow_internal_unsafe` allows defining \
`234`	`234`	`macros using unsafe without triggering \`
`235`		- the `unsafe_code` lint at their call site",
	`235`	+ the `unsafe_code` lint at their call site").emit(),
`236`	`236`	`);`
`237`	`237`	`}`
`238`	`238`	`}`
`@@ -241,19 +241,19 @@ impl EarlyLintPass for UnsafeCode {`
`241`	`241`	`if let ast::ExprKind::Block(ref blk, _) = e.kind {`
`242`	`242`	`// Don't warn about generated blocks; that'll just pollute the output.`
`243`	`243`	`if blk.rules == ast::BlockCheckMode::Unsafe(ast::UserProvided) {`
`244`		- self.report_unsafe(cx, blk.span, "usage of an `unsafe` block");
	`244`	+ self.report_unsafe(cx, blk.span, \|lint\| lint.build("usage of an `unsafe` block").emit());
`245`	`245`	`}`
`246`	`246`	`}`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`fn check_item(&mut self, cx: &EarlyContext<'_>, it: &ast::Item) {`
`250`	`250`	`match it.kind {`
`251`	`251`	`ast::ItemKind::Trait(_, ast::Unsafety::Unsafe, ..) => {`
`252`		- self.report_unsafe(cx, it.span, "declaration of an `unsafe` trait")
	`252`	+ self.report_unsafe(cx, it.span, \|lint\| lint.build("declaration of an `unsafe` trait").emit())
`253`	`253`	`}`
`254`	`254`
`255`	`255`	`ast::ItemKind::Impl { unsafety: ast::Unsafety::Unsafe, .. } => {`
`256`		- self.report_unsafe(cx, it.span, "implementation of an `unsafe` trait")
	`256`	+ self.report_unsafe(cx, it.span, \|lint\| lint.build("implementation of an `unsafe` trait").emit())
`257`	`257`	`}`
`258`	`258`
`259`	`259`	`_ => return,`
`@@ -270,12 +270,12 @@ impl EarlyLintPass for UnsafeCode {`
`270`	`270`	`) {`
`271`	`271`	`match fk {`
`272`	`272`	`FnKind::ItemFn(_, ast::FnHeader { unsafety: ast::Unsafety::Unsafe, .. }, ..) => {`
`273`		- self.report_unsafe(cx, span, "declaration of an `unsafe` function")
	`273`	+ self.report_unsafe(cx, span, \|lint\| lint.build("declaration of an `unsafe` function").emit())
`274`	`274`	`}`
`275`	`275`
`276`	`276`	`FnKind::Method(_, sig, ..) => {`
`277`	`277`	`if sig.header.unsafety == ast::Unsafety::Unsafe {`
`278`		- self.report_unsafe(cx, span, "implementation of an `unsafe` method")
	`278`	+ self.report_unsafe(cx, span, \|lint\| lint.build("implementation of an `unsafe` method").emit())
`279`	`279`	`}`
`280`	`280`	`}`
`281`	`281`
`@@ -286,7 +286,7 @@ impl EarlyLintPass for UnsafeCode {`
`286`	`286`	`fn check_trait_item(&mut self, cx: &EarlyContext<'_>, item: &ast::AssocItem) {`
`287`	`287`	`if let ast::AssocItemKind::Fn(ref sig, None) = item.kind {`
`288`	`288`	`if sig.header.unsafety == ast::Unsafety::Unsafe {`
`289`		- self.report_unsafe(cx, item.span, "declaration of an `unsafe` method")
	`289`	+ self.report_unsafe(cx, item.span, \|lint\| lint.build("declaration of an `unsafe` method").emit())
`290`	`290`	`}`
`291`	`291`	`}`
`292`	`292`	`}`
`@@ -372,10 +372,10 @@ impl MissingDoc {`
`372`	`372`
`373`	`373`	`let has_doc = attrs.iter().any(\|a\| has_doc(a));`
`374`	`374`	`if !has_doc {`
`375`		`- cx.span_lint(`
	`375`	`+ cx.struct_span_lint(`
`376`	`376`	`MISSING_DOCS,`
`377`	`377`	`cx.tcx.sess.source_map().def_span(sp),`
`378`		`- &format!("missing documentation for {}", desc),`
	`378`	`+ \|lint\| lint.build(&format!("missing documentation for {}", desc)).emit(),`
`379`	`379`	`);`
`380`	`380`	`}`
`381`	`381`	`}`
`@@ -404,10 +404,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {`
`404`	`404`	`for macro_def in krate.exported_macros {`
`405`	`405`	`let has_doc = macro_def.attrs.iter().any(\|a\| has_doc(a));`
`406`	`406`	`if !has_doc {`
`407`		`- cx.span_lint(`
	`407`	`+ cx.struct_span_lint(`
`408`	`408`	`MISSING_DOCS,`
`409`	`409`	`cx.tcx.sess.source_map().def_span(macro_def.span),`
`410`		`- "missing documentation for macro",`
	`410`	`+ \|lint\| lint.build("missing documentation for macro").emit(),`
`411`	`411`	`);`
`412`	`412`	`}`
`413`	`413`	`}`
`@@ -555,11 +555,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingCopyImplementations {`
`555`	`555`	`return;`
`556`	`556`	`}`
`557`	`557`	`if can_type_implement_copy(cx.tcx, param_env, ty).is_ok() {`
`558`		`- cx.span_lint(`
	`558`	`+ cx.struct_span_lint(`
`559`	`559`	`MISSING_COPY_IMPLEMENTATIONS,`
`560`	`560`	`item.span,`
`561`		- "type could implement `Copy`; consider adding `impl \
`562`		- Copy`",
	`561`	+ \|lint\| lint.build("type could implement `Copy`; consider adding `impl \
	`562`	+ Copy`").emit(),
`563`	`563`	`)`
`564`	`564`	`}`
`565`	`565`	`}`
`@@ -609,11 +609,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDebugImplementations {`
`609`	`609`	`}`
`610`	`610`
`611`	`611`	`if !self.impling_types.as_ref().unwrap().contains(&item.hir_id) {`
`612`		`- cx.span_lint(`
	`612`	`+ cx.struct_span_lint(`
`613`	`613`	`MISSING_DEBUG_IMPLEMENTATIONS,`
`614`	`614`	`item.span,`
`615`		- "type does not implement `fmt::Debug`; consider adding `#[derive(Debug)]` \
`616`		`- or a manual implementation",`
	`615`	+ \|lint\| lint.build("type does not implement `fmt::Debug`; consider adding `#[derive(Debug)]` \
	`616`	`+ or a manual implementation").emit(),`
`617`	`617`	`)`
`618`	`618`	`}`
`619`	`619`	`}`
`@@ -912,7 +912,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MutableTransmutes {`
`912`	`912`	`match get_transmute_from_to(cx, expr).map(\|(ty1, ty2)\| (&ty1.kind, &ty2.kind)) {`
`913`	`913`	`Some((&ty::Ref(_, _, from_mt), &ty::Ref(_, _, to_mt))) => {`
`914`	`914`	`if to_mt == hir::Mutability::Mut && from_mt == hir::Mutability::Not {`
`915`		`- cx.span_lint(MUTABLE_TRANSMUTES, expr.span, msg);`
	`915`	`+ cx.struct_span_lint(MUTABLE_TRANSMUTES, expr.span, \|lint\| lint.build(msg).emit());`
`916`	`916`	`}`
`917`	`917`	`}`
`918`	`918`	`_ => (),`
`@@ -962,7 +962,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnstableFeatures {`
`962`	`962`	`if attr.check_name(sym::feature) {`
`963`	`963`	`if let Some(items) = attr.meta_item_list() {`
`964`	`964`	`for item in items {`
`965`		`- ctx.span_lint(UNSTABLE_FEATURES, item.span(), "unstable feature");`
	`965`	`+ ctx.struct_span_lint(UNSTABLE_FEATURES, item.span(), \|lint\| lint.build("unstable feature").emit());`
`966`	`966`	`}`
`967`	`967`	`}`
`968`	`968`	`}`
`@@ -1244,14 +1244,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TrivialConstraints {`
`1244`	`1244`	`ConstEvaluatable(..) => continue,`
`1245`	`1245`	`};`
`1246`	`1246`	`if predicate.is_global() {`
`1247`		`- cx.span_lint(`
	`1247`	`+ cx.struct_span_lint(`
`1248`	`1248`	`TRIVIAL_BOUNDS,`
`1249`	`1249`	`span,`
`1250`		`- &format!(`
	`1250`	`+ \|lint\| lint.build(&format!(`
`1251`	`1251`	`"{} bound {} does not depend on any type \`
`1252`	`1252`	`or lifetime parameters",`
`1253`	`1253`	`predicate_kind_name, predicate`
`1254`		`- ),`
	`1254`	`+ )).emit(),`
`1255`	`1255`	`);`
`1256`	`1256`	`}`
`1257`	`1257`	`}`
Original file line number	Diff line number	Diff line change
`@@ -266,10 +266,10 @@ fn lint_int_literal<'a, 'tcx>(`
`266`	`266`	`}`
`267`	`267`	`}`
`268`	`268`
`269`		`- cx.span_lint(`
	`269`	`+ cx.struct_span_lint(`
`270`	`270`	`OVERFLOWING_LITERALS,`
`271`	`271`	`e.span,`
`272`		- &format!("literal out of range for `{}`", t.name_str()),
	`272`	+ \|lint\| lint.build(&format!("literal out of range for `{}`", t.name_str())).emit(),
`273`	`273`	`);`
`274`	`274`	`}`
`275`	`275`	`}`
`@@ -321,10 +321,10 @@ fn lint_uint_literal<'a, 'tcx>(`
`321`	`321`	`report_bin_hex_error(cx, e, attr::IntType::UnsignedInt(t), repr_str, lit_val, false);`
`322`	`322`	`return;`
`323`	`323`	`}`
`324`		`- cx.span_lint(`
	`324`	`+ cx.struct_span_lint(`
`325`	`325`	`OVERFLOWING_LITERALS,`
`326`	`326`	`e.span,`
`327`		- &format!("literal out of range for `{}`", t.name_str()),
	`327`	+ \|lint\| lint.build(&format!("literal out of range for `{}`", t.name_str())).emit(),
`328`	`328`	`);`
`329`	`329`	`}`
`330`	`330`	`}`
`@@ -355,10 +355,10 @@ fn lint_literal<'a, 'tcx>(`
`355`	`355`	`_ => bug!(),`
`356`	`356`	`};`
`357`	`357`	`if is_infinite == Ok(true) {`
`358`		`- cx.span_lint(`
	`358`	`+ cx.struct_span_lint(`
`359`	`359`	`OVERFLOWING_LITERALS,`
`360`	`360`	`e.span,`
`361`		- &format!("literal out of range for `{}`", t.name_str()),
	`361`	+ \|lint\| lint.build(&format!("literal out of range for `{}`", t.name_str())).emit(),
`362`	`362`	`);`
`363`	`363`	`}`
`364`	`364`	`}`
`@@ -377,10 +377,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeLimits {`
`377`	`377`	`}`
`378`	`378`	`hir::ExprKind::Binary(binop, ref l, ref r) => {`
`379`	`379`	`if is_comparison(binop) && !check_limits(cx, binop, &l, &r) {`
`380`		`- cx.span_lint(`
	`380`	`+ cx.struct_span_lint(`
`381`	`381`	`UNUSED_COMPARISONS,`
`382`	`382`	`e.span,`
`383`		`- "comparison is useless due to type limits",`
	`383`	`+ \|lint\| lint.build("comparison is useless due to type limits").emit(),`
`384`	`384`	`);`
`385`	`385`	`}`
`386`	`386`	`}`
`@@ -1055,14 +1055,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for VariantSizeDifferences {`
`1055`	`1055`	`// We only warn if the largest variant is at least thrice as large as`
`1056`	`1056`	`// the second-largest.`
`1057`	`1057`	`if largest > slargest * 3 && slargest > 0 {`
`1058`		`- cx.span_lint(`
	`1058`	`+ cx.struct_span_lint(`
`1059`	`1059`	`VARIANT_SIZE_DIFFERENCES,`
`1060`	`1060`	`enum_definition.variants[largest_index].span,`
`1061`		`- &format!(`
	`1061`	`+ \|lint\| lint.build(&format!(`
`1062`	`1062`	`"enum variant is more than three times \`
`1063`	`1063`	`larger ({} bytes) than the next largest",`
`1064`	`1064`	`largest`
`1065`		`- ),`
	`1065`	`+ )).emit(),`
`1066`	`1066`	`);`
`1067`	`1067`	`}`
`1068`	`1068`	`}`