1 use crate::utils::{in_macro, snippet, snippet_with_applicability, span_lint_and_sugg};
2 use if_chain::if_chain;
3 use rustc_errors::Applicability;
6 Item, ItemKind, UseKind,
8 use rustc_lint::{LateContext, LateLintPass};
9 use rustc_session::{declare_lint_pass, declare_tool_lint};
10 use rustc_span::BytePos;
12 declare_clippy_lint! {
13 /// **What it does:** Checks for `use Enum::*`.
15 /// **Why is this bad?** It is usually better style to use the prefixed name of
16 /// an enumeration variant, rather than importing variants.
18 /// **Known problems:** Old-style enumerations that prefix the variants are
23 /// use std::cmp::Ordering::*;
27 "use items that import all variants of an enum"
30 declare_clippy_lint! {
31 /// **What it does:** Checks for wildcard imports `use _::*`.
33 /// **Why is this bad?** wildcard imports can polute the namespace. This is especially bad if
34 /// you try to import something through a wildcard, that already has been imported by name from
35 /// a different source:
38 /// use crate1::foo; // Imports a function named foo
39 /// use crate2::*; // Has a function named foo
41 /// foo(); // Calls crate1::foo
44 /// This can lead to confusing error messages at best and to unexpected behavior at worst.
46 /// Note that this will not warn about wildcard imports from modules named `prelude`; many
47 /// crates (including the standard library) provide modules named "prelude" specifically
48 /// designed for wildcard import.
50 /// **Known problems:** If macros are imported through the wildcard, this macro is not included
51 /// by the suggestion and has to be added by hand.
53 /// Applying the suggestion when explicit imports of the things imported with a glob import
54 /// exist, may result in `unused_imports` warnings.
73 "lint `use _::*` statements"
76 declare_lint_pass!(WildcardImports => [ENUM_GLOB_USE, WILDCARD_IMPORTS]);
78 impl LateLintPass<'_, '_> for WildcardImports {
79 fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &Item<'_>) {
80 if item.vis.node.is_pub() || item.vis.node.is_pub_restricted() {
84 if !in_macro(item.span);
85 if let ItemKind::Use(use_path, UseKind::Glob) = &item.kind;
86 // don't lint prelude glob imports
87 if !use_path.segments.iter().last().map_or(false, |ps| ps.ident.as_str() == "prelude");
88 let used_imports = cx.tcx.names_imported_by_glob_use(item.hir_id.owner_def_id());
89 if !used_imports.is_empty(); // Already handled by `unused_imports`
91 let mut applicability = Applicability::MachineApplicable;
92 let import_source_snippet = snippet_with_applicability(cx, use_path.span, "..", &mut applicability);
93 let (span, braced_glob) = if import_source_snippet.is_empty() {
94 // This is a `_::{_, *}` import
95 // In this case `use_path.span` is empty and ends directly in front of the `*`,
96 // so we need to extend it by one byte.
98 use_path.span.with_hi(use_path.span.hi() + BytePos(1)),
102 // In this case, the `use_path.span` ends right before the `::*`, so we need to
103 // extend it up to the `*`. Since it is hard to find the `*` in weird
104 // formattings like `use _ :: *;`, we extend it up to, but not including the
105 // `;`. In nested imports, like `use _::{inner::*, _}` there is no `;` and we
106 // can just use the end of the item span
107 let mut span = use_path.span.with_hi(item.span.hi());
108 if snippet(cx, span, "").ends_with(';') {
109 span = use_path.span.with_hi(item.span.hi() - BytePos(1));
117 let imports_string = if used_imports.len() == 1 {
118 used_imports.iter().next().unwrap().to_string()
120 let mut imports = used_imports
122 .map(ToString::to_string)
123 .collect::<Vec<_>>();
128 format!("{{{}}}", imports.join(", "))
132 let sugg = if braced_glob {
135 format!("{}::{}", import_source_snippet, imports_string)
138 let (lint, message) = if let Res::Def(DefKind::Enum, _) = use_path.res {
139 (ENUM_GLOB_USE, "usage of wildcard import for enum variants")
141 (WILDCARD_IMPORTS, "usage of wildcard import")