Refactor away extension traits RegionEscape and HasTypeFlags

src/librustc/middle/implicator.rs

@@ -14,7 +14,7 @@ use middle::def_id::DefId;
 use middle::infer::{InferCtxt, GenericKind};
 use middle::subst::Substs;
 use middle::traits;
-use middle::ty::{self, RegionEscape, ToPredicate, Ty};
+use middle::ty::{self, ToPredicate, Ty};
 use middle::ty::fold::{TypeFoldable, TypeFolder};
 
 use syntax::ast;

src/librustc/middle/infer/error_reporting.rs

@@ -82,7 +82,7 @@ use middle::def_id::DefId;
 use middle::infer::{self, TypeOrigin};
 use middle::region;
 use middle::subst;
-use middle::ty::{self, Ty, HasTypeFlags};
+use middle::ty::{self, Ty, TypeFoldable};
 use middle::ty::{Region, ReFree};
 use middle::ty::error::TypeError;
 
@@ -250,7 +250,7 @@ pub trait ErrorReporting<'tcx> {
 
     fn values_str(&self, values: &ValuePairs<'tcx>) -> Option<String>;
 
-    fn expected_found_str<T: fmt::Display + Resolvable<'tcx> + HasTypeFlags>(
+    fn expected_found_str<T: fmt::Display + Resolvable<'tcx> + TypeFoldable<'tcx>>(
         &self,
         exp_found: &ty::error::ExpectedFound<T>)
         -> Option<String>;
@@ -575,7 +575,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
         }
     }
 
-    fn expected_found_str<T: fmt::Display + Resolvable<'tcx> + HasTypeFlags>(
+    fn expected_found_str<T: fmt::Display + Resolvable<'tcx> + TypeFoldable<'tcx>>(
         &self,
         exp_found: &ty::error::ExpectedFound<T>)
         -> Option<String>

src/librustc/middle/infer/freshen.rs

@@ -30,8 +30,7 @@
 //! variable only once, and it does so as soon as it can, so it is reasonable to ask what the type
 //! inferencer knows "so far".
 
-use middle::ty::{self, Ty, HasTypeFlags};
-use middle::ty::fold::TypeFoldable;
+use middle::ty::{self, Ty, TypeFoldable};
 use middle::ty::fold::TypeFolder;
 use std::collections::hash_map::{self, Entry};
 

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

@@ -14,9 +14,8 @@
 use super::{CombinedSnapshot, InferCtxt, HigherRankedType, SkolemizationMap};
 use super::combine::CombineFields;
 
-use middle::ty::{self, Binder};
+use middle::ty::{self, Binder, TypeFoldable};
 use middle::ty::error::TypeError;
-use middle::ty::fold::TypeFoldable;
 use middle::ty::relate::{Relate, RelateResult, TypeRelation};
 use syntax::codemap::Span;
 use util::nodemap::{FnvHashMap, FnvHashSet};
@@ -557,7 +556,7 @@ pub fn plug_leaks<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
                              snapshot: &CombinedSnapshot,
                              value: &T)
                              -> T
