Make lint diagnostics responsible for storing their span

Author: fmease

compiler/rustc_errors/src/diagnostic.rs

@@ -198,10 +198,11 @@ pub trait SubdiagMessageOp<G: EmissionGuarantee> =
 /// `#[derive(LintDiagnostic)]` -- see [rustc_macros::LintDiagnostic].
 #[rustc_diagnostic_item = "LintDiagnostic"]
 pub trait LintDiagnostic<'a, G: EmissionGuarantee> {
-    /// Decorate and emit a lint.
+    /// Decorate a lint.
     fn decorate_lint<'b>(self, diag: &'b mut Diag<'a, G>);
 
     fn msg(&self) -> DiagMessage;
+    fn span(&self) -> Option<MultiSpan>;
 }
 
 #[derive(Clone, Debug, Encodable, Decodable)]

compiler/rustc_lint/src/context.rs

@@ -566,19 +566,6 @@ pub trait LintContext {
         decorate: impl for<'a, 'b> FnOnce(&'b mut Diag<'a, ()>),
     );
 
-    /// Emit a lint at `span` from a lint struct (some type that implements `LintDiagnostic`,
-    /// typically generated by `#[derive(LintDiagnostic)]`).
-    fn emit_span_lint<S: Into<MultiSpan>>(
-        &self,
-        lint: &'static Lint,
-        span: S,
-        decorator: impl for<'a> LintDiagnostic<'a, ()>,
-    ) {
-        self.opt_span_lint(lint, Some(span), decorator.msg(), |diag| {
-            decorator.decorate_lint(diag);
-        });
-    }
-
     /// Emit a lint at the appropriate level, with an associated span.
     ///
     /// [`lint_level`]: rustc_middle::lint::lint_level#decorate-signature
