Auto merge of #157926 - mejrs:on_unknown_module, r=<try>

Implement `#[diagnostic::on_unknown]` for modules.

Author: bors

compiler/rustc_attr_parsing/src/attributes/diagnostic/mod.rs

@@ -460,6 +460,7 @@ fn parse_arg(
 
             (Mode::DiagnosticOnTypeError, sym::Found) => FormatArg::Found,
             (Mode::DiagnosticOnTypeError, sym::Expected) => FormatArg::Expected,
+            (Mode::DiagnosticOnUnknown, sym::Unresolved) => FormatArg::Unresolved,
 
             // Some diagnostic attributes can use `{This}` to refer to the annotated item.
             // For those that don't, we continue and maybe use it as a generic parameter.

compiler/rustc_attr_parsing/src/attributes/diagnostic/on_unknown.rs

@@ -5,7 +5,7 @@ use rustc_session::lint::builtin::MISPLACED_DIAGNOSTIC_ATTRIBUTES;
 use crate::ShouldEmit;
 use crate::attributes::diagnostic::*;
 use crate::attributes::prelude::*;
-use crate::diagnostics::DiagnosticOnUnknownOnlyForImports;
+use crate::diagnostics::DiagnosticOnUnknownInvalidTarget;
 
 #[derive(Default)]
 pub(crate) struct OnUnknownParser {
@@ -29,11 +29,11 @@ impl OnUnknownParser {
         // Therefore, only do target checking if we can emit.
         let early = matches!(cx.should_emit, ShouldEmit::Nothing);
 
-        if !early && !matches!(cx.target, Target::Use) {
+        if !early && !matches!(cx.target, Target::Use | Target::Mod | Target::Crate) {
             let target_span = cx.target_span;
             cx.emit_lint(
                 MISPLACED_DIAGNOSTIC_ATTRIBUTES,
-                DiagnosticOnUnknownOnlyForImports { target_span },
+                DiagnosticOnUnknownInvalidTarget { target_span },
                 span,
             );
             return;

compiler/rustc_attr_parsing/src/diagnostics.rs

@@ -295,9 +295,11 @@ pub(crate) struct DiagnosticOnMoveOnlyForAdt;
 pub(crate) struct DiagnosticOnUnimplementedOnlyForTraits;
 
 #[derive(Diagnostic)]
-#[diag("`#[diagnostic::on_unknown]` can only be applied to `use` statements")]
-pub(crate) struct DiagnosticOnUnknownOnlyForImports {
-    #[label("not an import")]
+#[diag(
+    "`#[diagnostic::on_unknown]` can only be applied to `use` statements and module declarations"
+)]
+pub(crate) struct DiagnosticOnUnknownInvalidTarget {
+    #[label("not an import or module")]
     pub target_span: Span,
 }
 

compiler/rustc_hir/src/attrs/diagnostic.rs

@@ -92,7 +92,7 @@ pub struct CustomDiagnostic {
 }
 
 impl CustomDiagnostic {
-    fn update(&mut self, di: &Directive, args: &FormatArgs) {
+    pub fn update(&mut self, di: &Directive, args: &FormatArgs) {
         if self.message.is_none() {
             self.message = di.message.as_ref().map(|m| m.1.format(args));
         }
@@ -153,6 +153,9 @@ impl FormatString {
                 Piece::Arg(FormatArg::Found) => ret.push_str(&args.found),
                 Piece::Arg(FormatArg::Expected) => ret.push_str(&args.expected),
 
+                // only for on_unknown
+                Piece::Arg(FormatArg::Unresolved) => ret.push_str(&args.unresolved),
+
                 // It's only `rustc_onunimplemented` from here
                 Piece::Arg(FormatArg::ThisPath) => ret.push_str(&args.this_path),
                 Piece::Arg(FormatArg::ThisResolved) => {
@@ -215,6 +218,7 @@ pub struct FormatArgs {
     pub this_path: String = String::new(),
     pub found: String = String::new(),
     pub expected: String = String::new(),
+    pub unresolved: String = String::new(),
     pub item_context: &'static str = "",
     pub generic_args: Vec<(Symbol, String)> = Vec::new(),
 }
@@ -248,6 +252,8 @@ pub enum FormatArg {
     Found,
     /// {Expected} in diagnostic::on_type_error
     Expected,
+    /// {Unresolved} in diagnostic::on_unknown
+    Unresolved,
 }
 
 /// Represents the `on` filter in `#[rustc_on_unimplemented]`.

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -31,8 +31,8 @@ use tracing::debug;
 
 use crate::Namespace::{MacroNS, TypeNS, ValueNS};
 use crate::def_collector::DefCollector;
-use crate::error_helper::StructCtor;
-use crate::imports::{ImportData, ImportKind, OnUnknownData};
+use crate::error_helper::{OnUnknownData, StructCtor};
+use crate::imports::{ImportData, ImportKind};
 use crate::macros::{MacroRulesDecl, MacroRulesScope, MacroRulesScopeRef};
 use crate::ref_mut::CmCell;
 use crate::{
@@ -548,7 +548,7 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
             root_id,
             vis,
             vis_span: item.vis.span,
-            on_unknown_attr: OnUnknownData::from_attrs(self.r.tcx, item),
+            on_unknown_attr: OnUnknownData::from_attrs(self.r.tcx, &item.attrs),
         });
 
         self.r.indeterminate_imports.push(import);
@@ -863,6 +863,9 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
                         || ast::attr::contains_name(&item.attrs, sym::no_implicit_prelude),
                 );
                 self.parent_scope.module = module.to_module();
+                if let Some(directive) = OnUnknownData::from_attrs(self.r.tcx, &item.attrs) {
+                    self.r.on_unknown_data.insert(local_def_id, directive);
+                }
             }
 
             // These items live in the value namespace.
@@ -1037,7 +1040,7 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
             module_path: Vec::new(),
             vis,
             vis_span: item.vis.span,
-            on_unknown_attr: OnUnknownData::from_attrs(self.r.tcx, item),
+            on_unknown_attr: OnUnknownData::from_attrs(self.r.tcx, &item.attrs),
         });
         if used {
             self.r.import_use_map.insert(import, Used::Other);
@@ -1169,7 +1172,7 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
                 module_path: Vec::new(),
                 vis: Visibility::Restricted(CRATE_DEF_ID),
                 vis_span: item.vis.span,
-                on_unknown_attr: OnUnknownData::from_attrs(this.r.tcx, item),
+                on_unknown_attr: OnUnknownData::from_attrs(this.r.tcx, &item.attrs),
             })
         };
 
@@ -1350,7 +1353,7 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
                     module_path: Vec::new(),
                     vis,
                     vis_span: item.vis.span,
-                    on_unknown_attr: OnUnknownData::from_attrs(self.r.tcx, item),
+                    on_unknown_attr: OnUnknownData::from_attrs(self.r.tcx, &item.attrs),
                 });
                 self.r.import_use_map.insert(import, Used::Other);
                 let import_decl = self.r.new_import_decl(decl, import);