-    where T : TypeFoldable<'tcx> + ty::HasTypeFlags
+    where T : TypeFoldable<'tcx>
 {
     debug_assert!(leak_check(infcx, &skol_map, snapshot).is_ok());
 

src/librustc/middle/infer/mod.rs

@@ -30,7 +30,7 @@ use middle::subst::Subst;
 use middle::traits;
 use middle::ty::adjustment;
 use middle::ty::{TyVid, IntVid, FloatVid};
-use middle::ty::{self, Ty, HasTypeFlags};
+use middle::ty::{self, Ty};
 use middle::ty::error::{ExpectedFound, TypeError, UnconstrainedNumeric};
 use middle::ty::fold::{TypeFolder, TypeFoldable};
 use middle::ty::relate::{Relate, RelateResult, TypeRelation};

src/librustc/middle/infer/resolve.rs

@@ -9,8 +9,7 @@
 // except according to those terms.
 
 use super::{InferCtxt, FixupError, FixupResult};
-use middle::ty::{self, Ty, HasTypeFlags};
-use middle::ty::fold::{TypeFoldable};
+use middle::ty::{self, Ty, TypeFoldable};
 
 ///////////////////////////////////////////////////////////////////////////
 // OPPORTUNISTIC TYPE RESOLVER

src/librustc/middle/intrinsicck.rs

@@ -13,7 +13,7 @@ use middle::def::DefFn;
 use middle::def_id::DefId;
 use middle::subst::{Subst, Substs, EnumeratedItems};
 use middle::ty::{TransmuteRestriction, ctxt, TyBareFn};
-use middle::ty::{self, Ty, HasTypeFlags};
+use middle::ty::{self, Ty, TypeFoldable};
 
 use std::fmt;
 

src/librustc/middle/subst.rs

@@ -14,7 +14,7 @@ pub use self::ParamSpace::*;
 pub use self::RegionSubsts::*;
 
 use middle::cstore;
-use middle::ty::{self, Ty, HasTypeFlags, RegionEscape};
+use middle::ty::{self, Ty};
 use middle::ty::fold::{TypeFoldable, TypeFolder};
 
 use serialize::{Encodable, Encoder, Decodable, Decoder};

src/librustc/middle/traits/error_reporting.rs

@@ -26,9 +26,8 @@ use super::{
 use fmt_macros::{Parser, Piece, Position};
 use middle::def_id::DefId;
 use middle::infer::InferCtxt;
-use middle::ty::{self, ToPredicate, HasTypeFlags, ToPolyTraitRef, TraitRef, Ty};
+use middle::ty::{self, ToPredicate, ToPolyTraitRef, TraitRef, Ty, TypeFoldable};
 use middle::ty::fast_reject;
-use middle::ty::fold::TypeFoldable;
 use util::nodemap::{FnvHashMap, FnvHashSet};
 
 use std::cmp;

src/librustc/middle/traits/fulfill.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use middle::infer::InferCtxt;
-use middle::ty::{self, RegionEscape, Ty, HasTypeFlags};
+use middle::ty::{self, Ty, TypeFoldable};
 
 use syntax::ast;
 use util::common::ErrorReported;

src/librustc/middle/traits/mod.rs

@@ -19,9 +19,8 @@ use dep_graph::DepNode;
 use middle::def_id::DefId;
 use middle::free_region::FreeRegionMap;
 use middle::subst;
-use middle::ty::{self, HasTypeFlags, Ty};
+use middle::ty::{self, Ty, TypeFoldable};
 use middle::ty::fast_reject;
-use middle::ty::fold::TypeFoldable;
 use middle::infer::{self, fixup_err_to_string, InferCtxt};
 
 use std::rc::Rc;

src/librustc/middle/traits/object_safety.rs

@@ -23,7 +23,7 @@ use super::elaborate_predicates;
 use middle::def_id::DefId;
 use middle::subst::{self, SelfSpace, TypeSpace};
 use middle::traits;
-use middle::ty::{self, HasTypeFlags, ToPolyTraitRef, Ty};
+use middle::ty::{self, ToPolyTraitRef, Ty, TypeFoldable};
 use std::rc::Rc;
 use syntax::ast;
 

src/librustc/middle/traits/project.rs

@@ -23,7 +23,7 @@ use super::util;
 
 use middle::infer::{self, TypeOrigin};
 use middle::subst::Subst;
-use middle::ty::{self, ToPredicate, RegionEscape, HasTypeFlags, ToPolyTraitRef, Ty};
+use middle::ty::{self, ToPredicate, ToPolyTraitRef, Ty};
 use middle::ty::fold::{TypeFoldable, TypeFolder};
 use syntax::parse::token;
 use util::common::FN_OUTPUT_NAME;

src/librustc/middle/traits/select.rs

@@ -39,9 +39,8 @@ use middle::def_id::DefId;
 use middle::infer;
 use middle::infer::{InferCtxt, TypeFreshener, TypeOrigin};
 use middle::subst::{Subst, Substs, TypeSpace};
-use middle::ty::{self, ToPredicate, RegionEscape, ToPolyTraitRef, Ty, HasTypeFlags};
+use middle::ty::{self, ToPredicate, ToPolyTraitRef, Ty, TypeFoldable};
 use middle::ty::fast_reject;
-use middle::ty::fold::TypeFoldable;
 use middle::ty::relate::TypeRelation;
 
 use std::cell::RefCell;

src/librustc/middle/ty/adjustment.rs

@@ -11,8 +11,7 @@
 pub use self::AutoAdjustment::*;
 pub use self::AutoRef::*;
 
-use middle::ty::{self, Ty, TypeAndMut};
-use middle::ty::HasTypeFlags;
+use middle::ty::{self, Ty, TypeAndMut, TypeFoldable};
 use middle::ty::LvaluePreference::{NoPreference};
 
 use syntax::ast;

src/librustc/middle/ty/flags.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use middle::subst;
-use middle::ty::{self, HasTypeFlags, Ty, TypeFlags};
+use middle::ty::{self, Ty, TypeFlags, TypeFoldable};
 
 pub struct FlagComputation {
     pub flags: TypeFlags,

src/librustc/middle/ty/fold.rs

@@ -42,7 +42,7 @@
 use middle::region;
 use middle::subst;
 use middle::ty::adjustment;
-use middle::ty::{self, Binder, Ty, RegionEscape, HasTypeFlags};
+use middle::ty::{self, Binder, Ty, TypeFlags};
 
 use std::fmt;
 use util::nodemap::{FnvHashMap, FnvHashSet};
@@ -59,6 +59,53 @@ pub trait TypeFoldable<'tcx>: fmt::Debug + Clone {
     fn visit_subitems_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
         self.visit_with(visitor)
     }
+
+    fn has_regions_escaping_depth(&self, depth: u32) -> bool {
+        self.visit_with(&mut HasEscapingRegionsVisitor { depth: depth })
+    }
+    fn has_escaping_regions(&self) -> bool {
+        self.has_regions_escaping_depth(0)
+    }
+
+    fn has_type_flags(&self, flags: TypeFlags) -> bool {
+        self.visit_with(&mut HasTypeFlagsVisitor { flags: flags })
+    }
+    fn has_projection_types(&self) -> bool {
+        self.has_type_flags(TypeFlags::HAS_PROJECTION)
+    }
+    fn references_error(&self) -> bool {
+        self.has_type_flags(TypeFlags::HAS_TY_ERR)
+    }
+    fn has_param_types(&self) -> bool {
+        self.has_type_flags(TypeFlags::HAS_PARAMS)
+    }
+    fn has_self_ty(&self) -> bool {
+        self.has_type_flags(TypeFlags::HAS_SELF)
+    }
+    fn has_infer_types(&self) -> bool {
+        self.has_type_flags(TypeFlags::HAS_TY_INFER)
+    }
+    fn needs_infer(&self) -> bool {
+        self.has_type_flags(TypeFlags::HAS_TY_INFER | TypeFlags::HAS_RE_INFER)
+    }
+    fn needs_subst(&self) -> bool {
+        self.has_type_flags(TypeFlags::NEEDS_SUBST)
+    }
+    fn has_closure_types(&self) -> bool {
+        self.has_type_flags(TypeFlags::HAS_TY_CLOSURE)
+    }
+    fn has_erasable_regions(&self) -> bool {
+        self.has_type_flags(TypeFlags::HAS_RE_EARLY_BOUND |
+                            TypeFlags::HAS_RE_INFER |
+                            TypeFlags::HAS_FREE_REGIONS)
+    }
+    /// Indicates whether this value references only 'global'
+    /// types/lifetimes that are the same regardless of what fn we are
+    /// in. This is used for caching. Errs on the side of returning
+    /// false.
+    fn is_global(&self) -> bool {
+        !self.has_type_flags(TypeFlags::HAS_LOCAL_NAMES)
+    }
 }
 
 /// The TypeFolder trait defines the actual *folding*. There is a
@@ -518,64 +565,74 @@ pub fn shift_regions<'tcx, T:TypeFoldable<'tcx>>(tcx: &ty::ctxt<'tcx>,
     }))
 }
 
