1 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
2 use rustc_errors::Applicability;
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};
10 pub fn check_crate(tcx: TyCtxt<'_>) {
11 let mut used_trait_imports = FxHashSet::default();
12 for item_def_id in tcx.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());
18 let mut visitor = CheckVisitor { tcx, used_trait_imports };
19 tcx.hir().krate().visit_all_item_likes(&mut visitor);
21 unused_crates_lint(tcx);
24 impl ItemLikeVisitor<'v> for CheckVisitor<'tcx> {
25 fn visit_item(&mut self, item: &hir::Item<'_>) {
26 if item.vis.node.is_pub() || item.span.is_dummy() {
29 if let hir::ItemKind::Use(ref path, _) = item.kind {
30 self.check_import(item.item_id(), path.span);
34 fn visit_trait_item(&mut self, _trait_item: &hir::TraitItem<'_>) {}
36 fn visit_impl_item(&mut self, _impl_item: &hir::ImplItem<'_>) {}
38 fn visit_foreign_item(&mut self, _foreign_item: &hir::ForeignItem<'_>) {}
41 struct CheckVisitor<'tcx> {
43 used_trait_imports: FxHashSet<LocalDefId>,
46 impl 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) {
52 if self.used_trait_imports.contains(&item_id.def_id) {
56 self.tcx.struct_span_lint_hir(
57 lint::builtin::UNUSED_IMPORTS,
61 let msg = if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
62 format!("unused import: `{}`", snippet)
64 "unused import".to_owned()
66 lint.build(&msg).emit();
72 fn unused_crates_lint(tcx: TyCtxt<'_>) {
73 let lint = lint::builtin::UNUSED_EXTERN_CRATES;
75 // Collect first the crates that are completely unused. These we
76 // can always suggest removing (no matter which edition we are
78 let unused_extern_crates: FxHashMap<LocalDefId, Span> = tcx
79 .maybe_unused_extern_crates(())
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)
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
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() {
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)
112 // Collect all the extern crates (in a reliable order).
113 let mut crates_to_lint = vec![];
114 tcx.hir().krate().visit_all_item_likes(&mut CollectExternCrateVisitor {
115 crates_to_lint: &mut crates_to_lint,
118 let extern_prelude = &tcx.resolutions(()).extern_prelude;
120 for extern_crate in &crates_to_lint {
121 let def_id = extern_crate.def_id.expect_local();
122 let id = tcx.hir().local_def_id_to_hir_id(def_id);
123 let item = tcx.hir().expect_item(id);
125 // If the crate is fully unused, we suggest removing it altogether.
126 // We do this in any edition.
127 if extern_crate.warn_if_unused {
128 if let Some(&span) = unused_extern_crates.get(&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)
134 .map(|attr| attr.span)
135 .fold(span, |acc, attr_span| acc.to(attr_span));
137 lint.build("unused extern crate")
138 .span_suggestion_short(
142 Applicability::MachineApplicable,
150 // If we are not in Rust 2018 edition, then we don't make any further
152 if !tcx.sess.rust_2018() {
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) {
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
166 if extern_crate.orig_name.is_some() {
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() {
176 tcx.struct_span_lint_hir(lint, id, extern_crate.span, |lint| {
177 // Otherwise, we can convert it into a `use` of some kind.
178 let base_replacement = match extern_crate.orig_name {
179 Some(orig_name) => format!("use {} as {};", orig_name, item.ident.name),
180 None => format!("use {};", item.ident.name),
182 let vis = tcx.sess.source_map().span_to_snippet(item.vis.span).unwrap_or_default();
183 let add_vis = |to| if vis.is_empty() { to } else { format!("{} {}", vis, to) };
184 lint.build("`extern crate` is not idiomatic in the new edition")
185 .span_suggestion_short(
187 &format!("convert it to a `{}`", add_vis("use".to_string())),
188 add_vis(base_replacement),
189 Applicability::MachineApplicable,
196 struct CollectExternCrateVisitor<'a> {
197 crates_to_lint: &'a mut Vec<ExternCrateToLint>,
200 struct ExternCrateToLint {
201 /// `DefId` of the extern crate
204 /// span from the item
207 /// if `Some`, then this is renamed (`extern crate orig_name as
208 /// crate_name`), and -- perhaps surprisingly -- this stores the
209 /// *original* name (`item.name` will contain the new name)
210 orig_name: Option<Symbol>,
212 /// if `false`, the original name started with `_`, so we shouldn't lint
213 /// about it going unused (but we should still emit idiom lints).
214 warn_if_unused: bool,
217 impl<'a, 'v> ItemLikeVisitor<'v> for CollectExternCrateVisitor<'a> {
218 fn visit_item(&mut self, item: &hir::Item<'_>) {
219 if let hir::ItemKind::ExternCrate(orig_name) = item.kind {
220 self.crates_to_lint.push(ExternCrateToLint {
221 def_id: item.def_id.to_def_id(),
224 warn_if_unused: !item.ident.as_str().starts_with('_'),
229 fn visit_trait_item(&mut self, _trait_item: &hir::TraitItem<'_>) {}
231 fn visit_impl_item(&mut self, _impl_item: &hir::ImplItem<'_>) {}
233 fn visit_foreign_item(&mut self, _foreign_item: &hir::ForeignItem<'_>) {}