Rollup merge of rust-lang#63250 - petrochenkov:descrate, r=davidtwco

diagnostics: Describe crate root modules in `DefKind::Mod` as "crate"

Or we can use "extern crate" like resolve previously did sometimes, not sure.

r? @davidtwco

Author: Centril

src/librustc/hir/def.rs

@@ -1,4 +1,4 @@
-use crate::hir::def_id::DefId;
+use crate::hir::def_id::{DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
 use crate::util::nodemap::DefIdMap;
 use syntax::ast;
 use syntax::ext::base::MacroKind;
@@ -81,9 +81,11 @@ pub enum DefKind {
 }
 
 impl DefKind {
-    pub fn descr(self) -> &'static str {
+    pub fn descr(self, def_id: DefId) -> &'static str {
         match self {
             DefKind::Fn => "function",
+            DefKind::Mod if def_id.index == CRATE_DEF_INDEX && def_id.krate != LOCAL_CRATE =>
+                "crate",
             DefKind::Mod => "module",
             DefKind::Static => "static",
             DefKind::Enum => "enum",
@@ -366,7 +368,7 @@ impl<Id> Res<Id> {
     /// A human readable name for the res kind ("function", "module", etc.).
     pub fn descr(&self) -> &'static str {
         match *self {
-            Res::Def(kind, _) => kind.descr(),
+            Res::Def(kind, def_id) => kind.descr(def_id),
             Res::SelfCtor(..) => "self constructor",
             Res::PrimTy(..) => "builtin type",
             Res::Local(..) => "local variable",

src/librustc_privacy/lib.rs

@@ -1127,7 +1127,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypePrivacyVisitor<'a, 'tcx> {
                     hir::QPath::Resolved(_, ref path) => path.to_string(),
                     hir::QPath::TypeRelative(_, ref segment) => segment.ident.to_string(),
                 };
-                let msg = format!("{} `{}` is private", kind.descr(), name);
+                let msg = format!("{} `{}` is private", kind.descr(def_id), name);
                 self.tcx.sess.span_err(span, &msg);
                 return;
             }

src/librustc_resolve/diagnostics.rs

@@ -115,10 +115,9 @@ impl<'a> Resolver<'a> {
                 let mod_prefix = match self.resolve_path_without_parent_scope(
                     mod_path, Some(TypeNS), false, span, CrateLint::No
                 ) {
-                    PathResult::Module(ModuleOrUniformRoot::Module(module)) =>
-                        module.def_kind(),
+                    PathResult::Module(ModuleOrUniformRoot::Module(module)) => module.res(),
                     _ => None,
-                }.map_or(String::new(), |kind| format!("{} ", kind.descr()));
+                }.map_or(String::new(), |res| format!("{} ", res.descr()));
                 (mod_prefix, format!("`{}`", Segment::names_to_string(mod_path)))
             };
             (format!("cannot find {} `{}` in {}{}", expected, item_str, mod_prefix, mod_str),

src/librustc_resolve/lib.rs

@@ -443,11 +443,12 @@ fn resolve_struct_error<'sess, 'a>(resolver: &'sess Resolver<'_>,
             err
         }
         ResolutionError::BindingShadowsSomethingUnacceptable(what_binding, name, binding) => {
-            let shadows_what = binding.descr();
+            let res = binding.res();
+            let shadows_what = res.descr();
             let mut err = struct_span_err!(resolver.session, span, E0530, "{}s cannot shadow {}s",
                                            what_binding, shadows_what);
             err.span_label(span, format!("cannot be named the same as {} {}",
-                                         binding.article(), shadows_what));
+                                         res.article(), shadows_what));
             let participle = if binding.is_import() { "imported" } else { "defined" };
             let msg = format!("the {} `{}` is {} here", shadows_what, name, participle);
             err.span_label(binding.span, msg);
@@ -1242,13 +1243,6 @@ impl<'a> ModuleData<'a> {
         }
     }
 
-    fn def_kind(&self) -> Option<DefKind> {
-        match self.kind {
-            ModuleKind::Def(kind, ..) => Some(kind),
-            _ => None,
-        }
-    }
-
     fn def_id(&self) -> Option<DefId> {
         match self.kind {
             ModuleKind::Def(_, def_id, _) => Some(def_id),
@@ -1493,14 +1487,6 @@ impl<'a> NameBinding<'a> {
         self.res().macro_kind()
     }
 
-    fn descr(&self) -> &'static str {
-        if self.is_extern_crate() { "extern crate" } else { self.res().descr() }
-    }
-
-    fn article(&self) -> &'static str {
-        if self.is_extern_crate() { "an" } else { self.res().article() }
-    }
-
     // Suppose that we resolved macro invocation with `invoc_parent_expansion` to binding `binding`
     // at some expansion round `max(invoc, binding)` when they both emerged from macros.
     // Then this function returns `true` if `self` may emerge from a macro *after* that
@@ -4691,6 +4677,7 @@ impl<'a> Resolver<'a> {
     }
 
     fn binding_description(&self, b: &NameBinding<'_>, ident: Ident, from_prelude: bool) -> String {
+        let res = b.res();
         if b.span.is_dummy() {
             let add_built_in = match b.res() {
                 // These already contain the "built-in" prefix or look bad with it.
@@ -4708,13 +4695,13 @@ impl<'a> Resolver<'a> {
                 ("", "")
             };
 
-            let article = if built_in.is_empty() { b.article() } else { "a" };
+            let article = if built_in.is_empty() { res.article() } else { "a" };
             format!("{a}{built_in} {thing}{from}",
-                    a = article, thing = b.descr(), built_in = built_in, from = from)
+                    a = article, thing = res.descr(), built_in = built_in, from = from)
         } else {
             let introduced = if b.is_import() { "imported" } else { "defined" };
             format!("the {thing} {introduced} here",
-                    thing = b.descr(), introduced = introduced)
+                    thing = res.descr(), introduced = introduced)
         }
     }
 
@@ -4737,6 +4724,7 @@ impl<'a> Resolver<'a> {
             let note_msg = format!("`{ident}` could{also} refer to {what}",
                                    ident = ident, also = also, what = what);
 
+            let thing = b.res().descr();
             let mut help_msgs = Vec::new();
             if b.is_glob_import() && (kind == AmbiguityKind::GlobVsGlob ||
                                       kind == AmbiguityKind::GlobVsExpanded ||
@@ -4748,18 +4736,18 @@ impl<'a> Resolver<'a> {
             if b.is_extern_crate() && ident.span.rust_2018() {
                 help_msgs.push(format!(
                     "use `::{ident}` to refer to this {thing} unambiguously",
-                    ident = ident, thing = b.descr(),
+                    ident = ident, thing = thing,
                 ))
             }
             if misc == AmbiguityErrorMisc::SuggestCrate {
                 help_msgs.push(format!(
                     "use `crate::{ident}` to refer to this {thing} unambiguously",
-                    ident = ident, thing = b.descr(),
+                    ident = ident, thing = thing,
                 ))
             } else if misc == AmbiguityErrorMisc::SuggestSelf {
                 help_msgs.push(format!(
                     "use `self::{ident}` to refer to this {thing} unambiguously",
-                    ident = ident, thing = b.descr(),
+                    ident = ident, thing = thing,
                 ))
             }
 
@@ -4797,7 +4785,7 @@ impl<'a> Resolver<'a> {
         for &PrivacyError(dedup_span, ident, binding) in &self.privacy_errors {
             if reported_spans.insert(dedup_span) {
                 span_err!(self.session, ident.span, E0603, "{} `{}` is private",
-                          binding.descr(), ident.name);
+                          binding.res().descr(), ident.name);
             }
         }
     }

src/librustc_typeck/astconv.rs

@@ -1688,7 +1688,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
 
         let kind = DefKind::AssocTy;
         if !item.vis.is_accessible_from(def_scope, tcx) {
-            let msg = format!("{} `{}` is private", kind.descr(), assoc_ident);
+            let msg = format!("{} `{}` is private", kind.descr(item.def_id), assoc_ident);
             tcx.sess.span_err(span, &msg);
         }
         tcx.check_stability(item.def_id, Some(hir_ref_id), span);
@@ -1703,7 +1703,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
 
             let mut could_refer_to = |kind: DefKind, def_id, also| {
                 let note_msg = format!("`{}` could{} refer to {} defined here",
-                                       assoc_ident, also, kind.descr());
+                                       assoc_ident, also, kind.descr(def_id));
                 err.span_note(tcx.def_span(def_id), &note_msg);
             };
             could_refer_to(DefKind::Variant, variant_def_id, "");

src/librustc_typeck/check/method/suggest.rs

@@ -522,7 +522,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         &format!(
                             "there is {} {} with a similar name",
                             def_kind.article(),
-                            def_kind.descr(),
+                            def_kind.descr(lev_candidate.def_id),
                         ),
                         lev_candidate.ident.to_string(),
                         Applicability::MaybeIncorrect,
@@ -543,9 +543,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 err.emit();
             }
 
-            MethodError::PrivateMatch(kind, _, out_of_scope_traits) => {
+            MethodError::PrivateMatch(kind, def_id, out_of_scope_traits) => {
                 let mut err = struct_span_err!(self.tcx.sess, span, E0624,
-                                               "{} `{}` is private", kind.descr(), item_name);
+                                               "{} `{}` is private", kind.descr(def_id), item_name);
                 self.suggest_valid_traits(&mut err, out_of_scope_traits);
                 err.emit();
             }

src/test/ui/extern/extern-crate-visibility.rs

@@ -3,10 +3,10 @@ mod foo {
 }
 
 // Check that private crates can be used from outside their modules, albeit with warnings
-use foo::core::cell; //~ ERROR extern crate `core` is private
+use foo::core::cell; //~ ERROR crate `core` is private
 
 fn f() {
-    foo::core::cell::Cell::new(0); //~ ERROR extern crate `core` is private
+    foo::core::cell::Cell::new(0); //~ ERROR crate `core` is private
 
     use foo::*;
     mod core {} // Check that private crates are not glob imported

src/test/ui/extern/extern-crate-visibility.stderr

@@ -1,10 +1,10 @@
-error[E0603]: extern crate `core` is private
+error[E0603]: crate `core` is private
   --> $DIR/extern-crate-visibility.rs:6:10
    |
 LL | use foo::core::cell;
    |          ^^^^
 
-error[E0603]: extern crate `core` is private
+error[E0603]: crate `core` is private
   --> $DIR/extern-crate-visibility.rs:9:10
    |
 LL |     foo::core::cell::Cell::new(0);

src/test/ui/imports/extern-prelude-extern-crate-restricted-shadowing.stderr

@@ -14,7 +14,7 @@ LL |         Vec::panic!();
    |         ^^^ ambiguous name
    |
    = note: `Vec` could refer to a struct from prelude
-note: `Vec` could also refer to the extern crate imported here
+note: `Vec` could also refer to the crate imported here
   --> $DIR/extern-prelude-extern-crate-restricted-shadowing.rs:5:9
    |
 LL |         extern crate std as Vec;

src/test/ui/imports/glob-conflict-cross-crate.rs

@@ -3,6 +3,6 @@
 extern crate glob_conflict;
 
 fn main() {
-    glob_conflict::f(); //~ ERROR cannot find function `f` in module `glob_conflict`
+    glob_conflict::f(); //~ ERROR cannot find function `f` in crate `glob_conflict`
     glob_conflict::glob::f(); //~ ERROR cannot find function `f` in module `glob_conflict::glob`
 }