-impl<'tcx, T: TypeFoldable<'tcx>> RegionEscape for T {
-    fn has_regions_escaping_depth(&self, depth: u32) -> bool {
-        struct RegionEscapeVisitor {
-            depth: u32,
-        }
+/// An "escaping region" is a bound region whose binder is not part of `t`.
+///
+/// So, for example, consider a type like the following, which has two binders:
+///
+///    for<'a> fn(x: for<'b> fn(&'a isize, &'b isize))
+///    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ outer scope
+///                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~  inner scope
+///
+/// This type has *bound regions* (`'a`, `'b`), but it does not have escaping regions, because the
+/// binders of both `'a` and `'b` are part of the type itself. However, if we consider the *inner
+/// fn type*, that type has an escaping region: `'a`.
+///
+/// Note that what I'm calling an "escaping region" is often just called a "free region". However,
+/// we already use the term "free region". It refers to the regions that we use to represent bound
+/// regions on a fn definition while we are typechecking its body.
+///
+/// To clarify, conceptually there is no particular difference between an "escaping" region and a
+/// "free" region. However, there is a big difference in practice. Basically, when "entering" a
+/// binding level, one is generally required to do some sort of processing to a bound region, such
+/// as replacing it with a fresh/skolemized region, or making an entry in the environment to
+/// represent the scope to which it is attached, etc. An escaping region represents a bound region
+/// for which this processing has not yet been done.
+struct HasEscapingRegionsVisitor {
+    depth: u32,
+}
 
-        impl<'tcx> TypeVisitor<'tcx> for RegionEscapeVisitor {
-            fn enter_region_binder(&mut self) {
-                self.depth += 1;
-            }
+impl<'tcx> TypeVisitor<'tcx> for HasEscapingRegionsVisitor {
+    fn enter_region_binder(&mut self) {
+        self.depth += 1;
+    }
 
-            fn exit_region_binder(&mut self) {
-                self.depth -= 1;
-            }
+    fn exit_region_binder(&mut self) {
+        self.depth -= 1;
+    }
 
-            fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
-                t.region_depth > self.depth
-            }
+    fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
+        t.region_depth > self.depth
+    }
 
-            fn visit_region(&mut self, r: ty::Region) -> bool {
-                r.escapes_depth(self.depth)
-            }
-        }
-
-        self.visit_with(&mut RegionEscapeVisitor { depth: depth })
+    fn visit_region(&mut self, r: ty::Region) -> bool {
+        r.escapes_depth(self.depth)
     }
 }
 
