Rollup merge of rust-lang#30325 - jseyfried:fixes_30078, r=nrc

This fixes a bug in which unused imports can get wrongly marked as used when checking for unused qualifications in `resolve_path` (issue rust-lang#30078), and it removes unused imports that were previously undetected because of the bug.

src/compiletest/runtest.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use self::TargetLocation::*;
-
 use common::Config;
 use common::{CompileFail, ParseFail, Pretty, RunFail, RunPass, RunPassValgrind};
 use common::{Codegen, DebugInfoLldb, DebugInfoGdb, Rustdoc};

src/libcollections/btree/node.rs

@@ -23,7 +23,7 @@ use core::marker::PhantomData;
 use core::ops::{Deref, DerefMut, Index, IndexMut};
 use core::ptr::Unique;
 use core::{slice, mem, ptr, cmp};
-use alloc::heap::{self, EMPTY};
+use alloc::heap;
 
 use borrow::Borrow;
 

src/libcollections/string.rs

@@ -23,7 +23,7 @@ use core::fmt;
 use core::hash;
 use core::iter::FromIterator;
 use core::mem;
-use core::ops::{self, Deref, Add, Index};
+use core::ops::{self, Add};
 use core::ptr;
 use core::slice;
 use core::str::pattern::Pattern;

src/libcollections/vec.rs

@@ -68,7 +68,7 @@ use core::hash::{self, Hash};
 use core::intrinsics::{arith_offset, assume, needs_drop};
 use core::iter::FromIterator;
 use core::mem;
-use core::ops::{Index, IndexMut, Deref};
+use core::ops::{Index, IndexMut};
 use core::ops;
 use core::ptr;
 use core::slice;

src/libcore/slice.rs

@@ -48,7 +48,6 @@ use result::Result;
 use result::Result::{Ok, Err};
 use ptr;
 use mem;
-use mem::size_of;
 use marker::{Send, Sync, self};
 use num::wrapping::OverflowingOps;
 use raw::Repr;

src/librustc/lint/context.rs

@@ -26,7 +26,7 @@
 use self::TargetLint::*;
 
 use middle::privacy::AccessLevels;
-use middle::ty::{self, Ty};
+use middle::ty;
 use session::{early_error, Session};
 use lint::{Level, LevelSource, Lint, LintId, LintArray, LintPass};
 use lint::{EarlyLintPass, EarlyLintPassObject, LateLintPass, LateLintPassObject};

src/librustc/middle/infer/combine.rs

@@ -41,7 +41,6 @@ use super::{InferCtxt};
 use super::{MiscVariable, TypeTrace};
 use super::type_variable::{RelationDir, BiTo, EqTo, SubtypeOf, SupertypeOf};
 
-use middle::ty::{TyVar};
 use middle::ty::{IntType, UintType};
 use middle::ty::{self, Ty};
 use middle::ty::error::TypeError;

src/librustc/middle/infer/mod.rs

@@ -27,10 +27,9 @@ use middle::region::CodeExtent;
 use middle::subst;
 use middle::subst::Substs;
 use middle::subst::Subst;
-use middle::traits::{self, FulfillmentContext, Normalized,
-                     SelectionContext, ObligationCause};
+use middle::traits;
 use middle::ty::adjustment;
-use middle::ty::{TyVid, IntVid, FloatVid, RegionVid};
+use middle::ty::{TyVid, IntVid, FloatVid};
 use middle::ty::{self, Ty, HasTypeFlags};
 use middle::ty::error::{ExpectedFound, TypeError, UnconstrainedNumeric};
 use middle::ty::fold::{TypeFolder, TypeFoldable};

src/librustc/middle/infer/region_inference/mod.rs

@@ -23,7 +23,7 @@ use rustc_data_structures::graph::{self, Direction, NodeIndex};
 use rustc_data_structures::unify::{self, UnificationTable};
 use middle::free_region::FreeRegionMap;
 use middle::ty::{self, Ty};
-use middle::ty::{BoundRegion, FreeRegion, Region, RegionVid};
+use middle::ty::{BoundRegion, Region, RegionVid};
 use middle::ty::{ReEmpty, ReStatic, ReFree, ReEarlyBound};
 use middle::ty::{ReLateBound, ReScope, ReVar, ReSkolemized, BrFresh};
 use middle::ty::error::TypeError;

src/librustc/middle/stability.rs

@@ -29,7 +29,7 @@ use syntax::attr::{self, Stability, Deprecation, AttrMetaMethods};
 use util::nodemap::{DefIdMap, FnvHashSet, FnvHashMap};
 
 use rustc_front::hir;
-use rustc_front::hir::{Block, Crate, Item, Generics, StructField, Variant};
+use rustc_front::hir::{Crate, Item, Generics, StructField, Variant};
 use rustc_front::intravisit::{self, Visitor};
 
 use std::mem::replace;

src/librustc/middle/ty/mod.rs

@@ -26,7 +26,7 @@ use middle::cstore::{self, CrateStore, LOCAL_CRATE};
 use middle::def::{self, ExportMap};
 use middle::def_id::DefId;
 use middle::lang_items::{FnTraitLangItem, FnMutTraitLangItem, FnOnceTraitLangItem};
-use middle::subst::{self, ParamSpace, Subst, Substs, VecPerParamSpace};
+use middle::subst::{self, Subst, Substs, VecPerParamSpace};
 use middle::traits;
 use middle::ty;
 use middle::ty::fold::TypeFolder;
@@ -51,7 +51,6 @@ use syntax::parse::token::{InternedString, special_idents};
 
 use rustc_front::hir;
 use rustc_front::hir::{ItemImpl, ItemTrait};
-use rustc_front::hir::{MutImmutable, MutMutable, Visibility};
 
 pub use self::sty::{Binder, DebruijnIndex};
 pub use self::sty::{BuiltinBound, BuiltinBounds, ExistentialBounds};

src/librustc/util/ppaux.rs

@@ -11,16 +11,13 @@
 
 use middle::def_id::DefId;
 use middle::subst::{self, Subst};
-use middle::ty::{BoundRegion, BrAnon, BrNamed};
-use middle::ty::{ReEarlyBound, BrFresh, ctxt};
-use middle::ty::{ReFree, ReScope, ReStatic, Region, ReEmpty};
-use middle::ty::{ReSkolemized, ReVar, BrEnv};
+use middle::ty::{BrAnon, BrEnv, BrFresh, BrNamed};
 use middle::ty::{TyBool, TyChar, TyStruct, TyEnum};
 use middle::ty::{TyError, TyStr, TyArray, TySlice, TyFloat, TyBareFn};
 use middle::ty::{TyParam, TyRawPtr, TyRef, TyTuple};
 use middle::ty::TyClosure;
 use middle::ty::{TyBox, TyTrait, TyInt, TyUint, TyInfer};
-use middle::ty::{self, TypeAndMut, Ty, HasTypeFlags};
+use middle::ty::{self, Ty, HasTypeFlags};
 use middle::ty::fold::TypeFoldable;
 
 use std::fmt;

src/librustc_borrowck/borrowck/gather_loans/mod.rs

@@ -29,7 +29,7 @@ use syntax::ast;
 use syntax::codemap::Span;
 use syntax::ast::NodeId;
 use rustc_front::hir;
-use rustc_front::hir::{Expr, FnDecl, Block, Pat};
+use rustc_front::hir::Expr;
 use rustc_front::intravisit;
 use rustc_front::intravisit::Visitor;
 

src/librustc_borrowck/borrowck/mod.rs

@@ -38,7 +38,7 @@ use rustc::middle::ty::{self, Ty};
 use std::fmt;
 use std::mem;
 use std::rc::Rc;
-use syntax::ast::{self, NodeId};
+use syntax::ast;
 use syntax::codemap::Span;
 
 use rustc_front::hir;

src/librustc_metadata/tls_context.rs

@@ -16,7 +16,7 @@ use rbml::reader::Decoder as RbmlDecoder;
 use rustc::middle::cstore::tls;
 use rustc::middle::def_id::DefId;
 use rustc::middle::subst::Substs;
-use rustc::middle::ty::{self, Ty};
+use rustc::middle::ty;
 
 use decoder::{self, Cmd};
 use encoder;

src/librustc_privacy/lib.rs

@@ -45,7 +45,7 @@ use rustc::middle::privacy::ImportUse::*;
 use rustc::middle::privacy::LastPrivate::*;
 use rustc::middle::privacy::PrivateDep::*;
 use rustc::middle::privacy::ExternalExports;
-use rustc::middle::ty::{self, Ty};
+use rustc::middle::ty;
 use rustc::util::nodemap::NodeMap;
 use rustc::front::map as ast_map;
 

src/librustc_resolve/build_reduced_graph.rs

@@ -38,12 +38,12 @@ use syntax::parse::token::special_idents;
 use syntax::codemap::{Span, DUMMY_SP};
 
 use rustc_front::hir;
-use rustc_front::hir::{Block, Crate, DeclItem};
+use rustc_front::hir::{Block, DeclItem};
 use rustc_front::hir::{ForeignItem, ForeignItemFn, ForeignItemStatic};
 use rustc_front::hir::{Item, ItemConst, ItemEnum, ItemExternCrate, ItemFn};
 use rustc_front::hir::{ItemForeignMod, ItemImpl, ItemMod, ItemStatic, ItemDefaultImpl};
 use rustc_front::hir::{ItemStruct, ItemTrait, ItemTy, ItemUse};
-use rustc_front::hir::{NamedField, PathListIdent, PathListMod, Public};
+use rustc_front::hir::{NamedField, PathListIdent, PathListMod};
 use rustc_front::hir::StmtDecl;
 use rustc_front::hir::UnnamedField;
 use rustc_front::hir::{Variant, ViewPathGlob, ViewPathList, ViewPathSimple};

src/librustc_resolve/lib.rs

@@ -64,7 +64,7 @@ use rustc::middle::ty::{Freevar, FreevarMap, TraitMap, GlobMap};
 use rustc::util::nodemap::{NodeMap, DefIdSet, FnvHashMap};
 
 use syntax::ast;
-use syntax::ast::{CRATE_NODE_ID, Ident, Name, NodeId, CrateNum, TyIs, TyI8, TyI16, TyI32, TyI64};
+use syntax::ast::{CRATE_NODE_ID, Name, NodeId, CrateNum, TyIs, TyI8, TyI16, TyI32, TyI64};
 use syntax::ast::{TyUs, TyU8, TyU16, TyU32, TyU64, TyF64, TyF32};
 use syntax::attr::AttrMetaMethods;
 use syntax::parse::token::{self, special_names, special_idents};
@@ -1463,7 +1463,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
     fn resolve_item_in_lexical_scope(&mut self,
                                      module_: Rc<Module>,
                                      name: Name,
-                                     namespace: Namespace)
+                                     namespace: Namespace,
+                                     record_used: bool)
                                      -> ResolveResult<(Target, bool)> {
         debug!("(resolving item in lexical scope) resolving `{}` in namespace {:?} in `{}`",
                name,
@@ -1503,10 +1504,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                     debug!("(resolving item in lexical scope) using import resolution");
                     // track used imports and extern crates as well
                     let id = import_resolution[namespace].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 {
+                        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, false));
                 }
