Fix redundant import errors for preload extern crate

Author: chenyukang

compiler/rustc_lint/src/context/diagnostics.rs

@@ -140,11 +140,21 @@ pub(super) fn builtin(sess: &Session, diagnostic: BuiltinLintDiag, diag: &mut Di
                 );
             }
         }
-        BuiltinLintDiag::RedundantImport(spans, ident) => {
+        BuiltinLintDiag::RedundantImport(spans, ident, import_span) => {
             for (span, is_imported) in spans {
                 let introduced = if is_imported { "imported" } else { "defined" };
-                diag.span_label(span, format!("the item `{ident}` is already {introduced} here"));
+                let span_msg = if span.is_dummy() { "by prelude" } else { "here" };
+                diag.span_label(
+                    span,
+                    format!("the item `{ident}` is already {introduced} {span_msg}"),
+                );
             }
+            diag.span_suggestion(
+                import_span,
+                "remove this import",
+                "",
+                Applicability::MachineApplicable,
+            );
         }
         BuiltinLintDiag::DeprecatedMacro(suggestion, span) => {
             stability::deprecation_suggestion(diag, "macro", suggestion, span)

compiler/rustc_lint_defs/src/lib.rs

@@ -577,7 +577,7 @@ pub enum BuiltinLintDiag {
     ElidedLifetimesInPaths(usize, Span, bool, Span),
     UnknownCrateTypes(Span, String, String),
     UnusedImports(String, Vec<(Span, String)>, Option<Span>),
-    RedundantImport(Vec<(Span, bool)>, Ident),
+    RedundantImport(Vec<(Span, bool)>, Ident, Span),
     DeprecatedMacro(Option<Symbol>, Span),
     MissingAbi(Span, Abi),
     UnusedDocComment(Span),

compiler/rustc_resolve/src/check_unused.rs

@@ -39,6 +39,7 @@ use rustc_session::lint::BuiltinLintDiag;
 use rustc_span::symbol::{kw, Ident};
 use rustc_span::{Span, DUMMY_SP};
 
+#[derive(Debug)]
 struct UnusedImport {
     use_tree: ast::UseTree,
     use_tree_id: ast::NodeId,
@@ -190,6 +191,40 @@ impl<'a, 'b, 'tcx> Visitor<'a> for UnusedImportCheckVisitor<'a, 'b, 'tcx> {
     }
 }
 
+struct ImportFinderVisitor {
+    unused_import: Option<UnusedImport>,
+    root_node_id: ast::NodeId,
+    node_id: ast::NodeId,
+    item_span: Span,
+}
+
+impl Visitor<'_> for ImportFinderVisitor {
+    fn visit_item(&mut self, item: &ast::Item) {
+        match item.kind {
+            ast::ItemKind::Use(..) if item.span.is_dummy() => return,
+            _ => {}
+        }
+
+        self.item_span = item.span_with_attributes();
+        visit::walk_item(self, item);
+    }
+
+    fn visit_use_tree(&mut self, use_tree: &ast::UseTree, id: ast::NodeId, _nested: bool) {
+        if id == self.root_node_id {
+            let mut unused_import = UnusedImport {
+                use_tree: use_tree.clone(),
+                use_tree_id: id,
+                item_span: self.item_span,
+                unused: Default::default(),
+            };
+            unused_import.unused.insert(self.node_id);
+            self.unused_import = Some(unused_import);
+        }
+        visit::walk_use_tree(self, use_tree, id);
+    }
+}
+
+#[derive(Debug)]
 enum UnusedSpanResult {
     Used,
     FlatUnused(Span, Span),
@@ -507,7 +542,36 @@ impl Resolver<'_, '_> {
         }
 
         for import in check_redundant_imports {
-            self.check_for_redundant_imports(import);
+            if let Some(redundant_spans) = self.check_for_redundant_imports(import)
+                && let ImportKind::Single { source, id, .. } = import.kind
+            {
+                let mut visitor = ImportFinderVisitor {
+                    node_id: id,
+                    root_node_id: import.root_id,
+                    unused_import: None,
+                    item_span: Span::default(),
+                };
+                visit::walk_crate(&mut visitor, krate);
+                if let Some(unused) = visitor.unused_import {
+                    let remove_span =
+                        match calc_unused_spans(&unused, &unused.use_tree, unused.use_tree_id) {
+                            UnusedSpanResult::FlatUnused(_, remove) => remove,
+                            UnusedSpanResult::NestedFullUnused(_, remove) => remove,
+                            UnusedSpanResult::NestedPartialUnused(_, removes) => {
+                                assert_eq!(removes.len(), 1);
+                                removes[0]
+                            }
+                            _ => import.use_span,
+                        };
+                    self.lint_buffer.buffer_lint_with_diagnostic(
+                        UNUSED_IMPORTS,
+                        id,
+                        import.span,
+                        format!("the item `{source}` is imported redundantly"),
+                        BuiltinLintDiag::RedundantImport(redundant_spans, source, remove_span),
+                    );
+                }
+            }
         }
     }
 }

compiler/rustc_resolve/src/imports.rs

@@ -1306,7 +1306,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         None
     }
 
