Rebase merge

Author: MarcusGrass

clippy_lints/src/std_instead_of_core.rs

@@ -1,9 +1,11 @@
+use std::hash::{Hash, Hasher};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_from_proc_macro;
+use rustc_data_structures::fx::FxIndexSet;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::def_id::DefId;
-use rustc_hir::{HirId, Path, PathSegment};
+use rustc_hir::{HirId, Item, ItemKind, Path, PathSegment, UseKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::impl_lint_pass;
@@ -93,9 +95,47 @@ pub struct StdReexports {
     // twice. First for the mod, second for the macro. This is used to avoid the lint reporting for the macro
     // when the path could be also be used to access the module.
     prev_span: Span,
+    open_use: Option<OpenUseSpan>
 }
+
 impl_lint_pass!(StdReexports => [STD_INSTEAD_OF_CORE, STD_INSTEAD_OF_ALLOC, ALLOC_INSTEAD_OF_CORE]);
 
+#[derive(Debug)]
+struct OpenUseSpan {
+    container: Span,
+    members: FxIndexSet<UseSpanMember>
+}
+
+#[derive(Debug, Copy, Clone)]
+struct UseSpanMember {
+    inner: Span,
+    lint_data: LintData,
+}
+
+impl PartialEq for UseSpanMember {
+    fn eq(&self, other: &Self) -> bool {
+        self.inner.eq(&other.inner)
+    }
+}
+
+impl Eq for UseSpanMember {}
+
+impl Hash for UseSpanMember {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.inner.hash(state);
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+enum LintData {
+    CanReplace {
+        lint: &'static crate::Lint,
+        used_mod: &'static str,
+        replace_with: &'static str,
+    },
+    NoReplace,
+}
+
 impl<'tcx> LateLintPass<'tcx> for StdReexports {
     fn check_path(&mut self, cx: &LateContext<'tcx>, path: &Path<'tcx>, _: HirId) {
         if let Res::Def(_, def_id) = path.res
@@ -104,37 +144,74 @@ impl<'tcx> LateLintPass<'tcx> for StdReexports {
             && !in_external_macro(cx.sess(), path.span)
             && !is_from_proc_macro(cx, &first_segment.ident)
         {
-            let (lint, used_mod, replace_with) = match first_segment.ident.name {
+            let lint_data = match first_segment.ident.name {
                 sym::std => match cx.tcx.crate_name(def_id.krate) {
-                    sym::core => (STD_INSTEAD_OF_CORE, "std", "core"),
-                    sym::alloc => (STD_INSTEAD_OF_ALLOC, "std", "alloc"),
+                    sym::core => LintData::CanReplace {
+                        lint: STD_INSTEAD_OF_CORE,
+                        used_mod: "std",
+                        replace_with: "core",
+                    },
+                    sym::alloc => LintData::CanReplace {
+                        lint: STD_INSTEAD_OF_ALLOC,
+                        used_mod: "std",
+                        replace_with: "alloc",
+                    },
                     _ => {
                         self.prev_span = first_segment.ident.span;
-                        return;
+                        LintData::NoReplace
                     },
                 },
                 sym::alloc => {
                     if cx.tcx.crate_name(def_id.krate) == sym::core {
-                        (ALLOC_INSTEAD_OF_CORE, "alloc", "core")
+                        LintData::CanReplace {
+                            lint: ALLOC_INSTEAD_OF_CORE,
+                            used_mod: "alloc",
+                            replace_with: "core",
+                        }
                     } else {
                         self.prev_span = first_segment.ident.span;
-                        return;
+                        LintData::NoReplace
                     }
                 },
                 _ => return,
             };
-            if first_segment.ident.span != self.prev_span {
-                span_lint_and_sugg(
-                    cx,
-                    lint,
-                    first_segment.ident.span,
-                    format!("used import from `{used_mod}` instead of `{replace_with}`"),
-                    format!("consider importing the item from `{replace_with}`"),
-                    replace_with.to_string(),
-                    Applicability::MachineApplicable,
-                );
-                self.prev_span = first_segment.ident.span;
+            if let Some(in_use) = self.open_use.as_mut() {
+                in_use.members.insert(UseSpanMember {
+                    inner: path.span,
+                    lint_data,
+                });
+                return;
             }
+            if let LintData::CanReplace { lint, used_mod, replace_with } = lint_data {
+                if first_segment.ident.span != self.prev_span {
+                    span_lint_and_sugg(
+                        cx,
+                        lint,
+                        first_segment.ident.span,
+                        &format!("used import from `{used_mod}` instead of `{replace_with}`"),
+                        &format!("consider importing the item from `{replace_with}`"),
+                        replace_with.to_string(),
+                        Applicability::MachineApplicable,
+                    );
+                    self.prev_span = first_segment.ident.span;
+                }
+            }
+        }
+    }
+
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if matches!(item.kind, ItemKind::Use(_, UseKind::ListStem)) {
+            self.open_use = Some(OpenUseSpan {
+                container: item.span,
+                members: FxIndexSet::default(),
+            })
+        }
+
+    }
+
+    fn check_item_post(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if let Some(collected_use) = self.open_use.take() {
+
         }
     }
 }