@@ -1583,7 +1586,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                        -> ResolveResult<Rc<Module>> {
         // If this module is an anonymous module, resolve the item in the
         // lexical scope. Otherwise, resolve the item from the crate root.
-        let resolve_result = self.resolve_item_in_lexical_scope(module_, name, TypeNS);
+        let resolve_result = self.resolve_item_in_lexical_scope(module_, name, TypeNS, true);
         match resolve_result {
             Success((target, _)) => {
                 if let Some(module_def) = target.binding.module() {
@@ -2791,7 +2794,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                        span: Span)
                                        -> BareIdentifierPatternResolution {
         let module = self.current_module.clone();
-        match self.resolve_item_in_lexical_scope(module, name, ValueNS) {
+        match self.resolve_item_in_lexical_scope(module, name, ValueNS, true) {
             Success((target, _)) => {
                 debug!("(resolve bare identifier pattern) succeeded in finding {} at {:?}",
                        name,
@@ -2899,17 +2902,16 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         }
 
         // Try to find a path to an item in a module.
-        let unqualified_def = self.resolve_identifier(segments.last().unwrap().identifier,
-                                                      namespace,
-                                                      check_ribs);
-
+        let last_ident = segments.last().unwrap().identifier;
         if segments.len() <= 1 {
+            let unqualified_def = self.resolve_identifier(last_ident, namespace, check_ribs, true);
             return unqualified_def.and_then(|def| self.adjust_local_def(def, span))
                                   .map(|def| {
                                       PathResolution::new(def, LastMod(AllPublic), path_depth)
                                   });
         }
 
+        let unqualified_def = self.resolve_identifier(last_ident, namespace, check_ribs, false);
         let def = self.resolve_module_relative_path(span, segments, namespace);
         match (def, unqualified_def) {
             (Some((ref d, _)), Some(ref ud)) if *d == ud.def => {
@@ -2929,7 +2931,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
     fn resolve_identifier(&mut self,
                           identifier: hir::Ident,
                           namespace: Namespace,
-                          check_ribs: bool)
+                          check_ribs: bool,
+                          record_used: bool)
                           -> Option<LocalDef> {
         // First, check to see whether the name is a primitive type.
         if namespace == TypeNS {
@@ -2946,7 +2949,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             }
         }
 
-        self.resolve_item_by_name_in_lexical_scope(identifier.unhygienic_name, namespace)
+        let name = identifier.unhygienic_name;
+        self.resolve_item_by_name_in_lexical_scope(name, namespace, record_used)
             .map(LocalDef::from_def)
     }
 
@@ -3197,11 +3201,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
 
     fn resolve_item_by_name_in_lexical_scope(&mut self,
                                              name: Name,
-                                             namespace: Namespace)
+                                             namespace: Namespace,
+                                             record_used: bool)
                                              -> Option<Def> {
         // Check the items.
         let module = self.current_module.clone();
-        match self.resolve_item_in_lexical_scope(module, name, namespace) {
+        match self.resolve_item_in_lexical_scope(module, name, namespace, record_used) {
             Success((target, _)) => {
                 match target.binding.def() {
                     None => {

src/librustc_trans/save/dump_csv.rs

@@ -34,10 +34,9 @@ use session::Session;
 
 use middle::def;
 use middle::def_id::DefId;
-use middle::ty::{self, Ty};
+use middle::ty;
 
 use std::fs::File;
-use std::path::Path;
 
 use syntax::ast::{self, NodeId};
 use syntax::codemap::*;

src/librustc_trans/trans/closure.rs

@@ -20,7 +20,7 @@ use trans::build::*;
 use trans::callee::{self, ArgVals, Callee, TraitItem, MethodData};
 use trans::cleanup::{CleanupMethods, CustomScope, ScopeId};
 use trans::common::*;
-use trans::datum::{self, Datum, rvalue_scratch_datum, Rvalue, ByValue};
+use trans::datum::{self, Datum, rvalue_scratch_datum, Rvalue};
 use trans::debuginfo::{self, DebugLoc};
 use trans::declare;
 use trans::expr;

src/librustc_trans/trans/debuginfo/gdb.rs

@@ -11,7 +11,6 @@
 // .debug_gdb_scripts binary section.
 
 use llvm;
-use llvm::ValueRef;
 
 use trans::common::{C_bytes, CrateContext, C_i32};
 use trans::declare;

src/librustc_trans/trans/intrinsic.rs

@@ -14,7 +14,7 @@ use arena::TypedArena;
 use intrinsics::{self, Intrinsic};
 use libc;
 use llvm;
-use llvm::{SequentiallyConsistent, Acquire, Release, AtomicXchg, ValueRef, TypeKind};
+use llvm::{ValueRef, TypeKind};
 use middle::infer;
 use middle::subst;
 use middle::subst::FnSpace;
@@ -32,10 +32,8 @@ use trans::debuginfo::DebugLoc;
 use trans::declare;
 use trans::expr;
 use trans::glue;
-use trans::type_of::*;
 use trans::type_of;
 use trans::machine;
-use trans::machine::llsize_of;
 use trans::type_::Type;
 use middle::ty::{self, Ty, HasTypeFlags};
 use middle::subst::Substs;

src/librustc_trans/trans/meth.rs

@@ -28,7 +28,6 @@ use trans::consts;
 use trans::datum::*;
 use trans::debuginfo::DebugLoc;
 use trans::declare;
-use trans::expr::SaveIn;
 use trans::expr;
 use trans::glue;
 use trans::machine;

src/librustc_typeck/check/mod.rs

@@ -93,7 +93,7 @@ use middle::pat_util::{self, pat_id_map};
 use middle::privacy::{AllPublic, LastMod};
 use middle::subst::{self, Subst, Substs, VecPerParamSpace, ParamSpace, TypeSpace};
 use middle::traits::{self, report_fulfillment_errors};
-use middle::ty::{FnSig, GenericPredicates, TypeScheme};
+use middle::ty::{GenericPredicates, TypeScheme};
 use middle::ty::{Disr, ParamTy, ParameterEnvironment};
 use middle::ty::{LvaluePreference, NoPreference, PreferMutLvalue};
 use middle::ty::{self, HasTypeFlags, RegionEscape, ToPolyTraitRef, Ty};
@@ -127,7 +127,6 @@ use syntax::util::lev_distance::lev_distance;
 use rustc_front::intravisit::{self, Visitor};
 use rustc_front::hir;
 use rustc_front::hir::Visibility;
-use rustc_front::hir::{Item, ItemImpl};
 use rustc_front::print::pprust;
 use rustc_back::slice;
 

src/librustc_typeck/check/regionck.rs

@@ -92,7 +92,7 @@ use middle::mem_categorization::Categorization;
 use middle::region::CodeExtent;
 use middle::subst::Substs;
 use middle::traits;
-use middle::ty::{self, RegionEscape, ReScope, Ty, MethodCall, HasTypeFlags};
+use middle::ty::{self, RegionEscape, Ty, MethodCall, HasTypeFlags};
 use middle::infer::{self, GenericKind, InferCtxt, SubregionOrigin, TypeOrigin, VerifyBound};
 use middle::pat_util;
 use middle::ty::adjustment;

src/librustc_typeck/coherence/mod.rs

@@ -40,7 +40,6 @@ use syntax::codemap::Span;
 use syntax::parse::token;
 use util::nodemap::{DefIdMap, FnvHashMap};
 use rustc::front::map as hir_map;
-use rustc::front::map::NodeItem;
 use rustc_front::intravisit;
 use rustc_front::hir::{Item, ItemImpl,Crate};
 use rustc_front::hir;

src/librustc_typeck/coherence/orphan.rs

@@ -19,7 +19,6 @@ use syntax::ast;
 use syntax::codemap::Span;
 use rustc_front::intravisit;
 use rustc_front::hir;
-use rustc_front::hir::{Item, ItemImpl};
 
 pub fn check(tcx: &ty::ctxt) {
     let mut orphan = OrphanChecker { tcx: tcx };

src/librustc_typeck/coherence/overlap.rs

@@ -15,7 +15,7 @@ use middle::cstore::{CrateStore, LOCAL_CRATE};
 use middle::def_id::DefId;
 use middle::traits;
 use middle::ty;
-use middle::infer::{self, new_infer_ctxt};
+use middle::infer;
 use syntax::ast;
 use syntax::codemap::Span;
 use rustc_front::hir;