-    pub(crate) fn check_for_redundant_imports(&mut self, import: Import<'a>) {
+    pub(crate) fn check_for_redundant_imports(
+        &mut self,
+        import: Import<'a>,
+    ) -> Option<Vec<(Span, bool)>> {
         // This function is only called for single imports.
         let ImportKind::Single {
             source, target, ref source_bindings, ref target_bindings, id, ..
@@ -1317,12 +1320,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
 
         // Skip if the import is of the form `use source as target` and source != target.
         if source != target {
-            return;
+            return None;
         }
 
         // Skip if the import was produced by a macro.
         if import.parent_scope.expansion != LocalExpnId::ROOT {
-            return;
+            return None;
         }
 
         // Skip if we are inside a named module (in contrast to an anonymous
@@ -1332,13 +1335,11 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         if import.used.get() == Some(Used::Other)
             || self.effective_visibilities.is_exported(self.local_def_id(id))
         {
-            return;
+            return None;
         }
 
         let mut is_redundant = true;
-
         let mut redundant_span = PerNS { value_ns: None, type_ns: None, macro_ns: None };
-
         self.per_ns(|this, ns| {
             if is_redundant && let Ok(binding) = source_bindings[ns].get() {
                 if binding.res() == Res::Err {
@@ -1370,14 +1371,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             let mut redundant_spans: Vec<_> = redundant_span.present_items().collect();
             redundant_spans.sort();
             redundant_spans.dedup();
-            self.lint_buffer.buffer_lint_with_diagnostic(
-                UNUSED_IMPORTS,
-                id,
-                import.span,
-                format!("the item `{source}` is imported redundantly"),
-                BuiltinLintDiag::RedundantImport(redundant_spans, source),
-            );
+            return Some(redundant_spans);
         }
+        None
     }
 
     fn resolve_glob_import(&mut self, import: Import<'a>) {

tests/ui/imports/auxiliary/aux-issue-121915.rs

@@ -0,0 +1 @@
+pub fn item() {}

tests/ui/imports/redundant-import-issue-121915-2015.rs

@@ -0,0 +1,11 @@
+//@ compile-flags: --extern aux_issue_121915 --edition 2015
+//@ aux-build: aux-issue-121915.rs
+
+extern crate aux_issue_121915;
+
+#[deny(unused_imports)]
+fn main() {
+    use aux_issue_121915;
+    //~^ ERROR the item `aux_issue_121915` is imported redundantly
+    aux_issue_121915::item();
+}

tests/ui/imports/redundant-import-issue-121915-2015.stderr

@@ -0,0 +1,17 @@
+error: the item `aux_issue_121915` is imported redundantly
+  --> $DIR/redundant-import-issue-121915-2015.rs:8:9
+   |
+LL | extern crate aux_issue_121915;
+   | ------------------------------ the item `aux_issue_121915` is already imported here
+...
+LL |     use aux_issue_121915;
+   |     ----^^^^^^^^^^^^^^^^- help: remove this import
+   |
+note: the lint level is defined here
+  --> $DIR/redundant-import-issue-121915-2015.rs:6:8
+   |
+LL | #[deny(unused_imports)]
+   |        ^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+

tests/ui/imports/redundant-import-issue-121915.rs

@@ -0,0 +1,9 @@
+//@ compile-flags: --extern aux_issue_121915 --edition 2018
+//@ aux-build: aux-issue-121915.rs
+
+#[deny(unused_imports)]
+fn main() {
+    use aux_issue_121915;
+    //~^ ERROR the item `aux_issue_121915` is imported redundantly
+    aux_issue_121915::item();
+}

tests/ui/imports/redundant-import-issue-121915.stderr

@@ -0,0 +1,17 @@
+error: the item `aux_issue_121915` is imported redundantly
+  --> $DIR/redundant-import-issue-121915.rs:6:9
+   |
+LL |     use aux_issue_121915;
+   |     ----^^^^^^^^^^^^^^^^-
+   |     |   |
+   |     |   the item `aux_issue_121915` is already defined by prelude
+   |     help: remove this import
+   |
+note: the lint level is defined here
+  --> $DIR/redundant-import-issue-121915.rs:4:8
+   |
+LL | #[deny(unused_imports)]
+   |        ^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+

tests/ui/imports/suggest-remove-issue-121315.fixed

@@ -0,0 +1,27 @@
+//@ run-rustfix
+//@ compile-flags: --edition 2021
+#![deny(unused_imports)]
+#![allow(dead_code)]
+
+// Test remove FlatUnused
+//~^ ERROR the item `TryFrom` is imported redundantly
+
+// Test remove NestedFullUnused
+//~^ ERROR the item `TryInto` is imported redundantly
+
+// Test remove NestedPartialUnused
+use std::convert::{Infallible};
+//~^ ERROR the item `From` is imported redundantly
+
+// Test remove both redundant and unused?
+// use std::convert::{AsMut, Into};
+
+trait MyTrait {}
+impl MyTrait for fn() -> Infallible {}
+
+fn main() {
+    let _ = u32::try_from(5i32);
+    let _a: i32 = u32::try_into(5u32).unwrap();
+    let _a: String = String::from("hello anan");
+    //let _a: u32 = (5i32).into();
+}