Introduce the #[diagnostic] attribute namespace

Author: weiznich

compiler/rustc_hir/src/def.rs

@@ -630,7 +630,7 @@ impl<Id> Res<Id> {
             | Res::SelfTyParam { .. }
             | Res::SelfTyAlias { .. }
             | Res::SelfCtor(..)
-            | Res::ToolMod
+            | Res::ToolMod { .. }
             | Res::NonMacroAttr(..)
             | Res::Err => None,
         }
@@ -652,7 +652,7 @@ impl<Id> Res<Id> {
             Res::PrimTy(..) => "builtin type",
             Res::Local(..) => "local variable",
             Res::SelfTyParam { .. } | Res::SelfTyAlias { .. } => "self type",
-            Res::ToolMod => "tool module",
+            Res::ToolMod { .. } => "tool module",
             Res::NonMacroAttr(attr_kind) => attr_kind.descr(),
             Res::Err => "unresolved item",
         }
@@ -720,9 +720,10 @@ impl<Id> Res<Id> {
     pub fn ns(&self) -> Option<Namespace> {
         match self {
             Res::Def(kind, ..) => kind.ns(),
-            Res::PrimTy(..) | Res::SelfTyParam { .. } | Res::SelfTyAlias { .. } | Res::ToolMod => {
-                Some(Namespace::TypeNS)
-            }
+            Res::PrimTy(..)
+            | Res::SelfTyParam { .. }
+            | Res::SelfTyAlias { .. }
+            | Res::ToolMod { .. } => Some(Namespace::TypeNS),
             Res::SelfCtor(..) | Res::Local(..) => Some(Namespace::ValueNS),
             Res::NonMacroAttr(..) => Some(Namespace::MacroNS),
             Res::Err => None,

compiler/rustc_lint/src/context.rs

@@ -404,6 +404,7 @@ impl LintStore {
             // FIXME: rustc and rustdoc are considered tools for lints, but not for attributes.
             if tool_name != sym::rustc
                 && tool_name != sym::rustdoc
+                && tool_name != sym::diagnostic
                 && !registered_tools.contains(&Ident::with_dummy_span(tool_name))
             {
                 return CheckLintNameResult::NoTool;

compiler/rustc_lint_defs/src/builtin.rs

@@ -3398,6 +3398,7 @@ declare_lint_pass! {
         UNFULFILLED_LINT_EXPECTATIONS,
         UNINHABITED_STATIC,
         UNKNOWN_CRATE_TYPES,
+    UNKNOWN_DIAGNOSTIC_ATTRIBUTE,
         UNKNOWN_LINTS,
         UNREACHABLE_CODE,
         UNREACHABLE_PATTERNS,
@@ -4251,3 +4252,26 @@ declare_lint! {
     Warn,
     "\"invalid_parameter\" isn't a valid argument for `#[macro_export]`",
 }
+
+declare_lint! {
+    /// The `unknown_diagnostic_attribute` lint detects unrecognized diagnostic attributes.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// #[diagnostic::does_not_exist]
+    /// struct Foo;
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// It is usually a mistake to specify a diagnostic attribute that does not exist. Check
+    /// the spelling, and check the diagnostic attribute listing for the correct name. Also
+    /// consider if you are using an old version of the compiler, and the attribute
+    /// is only available in a newer version.
+    pub UNKNOWN_DIAGNOSTIC_ATTRIBUTE,
+    Warn,
+    "unrecognized diagnostic attribute"
+}

compiler/rustc_passes/src/dead.rs

@@ -110,7 +110,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
             Res::Def(_, def_id) => self.check_def_id(def_id),
             Res::SelfTyParam { trait_: t } => self.check_def_id(t),
             Res::SelfTyAlias { alias_to: i, .. } => self.check_def_id(i),
-            Res::ToolMod | Res::NonMacroAttr(..) | Res::Err => {}
+            Res::ToolMod { .. } | Res::NonMacroAttr(..) | Res::Err => {}
         }
     }
 

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -956,7 +956,9 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
                 _,
             )
             | Res::PrimTy(..)
-            | Res::ToolMod => self.r.define(parent, ident, TypeNS, (res, vis, span, expansion)),
+            | Res::ToolMod { .. } => {
+                self.r.define(parent, ident, TypeNS, (res, vis, span, expansion))
+            }
             Res::Def(
                 DefKind::Fn
                 | DefKind::AssocFn

compiler/rustc_resolve/src/diagnostics.rs

@@ -1404,7 +1404,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                     Res::Def(DefKind::Macro(MacroKind::Derive), _) => {
                         format!("a derive macro: `#[derive({})]`", ident)
                     }
-                    Res::ToolMod => {
+                    Res::ToolMod { .. } => {
                         // Don't confuse the user with tool modules.
                         continue;
                     }
@@ -1505,7 +1505,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         if b.span.is_dummy() || !self.tcx.sess.source_map().is_span_accessible(b.span) {
             // These already contain the "built-in" prefix or look bad with it.
             let add_built_in =
-                !matches!(b.res(), Res::NonMacroAttr(..) | Res::PrimTy(..) | Res::ToolMod);
+                !matches!(b.res(), Res::NonMacroAttr(..) | Res::PrimTy(..) | Res::ToolMod { .. });
             let (built_in, from) = if from_prelude {
                 ("", " from prelude")
             } else if b.is_extern_crate()

compiler/rustc_resolve/src/macros.rs

@@ -21,7 +21,9 @@ use rustc_hir::def_id::{CrateNum, LocalDefId};
 use rustc_middle::middle::stability;
 use rustc_middle::ty::RegisteredTools;
 use rustc_middle::ty::TyCtxt;
-use rustc_session::lint::builtin::{LEGACY_DERIVE_HELPERS, SOFT_UNSTABLE};
+use rustc_session::lint::builtin::{
+    LEGACY_DERIVE_HELPERS, SOFT_UNSTABLE, UNKNOWN_DIAGNOSTIC_ATTRIBUTE,
+};
 use rustc_session::lint::builtin::{UNUSED_MACROS, UNUSED_MACRO_RULES};
 use rustc_session::lint::BuiltinLintDiagnostics;
 use rustc_session::parse::feature_err;
@@ -137,10 +139,11 @@ pub(crate) fn registered_tools(tcx: TyCtxt<'_>, (): ()) -> RegisteredTools {
             }
         }
     }
-    // We implicitly add `rustfmt` and `clippy` to known tools,
+    // We implicitly add `rustfmt`, `clippy`, `diagnostic` to known tools,
     // but it's not an error to register them explicitly.
     let predefined_tools = [sym::clippy, sym::rustfmt];
     registered_tools.extend(predefined_tools.iter().cloned().map(Ident::with_dummy_span));
+    registered_tools.insert(Ident::with_dummy_span(sym::diagnostic));
     registered_tools
 }
 
@@ -493,6 +496,27 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             Err(Determinacy::Undetermined) => return Err(Indeterminate),
         };
 
+        if kind == MacroKind::Attr
+            && !path.segments.is_empty()
+            && path.segments[0].ident.as_str() == "diagnostic"
+        {
+            if path.segments.len() != 2 {
+                self.tcx
+                    .sess
+                    .span_err(path.span, "Diagnostic attributes requires a path with 2 segments");
+                self.tcx
+                    .sess
+                    .span_err(path.span, "Diagnostic attributes requires a path with 2 segments");
+            } else {
+                self.tcx.sess.parse_sess.buffer_lint(
+                    UNKNOWN_DIAGNOSTIC_ATTRIBUTE,
+                    path.segments[1].span(),
+                    node_id,
+                    "Unknown diagnostic attribute",
+                );
+            }
+        }
+
         // Report errors for the resolved macro.
         for segment in &path.segments {
             if let Some(args) = &segment.args {

tests/ui/diagnostic_namespace/can_use_the_diagnostic_name_in_other_places.rs

@@ -0,0 +1,13 @@
+// check-pass
+
+mod diagnostic {}
+
+macro_rules! diagnostic{
+    () => {}
+}
+
+#[allow(non_upper_case_globals)]
+const diagnostic: () = ();
+
+fn main() {
+}

tests/ui/diagnostic_namespace/non_existing_attributes_accepted.rs

@@ -0,0 +1,12 @@
+// check-pass
+#[diagnostic::non_existing_attribute]
+//~^WARN Unknown diagnostic attribute
+pub trait Bar {
+}
+
+#[diagnostic::non_existing_attribute(with_option = "foo")]
+//~^WARN Unknown diagnostic attribute
+struct Foo;
+
+fn main() {
+}

tests/ui/diagnostic_namespace/non_existing_attributes_accepted.stderr

@@ -0,0 +1,16 @@
+warning: Unknown diagnostic attribute
+  --> $DIR/non_existing_attributes_accepted.rs:2:15
+   |
+LL | #[diagnostic::non_existing_attribute]
+   |               ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(unknown_diagnostic_attribute)]` on by default
+
+warning: Unknown diagnostic attribute
+  --> $DIR/non_existing_attributes_accepted.rs:7:15
+   |
+LL | #[diagnostic::non_existing_attribute(with_option = "foo")]
+   |               ^^^^^^^^^^^^^^^^^^^^^^
+
+warning: 2 warnings emitted
+

tests/ui/diagnostic_namespace/requires_path.rs

@@ -0,0 +1,11 @@
+// check-fail
+
+#[diagnostic]
+//~^ERROR Diagnostic attributes requires a path with 2 segments
+//~|ERROR Diagnostic attributes requires a path with 2 segments
+//~|ERROR cannot find attribute `diagnostic` in this scope
+pub struct Bar;
+
+
+fn main() {
+}

tests/ui/diagnostic_namespace/requires_path.stderr

@@ -0,0 +1,20 @@
+error: Diagnostic attributes requires a path with 2 segments
+  --> $DIR/requires_path.rs:3:3
+   |
+LL | #[diagnostic]
+   |   ^^^^^^^^^^
+
+error: Diagnostic attributes requires a path with 2 segments
+  --> $DIR/requires_path.rs:3:3
+   |
+LL | #[diagnostic]
+   |   ^^^^^^^^^^
+
+error: cannot find attribute `diagnostic` in this scope
+  --> $DIR/requires_path.rs:3:3
+   |
+LL | #[diagnostic]
+   |   ^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+