rustc: remove id's from Ty's in favor of pointer identity.

Author: eddyb

src/librustc/middle/trans/context.rs

@@ -139,7 +139,7 @@ pub struct LocalCrateContext<'tcx> {
     /// Holds the LLVM values for closure IDs.
     unboxed_closure_vals: RefCell<HashMap<MonoId<'tcx>, ValueRef>>,
 
-    dbg_cx: Option<debuginfo::CrateDebugContext>,
+    dbg_cx: Option<debuginfo::CrateDebugContext<'tcx>>,
 
     eh_personality: RefCell<Option<ValueRef>>,
 
@@ -685,7 +685,7 @@ impl<'b, 'tcx> CrateContext<'b, 'tcx> {
         &self.local.unboxed_closure_vals
     }
 
-    pub fn dbg_cx<'a>(&'a self) -> &'a Option<debuginfo::CrateDebugContext> {
+    pub fn dbg_cx<'a>(&'a self) -> &'a Option<debuginfo::CrateDebugContext<'tcx>> {
         &self.local.dbg_cx
     }
 

src/librustc/middle/trans/debuginfo.rs

@@ -176,11 +176,11 @@ debuginfo, more than one `Ty` instance may map to the same debuginfo type
 metadata, that is, some struct `Struct<'a>` may have N instantiations with
 different concrete substitutions for `'a`, and thus there will be N `Ty`
 instances for the type `Struct<'a>` even though it is not generic otherwise.
-Unfortunately this means that we cannot use `ty::type_id()` as cheap identifier
+Unfortunately this means that we cannot use `&TyS` as cheap identifier
 for type metadata---we have done this in the past, but it led to unnecessary
 metadata duplication in the best case and LLVM assertions in the worst. However,
 the unique type ID as described above *can* be used as identifier. Since it is
-comparatively expensive to construct, though, `ty::type_id()` is still used
+comparatively expensive to construct, though, `&TyS` is still used
 additionally as an optimization for cases where the exact same type has been
 seen before (which is most of the time). */
 
@@ -254,20 +254,20 @@ struct UniqueTypeId(ast::Name);
 // created so far. The metadata nodes are indexed by UniqueTypeId, and, for
 // faster lookup, also by Ty. The TypeMap is responsible for creating
 // UniqueTypeIds.
-struct TypeMap {
+struct TypeMap<'tcx> {
     // The UniqueTypeIds created so far
     unique_id_interner: Interner<Rc<String>>,
     // A map from UniqueTypeId to debuginfo metadata for that type. This is a 1:1 mapping.
     unique_id_to_metadata: HashMap<UniqueTypeId, DIType>,
-    // A map from ty::type_id() to debuginfo metadata. This is a N:1 mapping.
-    type_to_metadata: HashMap<uint, DIType>,
-    // A map from ty::type_id() to UniqueTypeId. This is a N:1 mapping.
-    type_to_unique_id: HashMap<uint, UniqueTypeId>
+    // A map from types to debuginfo metadata. This is a N:1 mapping.
+    type_to_metadata: HashMap<Ty<'tcx>, DIType>,
+    // A map from types to UniqueTypeId. This is a N:1 mapping.
+    type_to_unique_id: HashMap<Ty<'tcx>, UniqueTypeId>
 }
 
