Suppress redundant E0433 for paths matching failed import prefixes

Track first segments of failed imports and skip late resolution errors
for paths sharing the same prefix. This avoids redundant E0433 after an
E0432 has already been reported for the same missing module, without
suppressing unrelated diagnostics.

Author: yuk1ty

compiler/rustc_resolve/src/imports.rs

@@ -217,6 +217,15 @@ impl<'ra> ImportData<'ra> {
         }
     }
 
+    /// Returns the first meaningful path segment of this import,
+    /// skipping synthetic segments like `{{root}}` and `$crate`.
+    pub(crate) fn first_non_root_segment(&self) -> Option<Symbol> {
+        self.module_path
+            .iter()
+            .find(|seg| seg.ident.name != kw::PathRoot && seg.ident.name != kw::DollarCrate)
+            .map(|seg| seg.ident.name)
+    }
+
     pub(crate) fn id(&self) -> Option<NodeId> {
         match self.kind {
             ImportKind::Single { id, .. }
@@ -653,6 +662,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
             glob_error |= import.is_glob();
 
+            if let Some(name) = import.first_non_root_segment() {
+                self.failed_import_prefixes.insert(name);
+            }
+
             if let ImportKind::Single { source, ref decls, .. } = import.kind
                 && source.name == kw::SelfLower
                 // Silence `unresolved import` error if E0429 is already emitted

compiler/rustc_resolve/src/late.rs

@@ -4424,7 +4424,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
 
         let Finalize { node_id, path_span, .. } = finalize;
         let report_errors = |this: &mut Self, res: Option<Res>| {
-            if this.should_report_errs() {
+            if this.should_report_errs_for_path(path) {
                 let (err, candidates) = this.smart_resolve_report_errors(
                     path,
                     None,
@@ -4558,7 +4558,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
 
                 let def_id = this.parent_scope.module.nearest_parent_mod();
 
-                if this.should_report_errs() {
+                if this.should_report_errs_for_path(path) {
                     if candidates.is_empty() {
                         if path.len() == 2
                             && let [segment] = prefix_path
@@ -4668,7 +4668,9 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
 
             Err(err) => {
                 if let Some(err) = report_errors_for_call(self, err) {
-                    self.report_error(err.span, err.node);
+                    if self.should_report_errs_for_path(path) {
+                        self.r.report_error(err.span, err.node);
+                    }
                 }
 
                 PartialRes::new(Res::Err)
@@ -4717,6 +4719,20 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             && !self.r.glob_error.is_some()
     }
 
+    /// Like `should_report_errs`, but also suppresses errors for paths whose
+    /// first segment matches a known-failed import prefix.
+    fn should_report_errs_for_path(&self, path: &[Segment]) -> bool {
+        if !self.should_report_errs() {
+            return false;
+        }
+        if let Some(first) = path.first() {
+            if self.r.failed_import_prefixes.contains(&first.ident.name) {
+                return false;
+            }
+        }
+        true
+    }
+
     // Resolve in alternative namespaces if resolution in the primary namespace fails.
     fn resolve_qpath_anywhere(
         &mut self,

compiler/rustc_resolve/src/lib.rs

@@ -1242,6 +1242,10 @@ pub struct Resolver<'ra, 'tcx> {
     glob_error: Option<ErrorGuaranteed> = None,
     visibilities_for_hashing: Vec<(LocalDefId, Visibility)> = Vec::new(),
     used_imports: FxHashSet<NodeId> = default::fx_hash_set(),
+    /// First segments of import paths that failed to resolve.
+    /// Used to suppress redundant resolution errors in late resolver
+    /// for paths sharing the same unresolved prefix.
+    failed_import_prefixes: FxHashSet<Symbol>,
     maybe_unused_trait_imports: FxIndexSet<LocalDefId>,
 
     /// Privacy errors are delayed until the end in order to deduplicate them.
@@ -1681,6 +1685,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             extern_module_map: Default::default(),
 
             glob_map: Default::default(),
+            glob_error: None,
+            failed_import_prefixes: FxHashSet::default(),
+            used_imports: FxHashSet::default(),
+            visibilities_for_hashing: Default::default(),
             maybe_unused_trait_imports: Default::default(),
 
             arenas,

tests/ui/imports/absolute-paths-in-nested-use-groups.rs

@@ -1,14 +1,10 @@
 #![allow(unused_imports)]
 
-mod foo {}
-
 use foo::{
     ::bar,
     //~^ ERROR: crate root in paths can only be used in start position
     super::bar,
-    //~^ ERROR: `super` in paths can only be used in start position
     self::bar,
-    //~^ ERROR: `self` in paths can only be used in start position
 };
 
 fn main() {}

tests/ui/imports/absolute-paths-in-nested-use-groups.stderr

@@ -1,21 +1,14 @@
-error[E0433]: the crate root in paths can only be used in start position
-  --> $DIR/absolute-paths-in-nested-use-groups.rs:6:5
+error[E0432]: unresolved import `foo`
+  --> $DIR/absolute-paths-in-nested-use-groups.rs:3:5
    |
-LL |     ::bar,
-   |     ^ can only be used in path start position
-
-error[E0433]: `super` in paths can only be used in start position
-  --> $DIR/absolute-paths-in-nested-use-groups.rs:8:5
+LL | use foo::{
+   |     ^^^ use of unresolved module or unlinked crate `foo`
    |
-LL |     super::bar,
-   |     ^^^^^ can only be used in path start position
-
-error[E0433]: `self` in paths can only be used in start position
-  --> $DIR/absolute-paths-in-nested-use-groups.rs:10:5
+help: you might be missing a crate named `foo`, add it to your project and import it in your code
+   |
+LL + extern crate foo;
    |
-LL |     self::bar,
-   |     ^^^^ can only be used in path start position
 
-error: aborting due to 3 previous errors
+error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0433`.
+For more information about this error, try `rustc --explain E0432`.

tests/ui/imports/nested-import-root-symbol-150103.stderr

@@ -1,4 +1,4 @@
-error[E0433]: cannot find module or crate `Iuse` in the crate root
+error[E0432]: unresolved import `Iuse`
   --> $DIR/nested-import-root-symbol-150103.rs:6:9
    |
 LL |     use Iuse::{ ::Fish };
@@ -9,12 +9,12 @@ help: you might be missing a crate named `Iuse`, add it to your project and impo
 LL + extern crate Iuse;
    |
 
-error[E0433]: the crate root in paths can only be used in start position
+error[E0432]: unresolved import `A::Fish`
   --> $DIR/nested-import-root-symbol-150103.rs:10:13
    |
 LL |     use A::{::Fish};
    |             ^ can only be used in path start position
 
 error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0433`.
+For more information about this error, try `rustc --explain E0432`.

tests/ui/imports/redundant-import-errors-nested.rs

@@ -0,0 +1,8 @@
+// Issue #153156: Too many errors for missing crate for nested imports and later uses
+
+use foo::{bar, baz::bat};
+//~^ ERROR unresolved import `foo`
+
+pub fn main() {
+    foo::qux();
+}

tests/ui/imports/redundant-import-errors-nested.stderr

@@ -0,0 +1,14 @@
+error[E0432]: unresolved import `foo`
+  --> $DIR/redundant-import-errors-nested.rs:3:5
+   |
+LL | use foo::{bar, baz::bat};
+   |     ^^^ use of unresolved module or unlinked crate `foo`
+   |
+help: you might be missing a crate named `foo`, add it to your project and import it in your code
+   |
+LL + extern crate foo;
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0432`.

tests/ui/traits/const-traits/issue-102156.rs

@@ -4,7 +4,6 @@
 
 use core::convert::{From, TryFrom};
 //~^ ERROR
-//~| ERROR
 
 use std::pin::Pin;
 use std::alloc::Allocator;

tests/ui/traits/const-traits/issue-102156.stderr

@@ -1,4 +1,4 @@
-error[E0433]: cannot find `core` in the crate root
+error[E0432]: unresolved import `core`
   --> $DIR/issue-102156.rs:5:5
    |
 LL | use core::convert::{From, TryFrom};
@@ -10,19 +10,6 @@ LL - use core::convert::{From, TryFrom};
 LL + use std::convert::{From, TryFrom};
    |
 
-error[E0433]: cannot find `core` in the crate root
-  --> $DIR/issue-102156.rs:5:5
-   |
-LL | use core::convert::{From, TryFrom};
-   |     ^^^^ you might be missing crate `core`
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: try using `std` instead of `core`
-   |
-LL - use core::convert::{From, TryFrom};
-LL + use std::convert::{From, TryFrom};
-   |
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0433`.
+For more information about this error, try `rustc --explain E0432`.