blob: 7af1a342ff36edd98b532739407c13aa4910aae7 [file] [log] [blame]
use crate::lint;
use rustc::ty::TyCtxt;
use errors::Applicability;
use syntax::ast;
use syntax_pos::Span;
use rustc::hir::def_id::{DefId, LOCAL_CRATE};
use rustc::hir::itemlikevisit::ItemLikeVisitor;
use rustc::hir::print::visibility_qualified;
use rustc::hir;
use rustc::util::nodemap::DefIdSet;
use rustc_data_structures::fx::FxHashMap;
pub fn check_crate(tcx: TyCtxt<'_>) {
let mut used_trait_imports = DefIdSet::default();
for &body_id in tcx.hir().krate().bodies.keys() {
let item_def_id = tcx.hir().body_owner_def_id(body_id);
let imports = tcx.used_trait_imports(item_def_id);
debug!("GatherVisitor: item_def_id={:?} with imports {:#?}", item_def_id, imports);
let mut visitor = CheckVisitor { tcx, used_trait_imports };
tcx.hir().krate().visit_all_item_likes(&mut visitor);
impl ItemLikeVisitor<'v> for CheckVisitor<'tcx> {
fn visit_item(&mut self, item: &hir::Item) {
if item.vis.node.is_pub() || item.span.is_dummy() {
if let hir::ItemKind::Use(ref path, _) = item.kind {
self.check_import(item.hir_id, path.span);
fn visit_trait_item(&mut self, _trait_item: &hir::TraitItem) {
fn visit_impl_item(&mut self, _impl_item: &hir::ImplItem) {
struct CheckVisitor<'tcx> {
tcx: TyCtxt<'tcx>,
used_trait_imports: DefIdSet,
impl CheckVisitor<'tcx> {
fn check_import(&self, id: hir::HirId, span: Span) {
let def_id = self.tcx.hir().local_def_id(id);
if !self.tcx.maybe_unused_trait_import(def_id) {
if self.used_trait_imports.contains(&def_id) {
let msg = if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
format!("unused import: `{}`", snippet)
} else {
"unused import".to_owned()
self.tcx.lint_hir(lint::builtin::UNUSED_IMPORTS, id, span, &msg);
fn unused_crates_lint(tcx: TyCtxt<'_>) {
let lint = lint::builtin::UNUSED_EXTERN_CRATES;
// Collect first the crates that are completely unused. These we
// can always suggest removing (no matter which edition we are
// in).
let unused_extern_crates: FxHashMap<DefId, Span> =
.filter(|&&(def_id, _)| {
// The `def_id` here actually was calculated during resolution (at least
// at the time of this writing) and is being shipped to us via a side
// channel of the tcx. There may have been extra expansion phases,
// however, which ended up removing the `def_id` *after* expansion such
// as the `ReplaceBodyWithLoop` pass (which is a bit of a hack, but hey)
// As a result we need to verify that `def_id` is indeed still valid for
// our AST and actually present in the HIR map. If it's not there then
// there's safely nothing to warn about, and otherwise we carry on with
// our execution.
// Note that if we carry through to the `extern_mod_stmt_cnum` query
// below it'll cause a panic because `def_id` is actually bogus at this
// point in time otherwise.
if let Some(id) = tcx.hir().as_local_hir_id(def_id) {
if tcx.hir().find(id).is_none() {
return false;
.filter(|&&(def_id, _)| {
tcx.extern_mod_stmt_cnum(def_id).map_or(true, |cnum| {
!tcx.is_compiler_builtins(cnum) &&
!tcx.is_panic_runtime(cnum) &&
!tcx.has_global_allocator(cnum) &&
// Collect all the extern crates (in a reliable order).
let mut crates_to_lint = vec![];
tcx.hir().krate().visit_all_item_likes(&mut CollectExternCrateVisitor {
crates_to_lint: &mut crates_to_lint,
for extern_crate in &crates_to_lint {
let id = tcx.hir().as_local_hir_id(extern_crate.def_id).unwrap();
let item = tcx.hir().expect_item(id);
// If the crate is fully unused, we suggest removing it altogether.
// We do this in any edition.
if extern_crate.warn_if_unused {
if let Some(&span) = unused_extern_crates.get(&extern_crate.def_id) {
let msg = "unused extern crate";
// Removal suggestion span needs to include attributes (Issue #54400)
let span_with_attrs = tcx.get_attrs(extern_crate.def_id).iter()
.map(|attr| attr.span)
.fold(span, |acc, attr_span|;
tcx.struct_span_lint_hir(lint, id, span, msg)
"remove it",
// If we are not in Rust 2018 edition, then we don't make any further
// suggestions.
if !tcx.sess.rust_2018() {
// If the extern crate isn't in the extern prelude,
// there is no way it can be written as an `use`.
let orig_name = extern_crate.orig_name.unwrap_or(;
if !tcx.extern_prelude.get(&orig_name).map_or(false, |from_item| !from_item) {
// If the extern crate is renamed, then we cannot suggest replacing it with a use as this
// would not insert the new name into the prelude, where other imports in the crate may be
// expecting it.
if extern_crate.orig_name.is_some() {
// If the extern crate has any attributes, they may have funky
// semantics we can't faithfully represent using `use` (most
// notably `#[macro_use]`). Ignore it.
if !tcx.get_attrs(extern_crate.def_id).is_empty() {
// Otherwise, we can convert it into a `use` of some kind.
let msg = "`extern crate` is not idiomatic in the new edition";
let help = format!(
"convert it to a `{}`",
visibility_qualified(&item.vis, "use")
let base_replacement = match extern_crate.orig_name {
Some(orig_name) => format!("use {} as {};", orig_name,,
None => format!("use {};",,
let replacement = visibility_qualified(&item.vis, base_replacement);
tcx.struct_span_lint_hir(lint, id, extern_crate.span, msg)
struct CollectExternCrateVisitor<'a, 'tcx> {
tcx: TyCtxt<'tcx>,
crates_to_lint: &'a mut Vec<ExternCrateToLint>,
struct ExternCrateToLint {
/// `DefId` of the extern crate
def_id: DefId,
/// span from the item
span: Span,
/// if `Some`, then this is renamed (`extern crate orig_name as
/// crate_name`), and -- perhaps surprisingly -- this stores the
/// *original* name (`` will contain the new name)
orig_name: Option<ast::Name>,
/// if `false`, the original name started with `_`, so we shouldn't lint
/// about it going unused (but we should still emit idiom lints).
warn_if_unused: bool,
impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for CollectExternCrateVisitor<'a, 'tcx> {
fn visit_item(&mut self, item: &hir::Item) {
if let hir::ItemKind::ExternCrate(orig_name) = item.kind {
let extern_crate_def_id = self.tcx.hir().local_def_id(item.hir_id);
ExternCrateToLint {
def_id: extern_crate_def_id,
span: item.span,
warn_if_unused: !item.ident.as_str().starts_with('_'),
fn visit_trait_item(&mut self, _trait_item: &hir::TraitItem) {
fn visit_impl_item(&mut self, _impl_item: &hir::ImplItem) {