suggest similarly named type when use of undeclared crate or module

Author: m-ysk

compiler/rustc_resolve/src/diagnostics.rs

@@ -28,7 +28,7 @@ use rustc_span::{BytePos, Span};
 use tracing::debug;
 
 use crate::imports::{Import, ImportKind, ImportResolver};
-use crate::late::{PatternSource, Rib};
+use crate::late::{PatternSource, Rib, RibKind};
 use crate::path_names_to_string;
 use crate::{AmbiguityError, AmbiguityErrorMisc, AmbiguityKind, BindingError, Finalize};
 use crate::{HasGenericParams, MacroRulesScope, Module, ModuleKind, ModuleOrUniformRoot};
@@ -1825,6 +1825,75 @@ impl<'a> Resolver<'a> {
         }
     }
 
+    fn find_similarly_named_type(
+        &mut self,
+        ident: Symbol,
+        ribs: Option<&PerNS<Vec<Rib<'a>>>>,
+    ) -> Option<Symbol> {
+        fn is_type_candidate(res: Res) -> bool {
+            matches!(
+                res,
+                Res::Def(
+                    DefKind::Struct
+                        | DefKind::Union
+                        | DefKind::Enum
+                        | DefKind::Trait
+                        | DefKind::TraitAlias
+                        | DefKind::TyAlias
+                        | DefKind::AssocTy
+                        | DefKind::TyParam
+                        | DefKind::OpaqueTy
+                        | DefKind::ForeignTy,
+                    _
+                ) | Res::PrimTy(..)
+                    | Res::SelfTy { .. }
+            )
+        }
+
+        let mut names = Vec::new();
+        if let Some(ribs) = ribs {
+            // Search in lexical scope.
+            // Walk backwards up the ribs in scope and collect candidates.
+            for rib in ribs[TypeNS].iter().rev() {
+                for (ident, res) in &rib.bindings {
+                    if is_type_candidate(*res) {
+                        names.push(TypoSuggestion::typo_from_res(ident.name, *res));
+                    }
+                }
+                // Items in scope
+                if let RibKind::ModuleRibKind(module) = rib.kind {
+                    // Items from this module
+                    self.add_module_candidates(module, &mut names, &is_type_candidate);
+
+                    if let ModuleKind::Block(..) = module.kind {
+                        // We can through blocks
+                    } else {
+                        // Items from the prelude
+                        if !module.no_implicit_prelude {
+                            if let Some(prelude) = self.prelude {
+                                self.add_module_candidates(prelude, &mut names, &is_type_candidate);
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+            // Add primitive types
+            names.extend(PrimTy::ALL.iter().map(|prim_ty| {
+                TypoSuggestion::typo_from_res(prim_ty.name(), Res::PrimTy(*prim_ty))
+            }))
+        }
+
+        let mut names = names.iter().map(|sugg| sugg.candidate).collect::<Vec<Symbol>>();
+        names.sort();
+        names.dedup();
+
+        match find_best_match_for_name(&names, ident, None) {
+            Some(sugg) if sugg == ident => None,
+            sugg => sugg,
+        }
+    }
+
     pub(crate) fn report_path_resolution_error(
         &mut self,
         path: &[Segment],
@@ -2001,16 +2070,22 @@ impl<'a> Resolver<'a> {
                     String::from("add `extern crate alloc` to use the `alloc` crate"),
                     Applicability::MaybeIncorrect,
                 ))
+            } else if let Some(sugg) =
+                self.find_similarly_named_module_or_crate(ident.name, &parent_scope.module)
+            {
+                Some((
+                    vec![(ident.span, sugg.to_string())],
+                    String::from("there is a crate or module with a similar name"),
+                    Applicability::MaybeIncorrect,
+                ))
             } else {
-                self.find_similarly_named_module_or_crate(ident.name, &parent_scope.module).map(
-                    |sugg| {
-                        (
-                            vec![(ident.span, sugg.to_string())],
-                            String::from("there is a crate or module with a similar name"),
-                            Applicability::MaybeIncorrect,
-                        )
-                    },
-                )
+                self.find_similarly_named_type(ident.name, ribs).map(|sugg| {
+                    (
+                        vec![(ident.span, sugg.to_string())],
+                        String::from("there is a type with a similar name"),
+                        Applicability::MaybeIncorrect,
+                    )
+                })
             };
             (format!("use of undeclared crate or module `{}`", ident), suggestion)
         }

src/test/ui/macros/builtin-prelude-no-accidents.stderr

@@ -14,7 +14,10 @@ error[E0433]: failed to resolve: use of undeclared crate or module `vec`
   --> $DIR/builtin-prelude-no-accidents.rs:7:14
    |
 LL |     type B = vec::Vec<u8>;
-   |              ^^^ use of undeclared crate or module `vec`
+   |              ^^^
+   |              |
+   |              use of undeclared crate or module `vec`
+   |              help: there is a type with a similar name (notice the capitalization): `Vec`
 
 error: aborting due to 3 previous errors
 

src/test/ui/macros/macro_path_as_generic_bound.stderr

@@ -2,7 +2,10 @@ error[E0433]: failed to resolve: use of undeclared crate or module `m`
   --> $DIR/macro_path_as_generic_bound.rs:7:6
    |
 LL | foo!(m::m2::A);
-   |      ^ use of undeclared crate or module `m`
+   |      ^
+   |      |
+   |      use of undeclared crate or module `m`
+   |      help: there is a type with a similar name: `T`
 
 error: aborting due to previous error
 

src/test/ui/resolve/suggest-type-to-lowercase-path.rs

@@ -0,0 +1,9 @@
+// Beginners often write an incorrect type name whose initial letter is
+// a lowercase while the correct one is an uppercase.
+// (e.g. `string` instead of `String`)
+// This tests that we suggest the latter when we encounter the former.
+
+fn main() {
+    let _ = string::new();
+    //~^ ERROR failed to resolve: use of undeclared crate or module `string`
+}

src/test/ui/resolve/suggest-type-to-lowercase-path.stderr

@@ -0,0 +1,12 @@
+error[E0433]: failed to resolve: use of undeclared crate or module `string`
+  --> $DIR/suggest-type-to-lowercase-path.rs:7:13
+   |
+LL |     let _ = string::new();
+   |             ^^^^^^
+   |             |
+   |             use of undeclared crate or module `string`
+   |             help: there is a type with a similar name (notice the capitalization): `String`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0433`.

src/test/ui/suggestions/type-ascription-instead-of-path.stderr

@@ -2,7 +2,10 @@ error[E0433]: failed to resolve: use of undeclared crate or module `io`
   --> $DIR/type-ascription-instead-of-path.rs:2:9
    |
 LL |     std:io::stdin();
-   |         ^^ use of undeclared crate or module `io`
+   |         ^^
+   |         |
+   |         use of undeclared crate or module `io`
+   |         help: there is a type with a similar name: `i8`
 
 error[E0423]: expected value, found crate `std`
   --> $DIR/type-ascription-instead-of-path.rs:2:5