-impl<'tcx, T: TypeFoldable<'tcx>> HasTypeFlags for T {
-    fn has_type_flags(&self, flags: ty::TypeFlags) -> bool {
-        struct HasTypeFlagsVisitor {
-            flags: ty::TypeFlags,
-        }
+struct HasTypeFlagsVisitor {
+    flags: ty::TypeFlags,
+}
 
-        impl<'tcx> TypeVisitor<'tcx> for HasTypeFlagsVisitor {
-            fn visit_ty(&mut self, t: Ty) -> bool {
-                t.flags.get().intersects(self.flags)
-            }
+impl<'tcx> TypeVisitor<'tcx> for HasTypeFlagsVisitor {
+    fn visit_ty(&mut self, t: Ty) -> bool {
+        t.flags.get().intersects(self.flags)
+    }
 
-            fn visit_region(&mut self, r: ty::Region) -> bool {
-                if self.flags.intersects(ty::TypeFlags::HAS_LOCAL_NAMES) {
-                    // does this represent a region that cannot be named
-                    // in a global way? used in fulfillment caching.
-                    match r {
-                        ty::ReStatic | ty::ReEmpty => {}
-                        _ => return true,
-                    }
-                }
-                if self.flags.intersects(ty::TypeFlags::HAS_RE_INFER) {
-                    match r {
-                        ty::ReVar(_) | ty::ReSkolemized(..) => { return true }
-                        _ => {}
-                    }
-                }
-                false
+    fn visit_region(&mut self, r: ty::Region) -> bool {
+        if self.flags.intersects(ty::TypeFlags::HAS_LOCAL_NAMES) {
+            // does this represent a region that cannot be named
+            // in a global way? used in fulfillment caching.
+            match r {
+                ty::ReStatic | ty::ReEmpty => {}
+                _ => return true,
             }
         }
-
-        self.visit_with(&mut HasTypeFlagsVisitor { flags: flags })
+        if self.flags.intersects(ty::TypeFlags::HAS_RE_INFER) {
+            match r {
+                ty::ReVar(_) | ty::ReSkolemized(..) => { return true }
+                _ => {}
+            }
+        }
+        false
     }
 }

src/librustc/middle/ty/mod.rs

@@ -17,6 +17,7 @@ pub use self::BorrowKind::*;
 pub use self::ImplOrTraitItem::*;
 pub use self::IntVarValue::*;
 pub use self::LvaluePreference::*;
+pub use self::fold::TypeFoldable;
 
 use dep_graph::{self, DepNode};
 use front::map as ast_map;
@@ -2667,73 +2668,3 @@ impl<'tcx> ctxt<'tcx> {
         trait_ref.substs.clone().with_method(meth_tps, meth_regions)
     }
 }
-
-/// An "escaping region" is a bound region whose binder is not part of `t`.
-///
-/// So, for example, consider a type like the following, which has two binders:
-///
-///    for<'a> fn(x: for<'b> fn(&'a isize, &'b isize))
-///    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ outer scope
-///                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~  inner scope
-///
-/// This type has *bound regions* (`'a`, `'b`), but it does not have escaping regions, because the
-/// binders of both `'a` and `'b` are part of the type itself. However, if we consider the *inner
-/// fn type*, that type has an escaping region: `'a`.
-///
-/// Note that what I'm calling an "escaping region" is often just called a "free region". However,
-/// we already use the term "free region". It refers to the regions that we use to represent bound
-/// regions on a fn definition while we are typechecking its body.
-///
-/// To clarify, conceptually there is no particular difference between an "escaping" region and a
-/// "free" region. However, there is a big difference in practice. Basically, when "entering" a
-/// binding level, one is generally required to do some sort of processing to a bound region, such
-/// as replacing it with a fresh/skolemized region, or making an entry in the environment to
-/// represent the scope to which it is attached, etc. An escaping region represents a bound region
-/// for which this processing has not yet been done.
-pub trait RegionEscape {
-    fn has_escaping_regions(&self) -> bool {
-        self.has_regions_escaping_depth(0)
-    }
-
-    fn has_regions_escaping_depth(&self, depth: u32) -> bool;
-}
-
-pub trait HasTypeFlags {
-    fn has_type_flags(&self, flags: TypeFlags) -> bool;
-    fn has_projection_types(&self) -> bool {
-        self.has_type_flags(TypeFlags::HAS_PROJECTION)
-    }
-    fn references_error(&self) -> bool {
-        self.has_type_flags(TypeFlags::HAS_TY_ERR)
-    }
-    fn has_param_types(&self) -> bool {
-        self.has_type_flags(TypeFlags::HAS_PARAMS)
-    }
-    fn has_self_ty(&self) -> bool {
-        self.has_type_flags(TypeFlags::HAS_SELF)
-    }
-    fn has_infer_types(&self) -> bool {
-        self.has_type_flags(TypeFlags::HAS_TY_INFER)
-    }
-    fn needs_infer(&self) -> bool {
-        self.has_type_flags(TypeFlags::HAS_TY_INFER | TypeFlags::HAS_RE_INFER)
-    }
-    fn needs_subst(&self) -> bool {
-        self.has_type_flags(TypeFlags::NEEDS_SUBST)
-    }
-    fn has_closure_types(&self) -> bool {
-        self.has_type_flags(TypeFlags::HAS_TY_CLOSURE)
-    }
-    fn has_erasable_regions(&self) -> bool {
-        self.has_type_flags(TypeFlags::HAS_RE_EARLY_BOUND |
-                            TypeFlags::HAS_RE_INFER |
-                            TypeFlags::HAS_FREE_REGIONS)
-    }
-    /// Indicates whether this value references only 'global'
-    /// types/lifetimes that are the same regardless of what fn we are
-    /// in. This is used for caching. Errs on the side of returning
-    /// false.
-    fn is_global(&self) -> bool {
-        !self.has_type_flags(TypeFlags::HAS_LOCAL_NAMES)
-    }
-}

src/librustc/middle/ty/outlives.rs

@@ -13,7 +13,7 @@
 // RFC for reference.
 
 use middle::infer::InferCtxt;
-use middle::ty::{self, RegionEscape, Ty};
+use middle::ty::{self, Ty, TypeFoldable};
 
 #[derive(Debug)]
 pub enum Component<'tcx> {

src/librustc/middle/ty/relate.rs

@@ -15,9 +15,8 @@
 
 use middle::def_id::DefId;
 use middle::subst::{ErasedRegions, NonerasedRegions, ParamSpace, Substs};
-use middle::ty::{self, Ty};
+use middle::ty::{self, Ty, TypeFoldable};
 use middle::ty::error::{ExpectedFound, TypeError};
-use middle::ty::fold::TypeFoldable;
 use std::rc::Rc;
 use syntax::abi;
 use rustc_front::hir as ast;

src/librustc/middle/ty/structural_impls.rs

@@ -10,8 +10,7 @@
 
 use middle::subst::{self, VecPerParamSpace};
 use middle::traits;
-use middle::ty::{self, TraitRef, Ty, TypeAndMut};
-use middle::ty::Lift;
+use middle::ty::{self, Lift, TraitRef, Ty};
 use middle::ty::fold::{TypeFoldable, TypeFolder, TypeVisitor};
 
 use std::rc::Rc;

src/librustc/middle/ty/sty.rs

@@ -15,8 +15,7 @@ use middle::def_id::DefId;
 use middle::region;
 use middle::subst::{self, Substs};
 use middle::traits;
-use middle::ty::{self, AdtDef, TypeFlags, Ty, TyS};
-use middle::ty::{RegionEscape, ToPredicate};
+use middle::ty::{self, AdtDef, ToPredicate, TypeFlags, Ty, TyS, TypeFoldable};
 use util::common::ErrorReported;
 
 use collections::enum_set::{self, EnumSet, CLike};

src/librustc/middle/ty/util.rs

@@ -18,9 +18,8 @@ use middle::subst::{self, Subst, Substs};
 use middle::infer;
 use middle::pat_util;
 use middle::traits;
-use middle::ty::{self, Ty, TypeAndMut, TypeFlags};
+use middle::ty::{self, Ty, TypeAndMut, TypeFlags, TypeFoldable};
 use middle::ty::{Disr, ParameterEnvironment};
-use middle::ty::{HasTypeFlags, RegionEscape};
 use middle::ty::TypeVariants::*;
 use util::num::ToPrimitive;
 

src/librustc/middle/ty/wf.rs

@@ -13,7 +13,7 @@ use middle::infer::InferCtxt;
 use middle::ty::outlives::{self, Component};
 use middle::subst::Substs;
 use middle::traits;
-use middle::ty::{self, RegionEscape, ToPredicate, Ty};
+use middle::ty::{self, ToPredicate, Ty, TypeFoldable};
 use std::iter::once;
 use syntax::ast;
 use syntax::codemap::Span;

src/librustc/util/ppaux.rs

@@ -17,8 +17,7 @@ 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, Ty, HasTypeFlags};
-use middle::ty::fold::TypeFoldable;
+use middle::ty::{self, Ty, TypeFoldable};
 
 use std::fmt;
 use syntax::{abi};

src/librustc_driver/test.rs

@@ -21,7 +21,7 @@ use rustc_typeck::middle::resolve_lifetime;
 use rustc_typeck::middle::stability;
 use rustc_typeck::middle::subst;
 use rustc_typeck::middle::subst::Subst;
-use rustc_typeck::middle::ty::{self, Ty, RegionEscape};
+use rustc_typeck::middle::ty::{self, Ty, TypeFoldable};
 use rustc_typeck::middle::ty::relate::TypeRelation;
 use rustc_typeck::middle::infer::{self, TypeOrigin};
 use rustc_typeck::middle::infer::lub::Lub;

src/librustc_metadata/decoder.rs

@@ -33,7 +33,7 @@ use middle::def_id::{DefId, DefIndex};
 use middle::lang_items;
 use middle::subst;
 use middle::ty::{ImplContainer, TraitContainer};
-use middle::ty::{self, RegionEscape, Ty};
+use middle::ty::{self, Ty, TypeFoldable};
 
 use rustc::mir;
 use rustc::mir::visit::MutVisitor;

src/librustc_metadata/tydecode.rs

@@ -22,7 +22,7 @@ use middle::def_id::{DefId, DefIndex};
 use middle::region;
 use middle::subst;
 use middle::subst::VecPerParamSpace;
-use middle::ty::{self, ToPredicate, Ty, HasTypeFlags};
+use middle::ty::{self, ToPredicate, Ty, TypeFoldable};
 
 use rbml;
 use rbml::leb128;

src/librustc_trans/trans/base.rs

@@ -42,7 +42,7 @@ use middle::lang_items::{LangItem, ExchangeMallocFnLangItem, StartFnLangItem};
 use middle::weak_lang_items;
 use middle::pat_util::simple_name;
 use middle::subst::Substs;
-use middle::ty::{self, Ty, HasTypeFlags};
+use middle::ty::{self, Ty, TypeFoldable};
 use rustc::dep_graph::DepNode;
 use rustc::front::map as hir_map;
 use rustc::util::common::time;

src/librustc_trans/trans/callee.rs

@@ -50,7 +50,7 @@ use trans::meth;
 use trans::monomorphize;
 use trans::type_::Type;
 use trans::type_of;
-use middle::ty::{self, Ty, HasTypeFlags, RegionEscape};
+use middle::ty::{self, Ty, TypeFoldable};
 use middle::ty::MethodCall;
 use rustc_front::hir;
 

src/librustc_trans/trans/common.rs

@@ -37,7 +37,7 @@ use trans::monomorphize;
 use trans::type_::Type;
 use trans::type_of;
 use middle::traits;
-use middle::ty::{self, HasTypeFlags, Ty};
+use middle::ty::{self, Ty};
 use middle::ty::fold::{TypeFolder, TypeFoldable};
 use rustc_front::hir;
 use rustc::mir::repr::Mir;

src/librustc_trans/trans/intrinsic.rs

@@ -35,7 +35,7 @@ use trans::glue;
 use trans::type_of;
 use trans::machine;
 use trans::type_::Type;
-use middle::ty::{self, Ty, HasTypeFlags};
+use middle::ty::{self, Ty, TypeFoldable};
 use middle::subst::Substs;
 use rustc::dep_graph::DepNode;
 use rustc_front::hir;

src/librustc_trans/trans/meth.rs

@@ -34,7 +34,7 @@ use trans::machine;
 use trans::monomorphize;
 use trans::type_::Type;
 use trans::type_of::*;
-use middle::ty::{self, Ty, HasTypeFlags};
+use middle::ty::{self, Ty, TypeFoldable};
 use middle::ty::MethodCall;
 
 use syntax::ast;

src/librustc_trans/trans/mir/constant.rs

@@ -11,7 +11,7 @@
 use back::abi;
 use llvm::ValueRef;
 use middle::subst::Substs;
-use middle::ty::{Ty, HasTypeFlags};
+use middle::ty::{Ty, TypeFoldable};
 use rustc::middle::const_eval::ConstVal;
 use rustc::mir::repr as mir;
 use trans::common::{self, Block, C_bool, C_bytes, C_floating_f64, C_integral, C_str_slice};

src/librustc_trans/trans/mir/did.rs

@@ -12,7 +12,7 @@
 
 use syntax::codemap::DUMMY_SP;
 use rustc::front::map;
-use rustc::middle::ty::{self, Ty, HasTypeFlags};
+use rustc::middle::ty::{self, Ty, TypeFoldable};
 use rustc::middle::subst::Substs;
 use rustc::middle::const_eval;
 use rustc::middle::def_id::DefId;

src/librustc_trans/trans/mir/lvalue.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use llvm::ValueRef;
-use rustc::middle::ty::{self, Ty, HasTypeFlags};
+use rustc::middle::ty::{self, Ty, TypeFoldable};
 use rustc::mir::repr as mir;
 use rustc::mir::tcx::LvalueTy;
 use trans::adt;

src/librustc_trans/trans/mir/operand.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use llvm::ValueRef;
-use rustc::middle::ty::{Ty, HasTypeFlags};
+use rustc::middle::ty::{Ty, TypeFoldable};
 use rustc::mir::repr as mir;
 use trans::base;
 use trans::common::{self, Block};

src/librustc_trans/trans/monomorphize.rs

@@ -23,7 +23,7 @@ use trans::base;
 use trans::common::*;
 use trans::declare;
 use trans::foreign;
-use middle::ty::{self, HasTypeFlags, Ty};
+use middle::ty::{self, Ty};
 use rustc::front::map as hir_map;
 
 use rustc_front::hir;

src/librustc_trans/trans/type_of.rs

@@ -17,7 +17,7 @@ use trans::adt;
 use trans::common::*;
 use trans::foreign;
 use trans::machine;
-use middle::ty::{self, RegionEscape, Ty};
+use middle::ty::{self, Ty, TypeFoldable};
 
 use trans::type_::Type;
 

src/librustc_typeck/astconv.rs

@@ -57,7 +57,7 @@ use middle::resolve_lifetime as rl;
 use middle::privacy::{AllPublic, LastMod};
 use middle::subst::{FnSpace, TypeSpace, SelfSpace, Subst, Substs, ParamSpace};
 use middle::traits;
-use middle::ty::{self, Ty, ToPredicate, HasTypeFlags};
+use middle::ty::{self, Ty, ToPredicate, TypeFoldable};
 use middle::ty::wf::object_region_bounds;
 use require_c_abi_if_variadic;
 use rscope::{self, UnelidableRscope, RegionScope, ElidableRscope,

src/librustc_typeck/check/_match.rs

@@ -14,7 +14,7 @@ use middle::pat_util::{PatIdMap, pat_id_map, pat_is_binding};
 use middle::pat_util::pat_is_resolved_const;
 use middle::privacy::{AllPublic, LastMod};
 use middle::subst::Substs;
-use middle::ty::{self, Ty, HasTypeFlags, LvaluePreference};
+use middle::ty::{self, Ty, TypeFoldable, LvaluePreference};
 use check::{check_expr, check_expr_has_type, check_expr_with_expectation};
 use check::{check_expr_coercable_to_type, demand, FnCtxt, Expectation};
 use check::{check_expr_with_lvalue_pref};

src/librustc_typeck/check/cast.rs

@@ -45,7 +45,7 @@ use super::structurally_resolved_type;
 
 use lint;
 use middle::def_id::DefId;
-use middle::ty::{self, Ty, HasTypeFlags};
+use middle::ty::{self, Ty, TypeFoldable};
 use middle::ty::cast::{CastKind, CastTy};
 use syntax::codemap::Span;
 use rustc_front::hir;

src/librustc_typeck/check/method/mod.rs

@@ -17,7 +17,7 @@ use middle::def_id::DefId;
 use middle::privacy::{AllPublic, DependsOn, LastPrivate, LastMod};
 use middle::subst;
 use middle::traits;
-use middle::ty::{self, RegionEscape, ToPredicate, ToPolyTraitRef, TraitRef};
+use middle::ty::{self, ToPredicate, ToPolyTraitRef, TraitRef, TypeFoldable};
 use middle::ty::adjustment::{AdjustDerefRef, AutoDerefRef, AutoPtr};
 use middle::infer;
 

src/librustc_typeck/check/method/probe.rs

@@ -19,9 +19,7 @@ use middle::def_id::DefId;
 use middle::subst;
 use middle::subst::Subst;
 use middle::traits;
-use middle::ty::{self, NoPreference, RegionEscape, Ty, ToPolyTraitRef, TraitRef};
-use middle::ty::HasTypeFlags;
-use middle::ty::fold::TypeFoldable;
+use middle::ty::{self, NoPreference, Ty, ToPolyTraitRef, TraitRef, TypeFoldable};
 use middle::infer;
 use middle::infer::{InferCtxt, TypeOrigin};
 use syntax::ast;

src/librustc_typeck/check/method/suggest.rs

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

src/librustc_typeck/check/mod.rs

@@ -97,7 +97,7 @@ use middle::traits::{self, report_fulfillment_errors};
 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};
+use middle::ty::{self, ToPolyTraitRef, Ty};
 use middle::ty::{MethodCall, MethodCallee};
 use middle::ty::adjustment;
 use middle::ty::error::TypeError;

src/librustc_typeck/check/op.rs

@@ -19,7 +19,7 @@ use super::{
     FnCtxt,
 };
 use middle::def_id::DefId;
-use middle::ty::{Ty, HasTypeFlags, PreferMutLvalue};
+use middle::ty::{Ty, TypeFoldable, PreferMutLvalue};
 use syntax::ast;
 use syntax::parse::token;
 use rustc_front::hir;

src/librustc_typeck/check/regionck.rs

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

src/librustc_typeck/check/writeback.rs

@@ -17,7 +17,7 @@ use astconv::AstConv;
 use check::FnCtxt;
 use middle::def_id::DefId;
 use middle::pat_util;
-use middle::ty::{self, Ty, MethodCall, MethodCallee, HasTypeFlags};
+use middle::ty::{self, Ty, MethodCall, MethodCallee};
 use middle::ty::adjustment;
 use middle::ty::fold::{TypeFolder,TypeFoldable};
 use middle::infer;

src/librustc_typeck/coherence/mod.rs

@@ -20,8 +20,7 @@ use middle::def_id::DefId;
 use middle::lang_items::UnsizeTraitLangItem;
 use middle::subst::{self, Subst};
 use middle::traits;
-use middle::ty;
-use middle::ty::RegionEscape;
+use middle::ty::{self, TypeFoldable};
 use middle::ty::{ImplOrTraitItemId, ConstTraitItemId};
 use middle::ty::{MethodTraitItemId, TypeTraitItemId, ParameterEnvironment};
 use middle::ty::{Ty, TyBool, TyChar, TyEnum, TyError};

src/librustc_typeck/lib.rs

@@ -103,7 +103,7 @@ use front::map as hir_map;
 use middle::def;
 use middle::infer::{self, TypeOrigin};
 use middle::subst;
-use middle::ty::{self, Ty, HasTypeFlags};
+use middle::ty::{self, Ty, TypeFoldable};
 use session::config;
 use util::common::time;
 use rustc_front::hir;