src/tools/clippy/clippy_lints/src/wildcard_imports.rs

   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;
   4 use rustc_hir::{
   5     def::{DefKind, Res},
   6     Item, ItemKind, UseKind,
   7 };
   8 use rustc_lint::{LateContext, LateLintPass};
   9 use rustc_session::{declare_lint_pass, declare_tool_lint};
  10 use rustc_span::BytePos;
  11
  12 declare_clippy_lint! {
  13     /// **What it does:** Checks for `use Enum::*`.
  14     ///
  15     /// **Why is this bad?** It is usually better style to use the prefixed name of
  16     /// an enumeration variant, rather than importing variants.
  17     ///
  18     /// **Known problems:** Old-style enumerations that prefix the variants are
  19     /// still around.
  20     ///
  21     /// **Example:**
  22     /// ```rust
  23     /// use std::cmp::Ordering::*;
  24     /// ```
  25     pub ENUM_GLOB_USE,
  26     pedantic,
  27     "use items that import all variants of an enum"
  28 }
  29
  30 declare_clippy_lint! {
  31     /// **What it does:** Checks for wildcard imports `use _::*`.
  32     ///
  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:
  36     ///
  37     /// ```rust,ignore
  38     /// use crate1::foo; // Imports a function named foo
  39     /// use crate2::*; // Has a function named foo
  40     ///
  41     /// foo(); // Calls crate1::foo
  42     /// ```
  43     ///
  44     /// This can lead to confusing error messages at best and to unexpected behavior at worst.
  45     ///
  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.
  49     ///
  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.
  52     ///
  53     /// Applying the suggestion when explicit imports of the things imported with a glob import
  54     /// exist, may result in `unused_imports` warnings.
  55     ///
  56     /// **Example:**
  57     ///
  58     /// Bad:
  59     /// ```rust,ignore
  60     /// use crate1::*;
  61     ///
  62     /// foo();
  63     /// ```
  64     ///
  65     /// Good:
  66     /// ```rust,ignore
  67     /// use crate1::foo;
  68     ///
  69     /// foo();
  70     /// ```
  71     pub WILDCARD_IMPORTS,
  72     pedantic,
  73     "lint `use _::*` statements"
  74 }
  75
  76 declare_lint_pass!(WildcardImports => [ENUM_GLOB_USE, WILDCARD_IMPORTS]);
  77
  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() {
  81             return;
  82         }
  83         if_chain! {
  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);
  89             if !used_imports.is_empty(); // Already handled by `unused_imports`
  90             then {
  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.
  97                     (
  98                         use_path.span.with_hi(use_path.span.hi() + BytePos(1)),
  99                         true,
 100                     )
 101                 } else {
 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));
 110                     }
 111                     (
 112                         span,
 113                         false,
 114                     )
 115                 };
 116
 117                 let imports_string = if used_imports.len() == 1 {
 118                     used_imports.iter().next().unwrap().to_string()
 119                 } else {
 120                     let mut imports = used_imports
 121                         .iter()
 122                         .map(ToString::to_string)
 123                         .collect::<Vec<_>>();
 124                     imports.sort();
 125                     if braced_glob {
 126                         imports.join(", ")
 127                     } else {
 128                         format!("{{{}}}", imports.join(", "))
 129                     }
 130                 };
 131
 132                 let sugg = if braced_glob {
 133                     imports_string
 134                 } else {
 135                     format!("{}::{}", import_source_snippet, imports_string)
 136                 };
 137
 138                 let (lint, message) = if let Res::Def(DefKind::Enum, _) = use_path.res {
 139                     (ENUM_GLOB_USE, "usage of wildcard import for enum variants")
 140                 } else {
 141                     (WILDCARD_IMPORTS, "usage of wildcard import")
 142                 };
 143
 144                 span_lint_and_sugg(
 145                     cx,
 146                     lint,
 147                     span,
 148                     message,
 149                     "try",
 150                     sugg,
 151                     applicability,
 152                 );
 153             }
 154         }
 155     }
 156 }