@@ -596,7 +583,7 @@ pub trait LintContext {
     /// Emit a lint from a lint struct (some type that implements `LintDiagnostic`, typically
     /// generated by `#[derive(LintDiagnostic)]`).
     fn emit_lint(&self, lint: &'static Lint, decorator: impl for<'a> LintDiagnostic<'a, ()>) {
-        self.opt_span_lint(lint, None as Option<Span>, decorator.msg(), |diag| {
+        self.opt_span_lint(lint, decorator.span(), decorator.msg(), |diag| {
             decorator.decorate_lint(diag);
         });
     }

compiler/rustc_macros/src/diagnostics/diagnostic.rs

@@ -6,25 +6,28 @@ use crate::diagnostics::diagnostic_builder::DiagnosticDeriveKind;
 use crate::diagnostics::error::{span_err, DiagnosticDeriveError};
 use crate::diagnostics::utils::SetOnce;
 use proc_macro2::TokenStream;
-use quote::quote;
+use quote::{quote, quote_spanned};
 use syn::spanned::Spanned;
 use synstructure::Structure;
 
+use super::utils::FieldInnerTy;
+
 /// The central struct for constructing the `into_diag` method from an annotated struct.
 pub(crate) struct DiagnosticDerive<'a> {
     structure: Structure<'a>,
 }
 
 impl<'a> DiagnosticDerive<'a> {
+    const KIND: DiagnosticDeriveKind = DiagnosticDeriveKind::Diagnostic;
+
     pub(crate) fn new(structure: Structure<'a>) -> Self {
         Self { structure }
     }
 
     pub(crate) fn into_tokens(self) -> TokenStream {
         let DiagnosticDerive { mut structure } = self;
-        let kind = DiagnosticDeriveKind::Diagnostic;
         let slugs = RefCell::new(Vec::new());
-        let implementation = kind.each_variant(&mut structure, |mut builder, variant| {
+        let implementation = Self::KIND.each_variant(&mut structure, |mut builder, variant| {
             let preamble = builder.preamble(variant);
             let body = builder.body(variant);
 
@@ -98,14 +101,15 @@ pub(crate) struct LintDiagnosticDerive<'a> {
 }
 
 impl<'a> LintDiagnosticDerive<'a> {
+    const KIND: DiagnosticDeriveKind = DiagnosticDeriveKind::LintDiagnostic;
+
     pub(crate) fn new(structure: Structure<'a>) -> Self {
         Self { structure }
     }
 
     pub(crate) fn into_tokens(self) -> TokenStream {
         let LintDiagnosticDerive { mut structure } = self;
-        let kind = DiagnosticDeriveKind::LintDiagnostic;
-        let implementation = kind.each_variant(&mut structure, |mut builder, variant| {
+        let implementation = Self::KIND.each_variant(&mut structure, |mut builder, variant| {
             let preamble = builder.preamble(variant);
             let body = builder.body(variant);
 
@@ -119,7 +123,7 @@ impl<'a> LintDiagnosticDerive<'a> {
         });
 
         let slugs = RefCell::new(Vec::new());
-        let msg = kind.each_variant(&mut structure, |mut builder, variant| {
+        let msg = Self::KIND.each_variant(&mut structure, |mut builder, variant| {
             // Collect the slug by generating the preamble.
             let _ = builder.preamble(variant);
 
@@ -152,6 +156,41 @@ impl<'a> LintDiagnosticDerive<'a> {
             }
         });
 
+        let span = Self::KIND.each_variant(&mut structure, |_, variant| {
+            variant
+                .bindings()
+                .iter()
+                .find_map(|binding_info| {
+                    let field = binding_info.ast();
+
+                    field.attrs.iter().find_map(|attr| {
+                        if attr.path().segments.last().unwrap().ident != "primary_span"
+                            || !matches!(attr.meta, syn::Meta::Path(_))
+                        {
+                            return None;
+                        }
+
+                        let ident = &binding_info.binding;
+
+                        // Generate `.clone()` unconditionally as the inner type may
+                        // contain a `MultiSpan` which is not `Copy`.
+                        Some(match FieldInnerTy::from_type(&field.ty) {
+                            FieldInnerTy::Plain(_) | FieldInnerTy::Vec(_) => {
+                                quote_spanned! {field.ty.span()=>
+                                    std::option::Option::Some(#ident.clone().into())
+                                }
+                            }
+                            FieldInnerTy::Option(_) => {
+                                quote_spanned! {field.ty.span()=>
+                                    #ident.clone().into()
+                                }
+                            }
+                        })
+                    })
+                })
+                .unwrap_or_else(|| quote! { std::option::Option::None })
+        });
+
         let mut imp = structure.gen_impl(quote! {
             gen impl<'__a> rustc_errors::LintDiagnostic<'__a, ()> for @Self {
                 #[track_caller]
@@ -165,6 +204,10 @@ impl<'a> LintDiagnosticDerive<'a> {
                 fn msg(&self) -> rustc_errors::DiagMessage {
                     #msg
                 }
+
+                fn span(&self) -> std::option::Option<rustc_errors::MultiSpan> {
+                    #span
+                }
             }
         });
         for test in slugs.borrow().iter().map(|s| generate_test(s, &structure)) {

compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs

@@ -315,20 +315,13 @@ impl DiagnosticDeriveVariantBuilder {
             // `arg` call will not be generated.
             (Meta::Path(_), "skip_arg") => return Ok(quote! {}),
             (Meta::Path(_), "primary_span") => {
-                match self.kind {
-                    DiagnosticDeriveKind::Diagnostic => {
-                        report_error_if_not_applied_to_span(attr, &info)?;
+                report_error_if_not_applied_to_span(attr, &info)?;
 
-                        return Ok(quote! {
-                            diag.span(#binding);
-                        });
-                    }
-                    DiagnosticDeriveKind::LintDiagnostic => {
-                        throw_invalid_attr!(attr, |diag| {
-                            diag.help("the `primary_span` field attribute is not valid for lint diagnostics")
-                        })
-                    }
-                }
+                return Ok(match self.kind {
+                    DiagnosticDeriveKind::Diagnostic => quote! { diag.span(#binding); },
+                    // Handled separately in `LintDiagnosticDerive::into_tokens`.
+                    DiagnosticDeriveKind::LintDiagnostic => quote! {},
+                });
             }
             (Meta::Path(_), "subdiagnostic") => {
                 return Ok(quote! { diag.subdiagnostic(diag.dcx, #binding); });

compiler/rustc_macros/src/diagnostics/mod.rs

@@ -70,6 +70,7 @@ pub fn diagnostic_derive(mut s: Structure<'_>) -> TokenStream {
 ///     method: Symbol,
 ///     success_ordering: Symbol,
 ///     fail_ordering: Symbol,
+///     #[primary_span]
 ///     #[label(fail_label)]
 ///     fail_order_arg_span: Span,
 ///     #[label(success_label)]
@@ -91,7 +92,7 @@ pub fn diagnostic_derive(mut s: Structure<'_>) -> TokenStream {
 /// Then, later, to emit the error:
 ///
 /// ```ignore (rust)
-/// cx.span_lint(INVALID_ATOMIC_ORDERING, fail_order_arg_span, AtomicOrderingInvalidLint {
+/// tcx.emit_lint(INVALID_ATOMIC_ORDERING, AtomicOrderingInvalidLint {
 ///     method,
 ///     success_ordering,
 ///     fail_ordering,

compiler/rustc_middle/src/ty/context.rs

@@ -2464,23 +2464,6 @@ impl<'tcx> TyCtxt<'tcx> {
         T::collect_and_apply(iter, |xs| self.mk_bound_variable_kinds(xs))
     }
 
-    /// Emit a lint at `span` from a lint struct (some type that implements `LintDiagnostic`,
-    /// typically generated by `#[derive(LintDiagnostic)]`).
-    #[track_caller]
-    pub fn emit_node_span_lint(
-        self,
-        lint: &'static Lint,
-        hir_id: HirId,
-        span: impl Into<MultiSpan>,
-        decorator: impl for<'a> LintDiagnostic<'a, ()>,
-    ) {
-        let msg = decorator.msg();
-        let (level, src) = self.lint_level_at_node(lint, hir_id);
-        lint_level(self.sess, lint, level, src, Some(span.into()), msg, |diag| {
-            decorator.decorate_lint(diag);
-        })
-    }
-
     /// Emit a lint at the appropriate level for a hir node, with an associated span.
     ///
     /// [`lint_level`]: rustc_middle::lint::lint_level#decorate-signature
@@ -2546,9 +2529,10 @@ impl<'tcx> TyCtxt<'tcx> {
         id: HirId,
         decorator: impl for<'a> LintDiagnostic<'a, ()>,
     ) {
-        self.node_lint(lint, id, decorator.msg(), |diag| {
-            decorator.decorate_lint(diag);
-        })
+        let (level, src) = self.lint_level_at_node(lint, id);
+        lint_level(self.sess, lint, level, src, decorator.span(), decorator.msg(), |diag| {
+            decorator.decorate_lint(diag)
+        });
     }
 
     /// Emit a lint at the appropriate level for a hir node.