Improve detection of unused imports

Author: jseyfried

src/librustc/middle/region.rs

@@ -20,7 +20,7 @@ use front::map as ast_map;
 use session::Session;
 use util::nodemap::{FnvHashMap, NodeMap, NodeSet};
 use middle::cstore::InlinedItem;
-use middle::ty::{self, Ty};
+use middle::ty;
 
 use std::cell::RefCell;
 use std::collections::hash_map::Entry;

src/librustc_lint/types.rs

@@ -26,7 +26,6 @@ use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64};
 use syntax::{abi, ast};
 use syntax::attr::{self, AttrMetaMethods};
 use syntax::codemap::{self, Span};
-use syntax::ast::{TyIs, TyUs, TyI8, TyU8, TyI16, TyU16, TyI32, TyU32, TyI64, TyU64};
 
 use rustc_front::hir;
 use rustc_front::intravisit::{self, Visitor};

src/librustc_resolve/lib.rs

@@ -1249,7 +1249,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         // modules as we go.
         while index < module_path_len {
             let name = module_path[index];
-            match self.resolve_name_in_module(search_module, name, TypeNS, false) {
+            match self.resolve_name_in_module(search_module, name, TypeNS, false, true) {
                 Failed(None) => {
                     let segment_name = name.as_str();
                     let module_name = module_to_string(search_module);
@@ -1487,7 +1487,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             }
 
             // Resolve the name in the parent module.
-            match self.resolve_name_in_module(search_module, name, namespace, true) {
+            match self.resolve_name_in_module(search_module, name, namespace, true, record_used) {
                 Failed(Some((span, msg))) => {
                     resolve_error(self, span, ResolutionError::FailedToResolve(&*msg));
                 }
@@ -1612,7 +1612,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                               module_: Module<'a>,
                               name: Name,
                               namespace: Namespace,
-                              allow_private_imports: bool)
+                              allow_private_imports: bool,
+                              record_used: bool)
                               -> ResolveResult<(Target<'a>, bool)> {
         debug!("(resolving name in module) resolving `{}` in `{}`",
                name,
@@ -1641,11 +1642,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                     Some(target) => {
                         debug!("(resolving name in module) resolved to import");
                         // track used imports and extern crates as well
-                        let id = import_resolution.id;
-                        self.used_imports.insert((id, namespace));
-                        self.record_import_use(id, name);
-                        if let Some(DefId{krate: kid, ..}) = target.target_module.def_id() {
-                            self.used_crates.insert(kid);
+                        if record_used {
+                            let id = import_resolution.id;
+                            self.used_imports.insert((id, namespace));
+                            self.record_import_use(id, name);
+                            if let Some(DefId{krate: kid, ..}) = target.target_module.def_id() {
+                                self.used_crates.insert(kid);
+                            }
                         }
                         return Success((target, true));
                     }
@@ -2967,7 +2970,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         }
 
         let name = segments.last().unwrap().identifier.name;
-        let def = match self.resolve_name_in_module(containing_module, name, namespace, false) {
+        let result = self.resolve_name_in_module(containing_module, name, namespace, false, true);
+        let def = match result {
             Success((Target { binding, .. }, _)) => {
                 let (def, lp) = binding.def_and_lp();
                 (def, last_private.or(lp))
@@ -3026,7 +3030,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         }
 
         let name = segments.last().unwrap().identifier.name;
-        match self.resolve_name_in_module(containing_module, name, namespace, false) {
+        match self.resolve_name_in_module(containing_module, name, namespace, false, true) {
             Success((Target { binding, .. }, _)) => {
                 let (def, lp) = binding.def_and_lp();
                 Some((def, last_private.or(lp)))
@@ -3068,6 +3072,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                 if let Success((target, _)) = self.resolve_name_in_module(module,
                                                                           ident.unhygienic_name,
                                                                           namespace,
+                                                                          true,
                                                                           true) {
                     if let Some(def) = target.binding.def() {
                         return Some(LocalDef::from_def(def));

src/librustc_trans/trans/debuginfo/metadata.rs

@@ -26,7 +26,7 @@ use llvm::debuginfo::{DIType, DIFile, DIScope, DIDescriptor, DICompositeType};
 use middle::def_id::DefId;
 use middle::infer;
 use middle::pat_util;
-use middle::subst::{self, Substs};
+use middle::subst;
 use rustc::front::map as hir_map;
 use rustc_front::hir;
 use trans::{type_of, adt, machine, monomorphize};

src/librustc_trans/trans/debuginfo/type_names.rs

@@ -15,7 +15,7 @@ use super::namespace::crate_root_namespace;
 use trans::common::CrateContext;
 use middle::def_id::DefId;
 use middle::infer;
-use middle::subst::{self, Substs};
+use middle::subst;
 use middle::ty::{self, Ty};
 
 use rustc_front::hir;

src/librustc_typeck/check/cast.rs

@@ -50,7 +50,6 @@ use middle::ty::cast::{CastKind, CastTy};
 use syntax::codemap::Span;
 use rustc_front::hir;
 use syntax::ast;
-use syntax::ast::UintTy::TyU8;
 
 
 /// Reifies a cast check to be checked once we have full type information for

src/librustc_typeck/check/method/suggest.rs

@@ -17,7 +17,7 @@ use astconv::AstConv;
 use check::{self, FnCtxt};
 use front::map as hir_map;
 use middle::ty::{self, Ty, ToPolyTraitRef, ToPredicate, TypeFoldable};
-use middle::cstore::{self, CrateStore, DefLike};
+use middle::cstore::{self, CrateStore};
 use middle::def::Def;
 use middle::def_id::DefId;
 use middle::lang_items::FnOnceTraitLangItem;

src/librustc_typeck/check/mod.rs

@@ -92,7 +92,7 @@ use middle::infer;
 use middle::infer::{TypeOrigin, type_variable};
 use middle::pat_util::{self, pat_id_map};
 use middle::privacy::{AllPublic, LastMod};
-use middle::subst::{self, Subst, Substs, VecPerParamSpace, ParamSpace, TypeSpace};
+use middle::subst::{self, Subst, Substs, VecPerParamSpace, ParamSpace};
 use middle::traits::{self, report_fulfillment_errors};
 use middle::ty::{GenericPredicates, TypeScheme};
 use middle::ty::{Disr, ParamTy, ParameterEnvironment};

src/test/compile-fail/lint-unused-imports.rs

@@ -56,7 +56,10 @@ mod bar {
         use foo::Point;
         use foo::Square; //~ ERROR unused import
         pub fn cc(_p: Point) -> super::Square {
-            super::Square
+            fn f() -> super::Square {
+                super::Square
+            }
+            f()
         }
     }