-impl TypeMap {
+impl<'tcx> TypeMap<'tcx> {
 
-    fn new() -> TypeMap {
+    fn new() -> TypeMap<'tcx> {
         TypeMap {
             unique_id_interner: Interner::new(),
             type_to_metadata: HashMap::new(),
@@ -278,11 +278,11 @@ impl TypeMap {
 
     // Adds a Ty to metadata mapping to the TypeMap. The method will fail if
     // the mapping already exists.
-    fn register_type_with_metadata<'a, 'tcx>(&mut self,
-                                             cx: &CrateContext<'a, 'tcx>,
-                                             type_: Ty<'tcx>,
-                                             metadata: DIType) {
-        if !self.type_to_metadata.insert(ty::type_id(type_), metadata) {
+    fn register_type_with_metadata<'a>(&mut self,
+                                       cx: &CrateContext<'a, 'tcx>,
+                                       type_: Ty<'tcx>,
+                                       metadata: DIType) {
+        if !self.type_to_metadata.insert(type_, metadata) {
             cx.sess().bug(format!("Type metadata for Ty '{}' is already in the TypeMap!",
                                    ppaux::ty_to_string(cx.tcx(), type_)).as_slice());
         }
@@ -301,8 +301,8 @@ impl TypeMap {
         }
     }
 
-    fn find_metadata_for_type(&self, type_: Ty) -> Option<DIType> {
-        self.type_to_metadata.find_copy(&ty::type_id(type_))
+    fn find_metadata_for_type(&self, type_: Ty<'tcx>) -> Option<DIType> {
+        self.type_to_metadata.find_copy(&type_)
     }
 
     fn find_metadata_for_unique_id(&self, unique_type_id: UniqueTypeId) -> Option<DIType> {
@@ -319,8 +319,8 @@ impl TypeMap {
     // Get the UniqueTypeId for the given type. If the UniqueTypeId for the given
     // type has been requested before, this is just a table lookup. Otherwise an
     // ID will be generated and stored for later lookup.
-    fn get_unique_type_id_of_type<'a, 'tcx>(&mut self, cx: &CrateContext<'a, 'tcx>,
-                                            type_: Ty<'tcx>) -> UniqueTypeId {
+    fn get_unique_type_id_of_type<'a>(&mut self, cx: &CrateContext<'a, 'tcx>,
+                                      type_: Ty<'tcx>) -> UniqueTypeId {
 
         // basic type           -> {:name of the type:}
         // tuple                -> {tuple_(:param-uid:)*}
@@ -343,7 +343,7 @@ impl TypeMap {
         // unique vec box (~[]) -> {HEAP_VEC_BOX<:pointee-uid:>}
         // gc box               -> {GC_BOX<:pointee-uid:>}
 
-        match self.type_to_unique_id.find_copy(&ty::type_id(type_)) {
+        match self.type_to_unique_id.find_copy(&type_) {
             Some(unique_type_id) => return unique_type_id,
             None => { /* generate one */}
         };
@@ -487,11 +487,11 @@ impl TypeMap {
         unique_type_id.shrink_to_fit();
 
         let key = self.unique_id_interner.intern(Rc::new(unique_type_id));
-        self.type_to_unique_id.insert(ty::type_id(type_), UniqueTypeId(key));
+        self.type_to_unique_id.insert(type_, UniqueTypeId(key));
 
         return UniqueTypeId(key);
 
-        fn from_def_id_and_substs<'a, 'tcx>(type_map: &mut TypeMap,
+        fn from_def_id_and_substs<'a, 'tcx>(type_map: &mut TypeMap<'tcx>,
                                             cx: &CrateContext<'a, 'tcx>,
                                             def_id: ast::DefId,
                                             substs: &subst::Substs<'tcx>,
@@ -542,10 +542,10 @@ impl TypeMap {
         }
     }
 
-    fn get_unique_type_id_of_closure_type<'a, 'tcx>(&mut self,
-                                                    cx: &CrateContext<'a, 'tcx>,
-                                                    closure_ty: ty::ClosureTy<'tcx>,
-                                                    unique_type_id: &mut String) {
+    fn get_unique_type_id_of_closure_type<'a>(&mut self,
+                                              cx: &CrateContext<'a, 'tcx>,
+                                              closure_ty: ty::ClosureTy<'tcx>,
+                                              unique_type_id: &mut String) {
         let ty::ClosureTy { fn_style,
                             onceness,
                             store,
@@ -612,11 +612,11 @@ impl TypeMap {
     // Get the UniqueTypeId for an enum variant. Enum variants are not really
     // types of their own, so they need special handling. We still need a
     // UniqueTypeId for them, since to debuginfo they *are* real types.
-    fn get_unique_type_id_of_enum_variant<'a, 'tcx>(&mut self,
-                                                    cx: &CrateContext<'a, 'tcx>,
-                                                    enum_type: Ty<'tcx>,
-                                                    variant_name: &str)
-                                                    -> UniqueTypeId {
+    fn get_unique_type_id_of_enum_variant<'a>(&mut self,
+                                              cx: &CrateContext<'a, 'tcx>,
+                                              enum_type: Ty<'tcx>,
+                                              variant_name: &str)
+                                              -> UniqueTypeId {
         let enum_type_id = self.get_unique_type_id_of_type(cx, enum_type);
         let enum_variant_type_id = format!("{}::{}",
                                            self.get_unique_type_id_as_string(enum_type_id)
@@ -642,23 +642,23 @@ macro_rules! return_if_metadata_created_in_meantime(
 
 
 /// A context object for maintaining all state needed by the debuginfo module.
-pub struct CrateDebugContext {
+pub struct CrateDebugContext<'tcx> {
     llcontext: ContextRef,
     builder: DIBuilderRef,
     current_debug_location: Cell<DebugLocation>,
     created_files: RefCell<HashMap<String, DIFile>>,
     created_enum_disr_types: RefCell<HashMap<ast::DefId, DIType>>,
 
-    type_map: RefCell<TypeMap>,
+    type_map: RefCell<TypeMap<'tcx>>,
     namespace_map: RefCell<HashMap<Vec<ast::Name>, Rc<NamespaceTreeNode>>>,
 
     // This collection is used to assert that composite types (structs, enums,
     // ...) have their members only set once:
     composite_types_completed: RefCell<HashSet<DIType>>,
 }
 
-impl CrateDebugContext {
-    pub fn new(llmod: ModuleRef) -> CrateDebugContext {
+impl<'tcx> CrateDebugContext<'tcx> {
+    pub fn new(llmod: ModuleRef) -> CrateDebugContext<'tcx> {
         debug!("CrateDebugContext::new");
         let builder = unsafe { llvm::LLVMDIBuilderCreate(llmod) };
         // DIBuilder inherits context from the module, so we'd better use the same one
@@ -3107,9 +3107,9 @@ fn bytes_to_bits(bytes: u64) -> u64 {
 }
 
 #[inline]
-fn debug_context<'a>(cx: &'a CrateContext) -> &'a CrateDebugContext {
-    let debug_context: &'a CrateDebugContext = cx.dbg_cx().as_ref().unwrap();
-    debug_context
+fn debug_context<'a, 'tcx>(cx: &'a CrateContext<'a, 'tcx>) -> &'a CrateDebugContext<'tcx> {
+    let dbg_cx: &'a CrateDebugContext<'tcx> = cx.dbg_cx().as_ref().unwrap();
+    dbg_cx
 }
 
 #[inline]

src/librustc/middle/ty.rs

@@ -32,7 +32,7 @@ use middle;
 use util::ppaux::{note_and_explain_region, bound_region_ptr_to_string};
 use util::ppaux::{trait_store_to_string, ty_to_string};
 use util::ppaux::{Repr, UserString};
-use util::common::{indenter, memoized, memoized_with_key};
+use util::common::{indenter, memoized};
 use util::nodemap::{NodeMap, NodeSet, DefIdMap, DefIdSet, FnvHashMap};
 
 use std::cell::{Cell, RefCell};
@@ -437,7 +437,6 @@ pub struct ctxt<'tcx> {
     // FIXME(eddyb) use a FnvHashSet<InternedTy<'tcx>> when equivalent keys can
     // queried from a HashSet.
     interner: RefCell<FnvHashMap<InternedTy<'tcx>, Ty<'tcx>>>,
-    pub next_id: Cell<uint>,
     pub sess: Session,
     pub def_map: resolve::DefMap,
 
@@ -481,7 +480,7 @@ pub struct ctxt<'tcx> {
     pub rcache: creader_cache<'tcx>,
     pub short_names_cache: RefCell<HashMap<Ty<'tcx>, String>>,
     pub needs_unwind_cleanup_cache: RefCell<HashMap<Ty<'tcx>, bool>>,
-    pub tc_cache: RefCell<HashMap<uint, TypeContents>>,
+    pub tc_cache: RefCell<HashMap<Ty<'tcx>, TypeContents>>,
     pub ast_ty_to_ty_cache: RefCell<NodeMap<ast_ty_to_ty_cache_entry<'tcx>>>,
     pub enum_var_cache: RefCell<DefIdMap<Rc<Vec<Rc<VariantInfo<'tcx>>>>>>,
     pub ty_param_defs: RefCell<NodeMap<TypeParameterDef<'tcx>>>,
@@ -600,7 +599,6 @@ bitflags! {
 #[deriving(Show)]
 pub struct TyS<'tcx> {
     pub sty: sty<'tcx>,
-    pub id: uint,
     pub flags: TypeFlags,
 }
 
@@ -665,7 +663,6 @@ pub fn type_has_ty_infer(ty: Ty) -> bool {
 pub fn type_needs_infer(ty: Ty) -> bool {
     tbox_has_flag(ty, HAS_TY_INFER | HAS_RE_INFER)
 }
-pub fn type_id(ty: Ty) -> uint { ty.id }
 
 
 #[deriving(Clone, PartialEq, Eq, Hash, Show)]
@@ -944,38 +941,34 @@ mod primitives {
     use syntax::ast;
 
     macro_rules! def_prim_ty(
-        ($name:ident, $sty:expr, $id:expr) => (
+        ($name:ident, $sty:expr) => (
             pub static $name: TyS<'static> = TyS {
                 sty: $sty,
-                id: $id,
                 flags: super::NO_TYPE_FLAGS,
             };
         )
     )
 
-    def_prim_ty!(TY_NIL,    super::ty_nil,                  0)
-    def_prim_ty!(TY_BOOL,   super::ty_bool,                 1)
-    def_prim_ty!(TY_CHAR,   super::ty_char,                 2)
-    def_prim_ty!(TY_INT,    super::ty_int(ast::TyI),        3)
-    def_prim_ty!(TY_I8,     super::ty_int(ast::TyI8),       4)
-    def_prim_ty!(TY_I16,    super::ty_int(ast::TyI16),      5)
-    def_prim_ty!(TY_I32,    super::ty_int(ast::TyI32),      6)
-    def_prim_ty!(TY_I64,    super::ty_int(ast::TyI64),      7)
-    def_prim_ty!(TY_UINT,   super::ty_uint(ast::TyU),       8)
-    def_prim_ty!(TY_U8,     super::ty_uint(ast::TyU8),      9)
-    def_prim_ty!(TY_U16,    super::ty_uint(ast::TyU16),     10)
-    def_prim_ty!(TY_U32,    super::ty_uint(ast::TyU32),     11)
-    def_prim_ty!(TY_U64,    super::ty_uint(ast::TyU64),     12)
-    def_prim_ty!(TY_F32,    super::ty_float(ast::TyF32),    14)
-    def_prim_ty!(TY_F64,    super::ty_float(ast::TyF64),    15)
+    def_prim_ty!(TY_NIL,    super::ty_nil)
+    def_prim_ty!(TY_BOOL,   super::ty_bool)
+    def_prim_ty!(TY_CHAR,   super::ty_char)
+    def_prim_ty!(TY_INT,    super::ty_int(ast::TyI))
+    def_prim_ty!(TY_I8,     super::ty_int(ast::TyI8))
+    def_prim_ty!(TY_I16,    super::ty_int(ast::TyI16))
+    def_prim_ty!(TY_I32,    super::ty_int(ast::TyI32))
+    def_prim_ty!(TY_I64,    super::ty_int(ast::TyI64))
+    def_prim_ty!(TY_UINT,   super::ty_uint(ast::TyU))
+    def_prim_ty!(TY_U8,     super::ty_uint(ast::TyU8))
+    def_prim_ty!(TY_U16,    super::ty_uint(ast::TyU16))
+    def_prim_ty!(TY_U32,    super::ty_uint(ast::TyU32))
+    def_prim_ty!(TY_U64,    super::ty_uint(ast::TyU64))
+    def_prim_ty!(TY_F32,    super::ty_float(ast::TyF32))
+    def_prim_ty!(TY_F64,    super::ty_float(ast::TyF64))
 
     pub static TY_ERR: TyS<'static> = TyS {
         sty: super::ty_err,
-        id: 17,
         flags: super::HAS_TY_ERR,
     };
-
-    pub const LAST_PRIMITIVE_ID: uint = 18;
 }
 
 // NB: If you change this, you'll probably want to change the corresponding
@@ -1591,7 +1584,6 @@ pub fn mk_ctxt<'tcx>(s: Session,
         named_region_map: named_region_map,
         item_variance_map: RefCell::new(DefIdMap::new()),
         variance_computed: Cell::new(false),
-        next_id: Cell::new(primitives::LAST_PRIMITIVE_ID),
         sess: s,
         def_map: dm,
         region_maps: region_maps,
@@ -1755,14 +1747,11 @@ pub fn mk_t<'tcx>(cx: &ctxt<'tcx>, st: sty<'tcx>) -> Ty<'tcx> {
 
     let ty = cx.type_arena.alloc(TyS {
         sty: st,
-        id: cx.next_id.get(),
         flags: flags,
     });
 
     cx.interner.borrow_mut().insert(InternedTy { ty: ty }, ty);
 
-    cx.next_id.set(cx.next_id.get() + 1);
-
     ty
 }
 
@@ -2469,13 +2458,13 @@ pub fn type_interior_is_unsafe<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> bool {
 }
 
 pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents {
-    return memoized_with_key(&cx.tc_cache, ty, |ty| {
+    return memoized(&cx.tc_cache, ty, |ty| {
         tc_ty(cx, ty, &mut HashMap::new())
-    }, |&ty| type_id(ty));
+    });
 
     fn tc_ty<'tcx>(cx: &ctxt<'tcx>,
                    ty: Ty<'tcx>,
-                   cache: &mut HashMap<uint, TypeContents>) -> TypeContents
+                   cache: &mut HashMap<Ty<'tcx>, TypeContents>) -> TypeContents
     {
         // Subtle: Note that we are *not* using cx.tc_cache here but rather a
         // private cache for this walk.  This is needed in the case of cyclic
@@ -2498,16 +2487,15 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents {
         // which is incorrect.  This value was computed based on the crutch
         // value for the type contents of list.  The correct value is
         // TC::OwnsOwned.  This manifested as issue #4821.
-        let ty_id = type_id(ty);
-        match cache.find(&ty_id) {
+        match cache.find(&ty) {
             Some(tc) => { return *tc; }
             None => {}
         }
-        match cx.tc_cache.borrow().find(&ty_id) {    // Must check both caches!
+        match cx.tc_cache.borrow().find(&ty) {    // Must check both caches!
             Some(tc) => { return *tc; }
             None => {}
         }
-        cache.insert(ty_id, TC::None);
+        cache.insert(ty, TC::None);
 
         let result = match ty.sty {
             // uint and int are ffi-unsafe
@@ -2677,13 +2665,13 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents {
             }
         };
 
-        cache.insert(ty_id, result);
-        return result;
+        cache.insert(ty, result);
+        result
     }
 
     fn tc_mt<'tcx>(cx: &ctxt<'tcx>,
                    mt: mt<'tcx>,
-                   cache: &mut HashMap<uint, TypeContents>) -> TypeContents
+                   cache: &mut HashMap<Ty<'tcx>, TypeContents>) -> TypeContents
     {
         let mc = TC::ReachesMutable.when(mt.mutbl == MutMutable);
         mc | tc_ty(cx, mt.ty, cache)
@@ -2992,7 +2980,7 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>)
                 pairs.all(|(&a, &b)| same_type(a, b))
             }
             _ => {
-                type_id(a) == type_id(b)
+                a == b
             }
         }
     }

src/librustc/util/common.rs

@@ -189,17 +189,7 @@ pub fn memoized<T: Clone + Hash<S> + Eq, U: Clone, S, H: Hasher<S>>(
     arg: T,
     f: |T| -> U
 ) -> U {
-    memoized_with_key(cache, arg, f, |arg| arg.clone())
-}
-
-#[inline(always)]
-pub fn memoized_with_key<T, K: Hash<S> + Eq, U: Clone, S, H: Hasher<S>>(
-    cache: &RefCell<HashMap<K, U, H>>,
-    arg: T,
-    f: |T| -> U,
-    k: |&T| -> K
-) -> U {
-    let key = k(&arg);
+    let key = arg.clone();
     let result = cache.borrow().find(&key).map(|result| result.clone());
     match result {
         Some(result) => result,