compiler/rustc_typeck/src/check_unused.rs

   1 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
   2 use rustc_errors::Applicability;
   3 use rustc_hir as hir;
   4 use rustc_hir::def_id::{DefId, LocalDefId};
   5 use rustc_hir::itemlikevisit::ItemLikeVisitor;
   6 use rustc_middle::ty::TyCtxt;
   7 use rustc_session::lint;
   8 use rustc_span::{Span, Symbol};
   9
  10 pub fn check_crate(tcx: TyCtxt<'_>) {
  11     let mut used_trait_imports = FxHashSet::default();
  12     for item_def_id in tcx.hir().body_owners() {
  13         let imports = tcx.used_trait_imports(item_def_id);
  14         debug!("GatherVisitor: item_def_id={:?} with imports {:#?}", item_def_id, imports);
  15         used_trait_imports.extend(imports.iter());
  16     }
  17
  18     let mut visitor = CheckVisitor { tcx, used_trait_imports };
  19     tcx.hir().visit_all_item_likes(&mut visitor);
  20
  21     unused_crates_lint(tcx);
  22 }
  23
  24 impl<'tcx> ItemLikeVisitor<'_> for CheckVisitor<'tcx> {
  25     fn visit_item(&mut self, item: &hir::Item<'_>) {
  26         if item.vis.node.is_pub() || item.span.is_dummy() {
  27             return;
  28         }
  29         if let hir::ItemKind::Use(path, _) = item.kind {
  30             self.check_import(item.item_id(), path.span);
  31         }
  32     }
  33
  34     fn visit_trait_item(&mut self, _trait_item: &hir::TraitItem<'_>) {}
  35
  36     fn visit_impl_item(&mut self, _impl_item: &hir::ImplItem<'_>) {}
  37
  38     fn visit_foreign_item(&mut self, _foreign_item: &hir::ForeignItem<'_>) {}
  39 }
  40
  41 struct CheckVisitor<'tcx> {
  42     tcx: TyCtxt<'tcx>,
  43     used_trait_imports: FxHashSet<LocalDefId>,
  44 }
  45
  46 impl<'tcx> CheckVisitor<'tcx> {
  47     fn check_import(&self, item_id: hir::ItemId, span: Span) {
  48         if !self.tcx.maybe_unused_trait_import(item_id.def_id) {
  49             return;
  50         }
  51
  52         if self.used_trait_imports.contains(&item_id.def_id) {
  53             return;
  54         }
  55
  56         self.tcx.struct_span_lint_hir(
  57             lint::builtin::UNUSED_IMPORTS,
  58             item_id.hir_id(),
  59             span,
  60             |lint| {
  61                 let msg = if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
  62                     format!("unused import: `{}`", snippet)
  63                 } else {
  64                     "unused import".to_owned()
  65                 };
  66                 lint.build(&msg).emit();
  67             },
  68         );
  69     }
  70 }
  71
  72 fn unused_crates_lint(tcx: TyCtxt<'_>) {
  73     let lint = lint::builtin::UNUSED_EXTERN_CRATES;
  74
  75     // Collect first the crates that are completely unused.  These we
  76     // can always suggest removing (no matter which edition we are
  77     // in).
  78     let unused_extern_crates: FxHashMap<LocalDefId, Span> = tcx
  79         .maybe_unused_extern_crates(())
  80         .iter()
  81         .filter(|&&(def_id, _)| {
  82             // The `def_id` here actually was calculated during resolution (at least
  83             // at the time of this writing) and is being shipped to us via a side
  84             // channel of the tcx. There may have been extra expansion phases,
  85             // however, which ended up removing the `def_id` *after* expansion such
  86             // as the `ReplaceBodyWithLoop` pass (which is a bit of a hack, but hey)
  87             //
  88             // As a result we need to verify that `def_id` is indeed still valid for
  89             // our AST and actually present in the HIR map. If it's not there then
  90             // there's safely nothing to warn about, and otherwise we carry on with
  91             // our execution.
  92             //
  93             // Note that if we carry through to the `extern_mod_stmt_cnum` query
  94             // below it'll cause a panic because `def_id` is actually bogus at this
  95             // point in time otherwise.
  96             if tcx.hir().find(tcx.hir().local_def_id_to_hir_id(def_id)).is_none() {
  97                 return false;
  98             }
  99             true
 100         })
 101         .filter(|&&(def_id, _)| {
 102             tcx.extern_mod_stmt_cnum(def_id).map_or(true, |cnum| {
 103                 !tcx.is_compiler_builtins(cnum)
 104                     && !tcx.is_panic_runtime(cnum)
 105                     && !tcx.has_global_allocator(cnum)
 106                     && !tcx.has_panic_handler(cnum)
 107             })
 108         })
 109         .cloned()
 110         .collect();
 111
 112     // Collect all the extern crates (in a reliable order).
 113     let mut crates_to_lint = vec![];
 114     tcx.hir().visit_all_item_likes(&mut CollectExternCrateVisitor {
 115         crates_to_lint: &mut crates_to_lint,
 116     });
 117
 118     let extern_prelude = &tcx.resolutions(()).extern_prelude;
 119
 120     for extern_crate in &crates_to_lint {
 121         let def_id = extern_crate.def_id.expect_local();
 122         let item = tcx.hir().expect_item(def_id);
 123
 124         // If the crate is fully unused, we suggest removing it altogether.
 125         // We do this in any edition.
 126         if extern_crate.warn_if_unused {
 127             if let Some(&span) = unused_extern_crates.get(&def_id) {
 128                 let id = tcx.hir().local_def_id_to_hir_id(def_id);
 129                 tcx.struct_span_lint_hir(lint, id, span, |lint| {
 130                     // Removal suggestion span needs to include attributes (Issue #54400)
 131                     let span_with_attrs = tcx
 132                         .get_attrs(extern_crate.def_id)
 133                         .iter()
 134                         .map(|attr| attr.span)
 135                         .fold(span, |acc, attr_span| acc.to(attr_span));
 136
 137                     lint.build("unused extern crate")
 138                         .span_suggestion_short(
 139                             span_with_attrs,
 140                             "remove it",
 141                             String::new(),
 142                             Applicability::MachineApplicable,
 143                         )
 144                         .emit();
 145                 });
 146                 continue;
 147             }
 148         }
 149
 150         // If we are not in Rust 2018 edition, then we don't make any further
 151         // suggestions.
 152         if !tcx.sess.rust_2018() {
 153             continue;
 154         }
 155
 156         // If the extern crate isn't in the extern prelude,
 157         // there is no way it can be written as a `use`.
 158         let orig_name = extern_crate.orig_name.unwrap_or(item.ident.name);
 159         if !extern_prelude.get(&orig_name).map_or(false, |from_item| !from_item) {
 160             continue;
 161         }
 162
 163         // If the extern crate is renamed, then we cannot suggest replacing it with a use as this
 164         // would not insert the new name into the prelude, where other imports in the crate may be
 165         // expecting it.
 166         if extern_crate.orig_name.is_some() {
 167             continue;
 168         }
 169
 170         // If the extern crate has any attributes, they may have funky
 171         // semantics we can't faithfully represent using `use` (most
 172         // notably `#[macro_use]`). Ignore it.
 173         if !tcx.get_attrs(extern_crate.def_id).is_empty() {
 174             continue;
 175         }
 176         let id = tcx.hir().local_def_id_to_hir_id(def_id);
 177         tcx.struct_span_lint_hir(lint, id, extern_crate.span, |lint| {
 178             // Otherwise, we can convert it into a `use` of some kind.
 179             let base_replacement = match extern_crate.orig_name {
 180                 Some(orig_name) => format!("use {} as {};", orig_name, item.ident.name),
 181                 None => format!("use {};", item.ident.name),
 182             };
 183             let vis = tcx.sess.source_map().span_to_snippet(item.vis.span).unwrap_or_default();
 184             let add_vis = |to| if vis.is_empty() { to } else { format!("{} {}", vis, to) };
 185             lint.build("`extern crate` is not idiomatic in the new edition")
 186                 .span_suggestion_short(
 187                     extern_crate.span,
 188                     &format!("convert it to a `{}`", add_vis("use".to_string())),
 189                     add_vis(base_replacement),
 190                     Applicability::MachineApplicable,
 191                 )
 192                 .emit();
 193         })
 194     }
 195 }
 196
 197 struct CollectExternCrateVisitor<'a> {
 198     crates_to_lint: &'a mut Vec<ExternCrateToLint>,
 199 }
 200
 201 struct ExternCrateToLint {
 202     /// `DefId` of the extern crate
 203     def_id: DefId,
 204
 205     /// span from the item
 206     span: Span,
 207
 208     /// if `Some`, then this is renamed (`extern crate orig_name as
 209     /// crate_name`), and -- perhaps surprisingly -- this stores the
 210     /// *original* name (`item.name` will contain the new name)
 211     orig_name: Option<Symbol>,
 212
 213     /// if `false`, the original name started with `_`, so we shouldn't lint
 214     /// about it going unused (but we should still emit idiom lints).
 215     warn_if_unused: bool,
 216 }
 217
 218 impl<'a, 'v> ItemLikeVisitor<'v> for CollectExternCrateVisitor<'a> {
 219     fn visit_item(&mut self, item: &hir::Item<'_>) {
 220         if let hir::ItemKind::ExternCrate(orig_name) = item.kind {
 221             self.crates_to_lint.push(ExternCrateToLint {
 222                 def_id: item.def_id.to_def_id(),
 223                 span: item.span,
 224                 orig_name,
 225                 warn_if_unused: !item.ident.as_str().starts_with('_'),
 226             });
 227         }
 228     }
 229
 230     fn visit_trait_item(&mut self, _trait_item: &hir::TraitItem<'_>) {}
 231
 232     fn visit_impl_item(&mut self, _impl_item: &hir::ImplItem<'_>) {}
 233
 234     fn visit_foreign_item(&mut self, _foreign_item: &hir::ForeignItem<'_>) {}
 235 }