use core::atomic;
use core::atomic::Ordering::{Relaxed, Release, Acquire, SeqCst};
use core::fmt;
-use core::cmp::{Ordering};
+use core::cmp::Ordering;
use core::default::Default;
use core::mem::{min_align_of, size_of};
use core::mem;
use core::fmt::Debug;
use core::hash::{Hash, Hasher};
use core::iter::{Map, FromIterator, IntoIterator};
-use core::ops::{Index};
+use core::ops::Index;
use core::{iter, fmt, mem, usize};
use Bound::{self, Included, Excluded, Unbounded};
use alloc::boxed::Box;
use alloc::heap::{EMPTY, allocate, reallocate, deallocate};
use core::cmp::max;
-use core::cmp::{Ordering};
+use core::cmp::Ordering;
use core::default::Default;
use core::fmt;
use core::hash::{self, Hash};
use clone::Clone;
use cmp::{Eq, Ord};
use default::Default;
-use iter::{ExactSizeIterator};
+use iter::ExactSizeIterator;
use iter::{Iterator, IteratorExt, DoubleEndedIterator, FromIterator, IntoIterator};
use mem;
use ops::{Deref, FnOnce};
// this is surprisingly complicated to be both generic & correct
-use core::prelude::{PartialOrd};
+use core::prelude::PartialOrd;
use core::num::Int;
use core::num::wrapping::WrappingOps;
use metadata::decoder;
use metadata::tyencode;
use middle::def;
-use middle::ty::{lookup_item_type};
+use middle::ty::lookup_item_type;
use middle::ty::{self, Ty};
use middle::stability;
use util::nodemap::{FnvHashMap, NodeMap, NodeSet};
//! no means all of the necessary details. Take a look at the rest of
//! metadata::loader or metadata::creader for all the juicy details!
-use back::archive::{METADATA_FILENAME};
+use back::archive::METADATA_FILENAME;
use back::svh::Svh;
use session::Session;
use session::search_paths::PathKind;
use rbml;
use serialize;
use serialize::{Decodable, Decoder, DecoderHelpers, Encodable};
-use serialize::{EncoderHelpers};
+use serialize::EncoderHelpers;
#[cfg(test)] use std::io::Cursor;
#[cfg(test)] use syntax::parse;
use middle::def::*;
use middle::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, Init};
use middle::expr_use_visitor::{JustWrite, LoanCause, MutateMode};
-use middle::expr_use_visitor::{WriteAndRead};
+use middle::expr_use_visitor::WriteAndRead;
use middle::expr_use_visitor as euv;
use middle::mem_categorization::cmt;
use middle::pat_util::*;
//! In particular, it might be enough to say (A,B) are bivariant for
//! all (A,B).
-use middle::ty::{BuiltinBounds};
+use middle::ty::BuiltinBounds;
use middle::ty::{self, Ty};
use middle::ty::TyVar;
use middle::infer::combine::*;
-use middle::infer::{cres};
-use middle::infer::type_variable::{BiTo};
-use util::ppaux::{Repr};
+use middle::infer::cres;
+use middle::infer::type_variable::BiTo;
+use util::ppaux::Repr;
pub struct Bivariate<'f, 'tcx: 'f> {
fields: CombineFields<'f, 'tcx>
use middle::subst::{ErasedRegions, NonerasedRegions, Substs};
use middle::ty::{FloatVar, FnSig, IntVar, TyVar};
use middle::ty::{IntType, UintType};
-use middle::ty::{BuiltinBounds};
+use middle::ty::BuiltinBounds;
use middle::ty::{self, Ty};
use middle::ty_fold;
use middle::ty_fold::{TypeFolder, TypeFoldable};
use middle::ty::{self, Ty};
use middle::ty::TyVar;
use middle::infer::combine::*;
-use middle::infer::{cres};
-use middle::infer::{Subtype};
-use middle::infer::type_variable::{EqTo};
-use util::ppaux::{Repr};
+use middle::infer::cres;
+use middle::infer::Subtype;
+use middle::infer::type_variable::EqTo;
+use util::ppaux::Repr;
pub struct Equate<'f, 'tcx: 'f> {
fields: CombineFields<'f, 'tcx>
use super::combine::*;
use super::lattice::*;
use super::higher_ranked::HigherRankedRelations;
-use super::{cres};
+use super::cres;
use super::Subtype;
use middle::ty::{self, Ty};
use super::glb::Glb;
use super::lub::Lub;
-use middle::ty::{TyVar};
+use middle::ty::TyVar;
use middle::ty::{self, Ty};
use util::ppaux::Repr;
use super::combine::*;
use super::higher_ranked::HigherRankedRelations;
use super::lattice::*;
-use super::{cres};
-use super::{Subtype};
+use super::cres;
+use super::Subtype;
use middle::ty::{self, Ty};
use util::ppaux::Repr;
use middle::ty::replace_late_bound_regions;
use middle::ty::{self, Ty};
use middle::ty_fold::{TypeFolder, TypeFoldable};
-use std::cell::{RefCell};
+use std::cell::RefCell;
use std::fmt;
use std::rc::Rc;
use syntax::ast;
use syntax::codemap;
use syntax::codemap::Span;
use util::nodemap::FnvHashMap;
-use util::ppaux::{ty_to_string};
+use util::ppaux::ty_to_string;
use util::ppaux::{Repr, UserString};
use self::combine::{Combine, Combineable, CombineFields};
// except according to those terms.
use super::combine::*;
-use super::{cres};
+use super::cres;
use super::higher_ranked::HigherRankedRelations;
-use super::{Subtype};
+use super::Subtype;
use super::type_variable::{SubtypeOf, SupertypeOf};
use middle::ty::{self, Ty};
use middle::ty::TyVar;
-use util::ppaux::{Repr};
+use util::ppaux::Repr;
/// "Greatest lower bound" (common subtype)
pub struct Sub<'f, 'tcx: 'f> {
use middle::def;
use middle::region;
use middle::ty::{self, Ty};
-use util::nodemap::{NodeMap};
+use util::nodemap::NodeMap;
use util::ppaux::{Repr, UserString};
use syntax::ast::{MutImmutable, MutMutable};
use util::nodemap::FnvHashMap;
use syntax::ast;
-use syntax::ast_util::{walk_pat};
+use syntax::ast_util::walk_pat;
use syntax::codemap::{Span, DUMMY_SP};
pub type PatIdMap = FnvHashMap<ast::Ident, ast::NodeId>;
use syntax::codemap::{self, Span};
use syntax::{ast, visit};
use syntax::ast::{Block, Item, FnDecl, NodeId, Arm, Pat, Stmt, Expr, Local};
-use syntax::ast_util::{stmt_id};
+use syntax::ast_util::stmt_id;
use syntax::ast_map;
use syntax::ptr::P;
use syntax::visit::{Visitor, FnKind};
use syntax::codemap::Span;
use syntax::parse::token::special_idents;
use syntax::parse::token;
-use syntax::print::pprust::{lifetime_to_string};
+use syntax::print::pprust::lifetime_to_string;
use syntax::visit;
use syntax::visit::Visitor;
use util::nodemap::NodeMap;
use super::Normalized;
use super::SelectionContext;
-use super::{ObligationCause};
+use super::ObligationCause;
use super::PredicateObligation;
use super::project;
use super::util;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use middle::infer::{InferCtxt};
+use middle::infer::InferCtxt;
use middle::ty::{self, RegionEscape, Ty};
use std::collections::HashSet;
use std::default::Default;
use super::project;
use super::project::{normalize_with_depth, Normalized};
use super::{PredicateObligation, TraitObligation, ObligationCause};
-use super::{report_overflow_error};
+use super::report_overflow_error;
use super::{ObligationCauseCode, BuiltinDerivedObligation, ImplDerivedObligation};
use super::{SelectionError, Unimplemented, OutputTypeParameterMismatch};
-use super::{Selection};
-use super::{SelectionResult};
+use super::Selection;
+use super::SelectionResult;
use super::{VtableBuiltin, VtableImpl, VtableParam, VtableClosure,
VtableFnPointer, VtableObject, VtableDefaultImpl};
use super::{VtableImplData, VtableObjectData, VtableBuiltinData, VtableDefaultImplData};
use super::object_safety;
-use super::{util};
+use super::util;
use middle::fast_reject;
use middle::subst::{Subst, Substs, TypeSpace, VecPerParamSpace};
use util::ppaux::{Repr, UserString};
use util::common::{memoized, ErrorReported};
use util::nodemap::{NodeMap, NodeSet, DefIdMap, DefIdSet};
-use util::nodemap::{FnvHashMap};
+use util::nodemap::FnvHashMap;
use arena::TypedArena;
use std::borrow::{Borrow, Cow};
use syntax::ext::base::{SyntaxExtension, NamedSyntaxExtension, NormalTT};
use syntax::ext::base::{IdentTT, Decorator, Modifier, MultiModifier, MacroRulesTT};
-use syntax::ext::base::{MacroExpanderFn};
+use syntax::ext::base::MacroExpanderFn;
use syntax::codemap::Span;
use syntax::parse::token;
use syntax::ptr::P;
#![allow(non_snake_case)]
-use std::collections::hash_state::{DefaultState};
+use std::collections::hash_state::DefaultState;
use std::collections::{HashMap, HashSet};
use std::default::Default;
use std::hash::{Hasher, Hash};
use middle::ty::{ty_bool, ty_char, ty_struct, ty_enum};
use middle::ty::{ty_err, ty_str, ty_vec, ty_float, ty_bare_fn};
use middle::ty::{ty_param, ty_ptr, ty_rptr, ty_tup};
-use middle::ty::{ty_closure};
+use middle::ty::ty_closure;
use middle::ty::{ty_uniq, ty_trait, ty_int, ty_uint, ty_infer};
use middle::ty;
use middle::ty_fold::TypeFoldable;
use self::Fragment::*;
use borrowck::InteriorKind::{InteriorField, InteriorElement};
-use borrowck::{LoanPath};
+use borrowck::LoanPath;
use borrowck::LoanPathKind::{LpVar, LpUpvar, LpDowncast, LpExtend};
use borrowck::LoanPathElem::{LpDeref, LpInterior};
-use borrowck::move_data::{InvalidMovePathIndex};
+use borrowck::move_data::InvalidMovePathIndex;
use borrowck::move_data::{MoveData, MovePathIndex};
use rustc::middle::ty;
use rustc::middle::mem_categorization as mc;
use rustc::middle::mem_categorization as mc;
use rustc::middle::region;
use rustc::middle::ty;
-use rustc::util::ppaux::{Repr};
+use rustc::util::ppaux::Repr;
use syntax::ast;
use syntax::codemap::Span;
use syntax::visit;
use borrowck;
use borrowck::{BorrowckCtxt, LoanPath};
use dot;
-use rustc::middle::cfg::{CFGIndex};
+use rustc::middle::cfg::CFGIndex;
use rustc::middle::dataflow::{DataFlowOperator, DataFlowContext, EntryOrExit};
use rustc::middle::dataflow;
use std::rc::Rc;
use syntax::ast;
use syntax::ast_map;
use syntax::attr;
-use syntax::attr::{AttrMetaMethods};
+use syntax::attr::AttrMetaMethods;
use syntax::diagnostics;
use syntax::parse;
use syntax::parse::token;
use middle::{def, pat_util, stability};
use middle::const_eval::{eval_const_expr_partial, const_int, const_uint};
use middle::cfg;
-use util::ppaux::{ty_to_string};
+use util::ppaux::ty_to_string;
use util::nodemap::{FnvHashMap, NodeSet};
use lint::{Level, Context, LintPass, LintArray, Lint};
use rustc::middle::ty::{MethodTypeParam, MethodStatic};
use rustc::middle::ty::{MethodCall, MethodMap, MethodOrigin, MethodParam};
use rustc::middle::ty::{MethodStaticClosure, MethodObject};
-use rustc::middle::ty::{MethodTraitObject};
+use rustc::middle::ty::MethodTraitObject;
use rustc::middle::ty::{self, Ty};
use rustc::util::nodemap::{NodeMap, NodeSet};
use syntax::ast::TupleVariantKind;
use syntax::ast::UnnamedField;
use syntax::ast::{Variant, ViewPathGlob, ViewPathList, ViewPathSimple};
-use syntax::ast::{Visibility};
+use syntax::ast::Visibility;
use syntax::ast;
use syntax::ast_util::local_def;
use syntax::attr::AttrMetaMethods;
use syntax::ast::{TyF64, TyFloat, TyIs, TyI8, TyI16, TyI32, TyI64, TyInt};
use syntax::ast::{TyPath, TyPtr};
use syntax::ast::{TyRptr, TyStr, TyUs, TyU8, TyU16, TyU32, TyU64, TyUint};
-use syntax::ast::{TypeImplItem};
+use syntax::ast::TypeImplItem;
use syntax::ast;
use syntax::ast_map;
use syntax::ast_util::{local_def, walk_pat};
use super::CrateTranslation;
use super::ModuleTranslation;
-use back::link::{mangle_exported_name};
+use back::link::mangle_exported_name;
use back::{link, abi};
use lint;
use llvm::{AttrHelper, BasicBlockRef, Linkage, ValueRef, Vector, get_param};
// except according to those terms.
use llvm;
-use llvm::{BasicBlockRef};
+use llvm::BasicBlockRef;
use trans::value::{Users, Value};
use std::iter::{Filter, Map};
use arena::TypedArena;
use back::link;
use session;
-use llvm::{ValueRef};
+use llvm::ValueRef;
use llvm::get_param;
use llvm;
use metadata::csearch;
use trans::monomorphize::{self, MonoId};
use trans::type_of::*;
use middle::ty::{self, ClosureTyper};
-use middle::subst::{Substs};
+use middle::subst::Substs;
use session::config::FullDebugInfo;
use util::ppaux::Repr;
use llvm;
use llvm::{ContextRef, ModuleRef, ValueRef, BuilderRef};
-use llvm::{TargetData};
+use llvm::TargetData;
use llvm::mk_target_data;
use metadata::common::LinkMeta;
use middle::def::ExportMap;
use trans::tvec;
use trans::type_of;
use middle::ty::{self, Ty};
-use util::ppaux::{ty_to_string};
+use util::ppaux::ty_to_string;
use std::fmt;
use syntax::ast;
use trans::type_of;
use middle::ty::{struct_fields, tup_fields};
use middle::ty::{AdjustDerefRef, AdjustReifyFnPointer, AdjustUnsafeFnPointer, AutoUnsafe};
-use middle::ty::{AutoPtr};
+use middle::ty::AutoPtr;
use middle::ty::{self, Ty};
use middle::ty::MethodCall;
use util::common::indenter;
// except according to those terms.
-use back::{link};
+use back::link;
use llvm::{ValueRef, CallConv, get_param};
use llvm;
use middle::weak_lang_items;
use syntax::codemap::Span;
use syntax::parse::token::{InternedString, special_idents};
use syntax::parse::token;
-use syntax::{ast};
+use syntax::ast;
use syntax::{attr, ast_map};
use syntax::print::pprust;
use util::ppaux::Repr;
use back::abi;
use llvm;
-use llvm::{ValueRef};
+use llvm::ValueRef;
use trans::base::*;
use trans::base;
use trans::build::*;
use middle::def;
use middle::infer;
use middle::pat_util::{PatIdMap, pat_id_map, pat_is_binding, pat_is_const};
-use middle::subst::{Substs};
+use middle::subst::Substs;
use middle::ty::{self, Ty};
use check::{check_expr, check_expr_has_type, check_expr_with_expectation};
use check::{check_expr_coercable_to_type, demand, FnCtxt, Expectation};
use util::ppaux::{self, Repr};
use syntax::ast;
-use syntax::codemap::{Span};
+use syntax::codemap::Span;
use syntax::parse::token;
use super::assoc;
use astconv::object_region_bounds;
use middle::infer::{InferCtxt, GenericKind};
-use middle::subst::{Substs};
+use middle::subst::Substs;
use middle::traits;
use middle::ty::{self, ToPolyTraitRef, Ty};
use middle::ty_fold::{TypeFoldable, TypeFolder};
//! Method lookup: the secret sauce of Rust. See `README.md`.
use astconv::AstConv;
-use check::{FnCtxt};
+use check::FnCtxt;
use check::vtable;
use check::vtable::select_new_fcx_obligations;
use middle::def;
use util::ppaux::Repr;
use std::rc::Rc;
-use syntax::ast::{DefId};
+use syntax::ast::DefId;
use syntax::ast;
use syntax::codemap::Span;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use super::{MethodError};
+use super::MethodError;
use super::MethodIndex;
use super::{CandidateSource,ImplSource,TraitSource};
use super::suggest;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use check::{FnCtxt};
+use check::FnCtxt;
use middle::traits::{self, ObjectSafetyViolation, MethodViolationCode};
use middle::traits::{Obligation, ObligationCause};
use middle::traits::report_fulfillment_errors;
use std::collections::HashSet;
use syntax::ast;
-use syntax::ast_util::{local_def};
+use syntax::ast_util::local_def;
use syntax::attr;
use syntax::codemap::Span;
use syntax::parse::token::{self, special_idents};
use middle::ty::{ty_rptr, ty_struct, ty_trait, ty_tup};
use middle::ty::{ty_str, ty_vec, ty_float, ty_infer, ty_int};
use middle::ty::{ty_uint, ty_closure, ty_uniq, ty_bare_fn};
-use middle::ty::{ty_projection};
+use middle::ty::ty_projection;
use middle::ty;
use CrateCtxt;
use middle::infer::combine::Combine;
use middle::infer::InferCtxt;
-use middle::infer::{new_infer_ctxt};
-use std::collections::{HashSet};
+use middle::infer::new_infer_ctxt;
+use std::collections::HashSet;
use std::cell::RefCell;
use std::rc::Rc;
use syntax::ast::{Crate, DefId};
use syntax::ast;
use syntax::ast_map::NodeItem;
use syntax::ast_map;
-use syntax::ast_util::{local_def};
-use syntax::codemap::{Span};
+use syntax::ast_util::local_def;
+use syntax::codemap::Span;
use syntax::parse::token;
use syntax::visit;
use util::nodemap::{DefIdMap, FnvHashMap};
use middle::traits;
use middle::ty;
use middle::infer::{self, new_infer_ctxt};
-use syntax::ast::{DefId};
-use syntax::ast::{LOCAL_CRATE};
+use syntax::ast::DefId;
+use syntax::ast::LOCAL_CRATE;
use syntax::ast;
use syntax::ast_util;
use syntax::visit;
use syntax::ast_map;
use syntax::ast_util::local_def;
use syntax::codemap::Span;
-use syntax::parse::token::{special_idents};
+use syntax::parse::token::special_idents;
use syntax::parse::token;
use syntax::ptr::P;
use syntax::visit;
use std::collections::{HashMap, BTreeMap};
use std::io::prelude::*;
use std::io;
-use std::mem::{swap};
+use std::mem::swap;
use std::num::FpCategory as Fp;
use std::ops::Index;
use std::str::FromStr;
use prelude::v1::*;
use self::test::Bencher;
-use iter::{range_inclusive};
+use iter::range_inclusive;
#[bench]
fn new_drop(b : &mut Bencher) {
pub use self::Protocol::*;
use iter::IteratorExt;
-use old_io::{IoResult};
+use old_io::IoResult;
use old_io::net::ip::{SocketAddr, IpAddr};
use option::Option;
use option::Option::{Some, None};
#![allow(deprecated)] // rand
use env;
-use iter::{IteratorExt};
+use iter::IteratorExt;
use old_io::{fs, IoError, IoErrorKind, IoResult};
use old_io;
use ops::Drop;
use self::FutureState::*;
use sync::mpsc::{Receiver, channel};
-use thunk::{Thunk};
+use thunk::Thunk;
use thread;
/// A type encapsulating the result of a computation which may not be complete
use super::c::{ENABLE_PROCESSED_INPUT, ENABLE_QUICK_EDIT_MODE};
use super::c::CONSOLE_SCREEN_BUFFER_INFO;
use super::c::{ReadConsoleW, WriteConsoleW, GetConsoleMode, SetConsoleMode};
-use super::c::{GetConsoleScreenBufferInfo};
+use super::c::GetConsoleScreenBufferInfo;
fn invalid_encoding() -> IoError {
IoError {
use abi;
use ast::{Block, FnDecl, NodeId};
use ast;
-use ast_map::{Node};
+use ast_map::Node;
use ast_map;
use codemap::Span;
use visit;
use ext::base;
use feature_gate;
use parse::token;
-use parse::token::{str_to_ident};
+use parse::token::str_to_ident;
use ptr::P;
pub fn expand_syntax_ext<'cx>(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
use ast::{MetaItem, Item, Expr};
use codemap::Span;
use ext::base::ExtCtxt;
-use ext::build::{AstBuilder};
+use ext::build::AstBuilder;
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
use ptr::P;
use diagnostic::SpanHandler;
use ext::tt::transcribe::tt_next_token;
use parse::token;
-use parse::token::{str_to_ident};
+use parse::token::str_to_ident;
use std::borrow::{IntoCow, Cow};
use std::char;
pub use self::PathParsingMode::*;
use abi;
-use ast::{BareFnTy};
+use ast::BareFnTy;
use ast::{RegionTyParamBound, TraitTyParamBound, TraitBoundModifier};
use ast::{Public, Unsafety};
use ast::{Mod, BiAdd, Arg, Arm, Attribute, BindByRef, BindByValue};
// except according to those terms.
use ast;
-use parse::{new_parse_sess};
+use parse::new_parse_sess;
use parse::{ParseSess,string_to_filemap,filemap_to_tts};
-use parse::{new_parser_from_source_str};
+use parse::new_parser_from_source_str;
use parse::parser::Parser;
use parse::token;
use ptr::P;
use std::io;
use std::iter::repeat;
use std::num::{Float, Int};
-use std::path::{PathBuf};
+use std::path::PathBuf;
use std::sync::mpsc::{channel, Sender};
use std::sync::{Arc, Mutex};
use std::thread;
// except according to those terms.
extern crate cci_lib;
-use cci_lib::{cci_fn};
+use cci_lib::cci_fn;
fn call1() -> uint {
cci_fn()
extern crate trait_superkinds_in_metadata;
use trait_superkinds_in_metadata::{RequiresRequiresShareAndSend, RequiresShare};
-use trait_superkinds_in_metadata::{RequiresCopy};
+use trait_superkinds_in_metadata::RequiresCopy;
use std::marker;
#[derive(Copy)]
#![allow(unknown_features)]
#![feature(unboxed_closures, old_path, std_misc)]
-use std::old_path::{Path};
+use std::old_path::Path;
use std::old_path;
use std::result;
use std::thunk::Thunk;
#![feature(unboxed_closures, core)]
-use std::ops::{FnMut};
+use std::ops::FnMut;
struct S {
x: i32,