Make base members use TypeId rather than ItemId

9 files changed, 15 insertions, 15 deletions

diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index acc87692..95ec8f9d 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -1543,7 +1543,7 @@ impl CodeGenerator for CompInfo {
                     continue;
                 }
 
-                let base_ty = ctx.resolve_type(base.ty.as_type_id_unchecked());
+                let base_ty = ctx.resolve_type(base.ty);
                 // NB: We won't include unsized types in our base chain because they
                 // would contribute to our size given the dummy field we insert for
                 // unsized types.
diff --git a/src/ir/analysis/derive_default.rs b/src/ir/analysis/derive_default.rs
index 13ab29a4..f8f02df7 100644
--- a/src/ir/analysis/derive_default.rs
+++ b/src/ir/analysis/derive_default.rs
@@ -290,7 +290,7 @@ impl<'ctx> MonotoneFramework for CannotDeriveDefault<'ctx> {
 
                 let bases_cannot_derive =
                     info.base_members().iter().any(|base| {
-                        !self.ctx.whitelisted_items().contains(&base.ty) ||
+                        !self.ctx.whitelisted_items().contains(&base.ty.into()) ||
                             self.is_not_default(base.ty)
                     });
                 if bases_cannot_derive {
diff --git a/src/ir/analysis/derive_hash.rs b/src/ir/analysis/derive_hash.rs
index 0d4392b3..8e23f73f 100644
--- a/src/ir/analysis/derive_hash.rs
+++ b/src/ir/analysis/derive_hash.rs
@@ -264,8 +264,8 @@ impl<'ctx> MonotoneFramework for CannotDeriveHash<'ctx> {
 
                 let bases_cannot_derive =
                     info.base_members().iter().any(|base| {
-                        !self.ctx.whitelisted_items().contains(&base.ty) ||
-                            self.cannot_derive_hash.contains(&base.ty)
+                        !self.ctx.whitelisted_items().contains(&base.ty.into()) ||
+                            self.cannot_derive_hash.contains(&base.ty.into())
                     });
                 if bases_cannot_derive {
                     trace!(
diff --git a/src/ir/analysis/derive_partial_eq_or_partial_ord.rs b/src/ir/analysis/derive_partial_eq_or_partial_ord.rs
index f5cdc566..ccdbbb69 100644
--- a/src/ir/analysis/derive_partial_eq_or_partial_ord.rs
+++ b/src/ir/analysis/derive_partial_eq_or_partial_ord.rs
@@ -280,8 +280,8 @@ impl<'ctx> MonotoneFramework for CannotDerivePartialEqOrPartialOrd<'ctx> {
 
                 let bases_cannot_derive =
                     info.base_members().iter().any(|base| {
-                        !self.ctx.whitelisted_items().contains(&base.ty) ||
-                            self.cannot_derive_partialeq_or_partialord.contains(&base.ty)
+                        !self.ctx.whitelisted_items().contains(&base.ty.into()) ||
+                            self.cannot_derive_partialeq_or_partialord.contains(&base.ty.into())
                     });
                 if bases_cannot_derive {
                     trace!(
diff --git a/src/ir/analysis/has_destructor.rs b/src/ir/analysis/has_destructor.rs
index 9966b7f2..729910be 100644
--- a/src/ir/analysis/has_destructor.rs
+++ b/src/ir/analysis/has_destructor.rs
@@ -121,7 +121,7 @@ impl<'ctx> MonotoneFramework for HasDestructorAnalysis<'ctx> {
                     CompKind::Struct => {
                         let base_or_field_destructor =
                             info.base_members().iter().any(|base| {
-                                self.have_destructor.contains(&base.ty)
+                                self.have_destructor.contains(&base.ty.into())
                             }) ||
                             info.fields().iter().any(|field| {
                                 match *field {
diff --git a/src/ir/analysis/has_float.rs b/src/ir/analysis/has_float.rs
index 8b86f48d..05dd3b4a 100644
--- a/src/ir/analysis/has_float.rs
+++ b/src/ir/analysis/has_float.rs
@@ -166,7 +166,7 @@ impl<'ctx> MonotoneFramework for HasFloat<'ctx> {
             TypeKind::Comp(ref info) => {
                 let bases_have = info.base_members()
                     .iter()
-                    .any(|base| self.has_float.contains(&base.ty));
+                    .any(|base| self.has_float.contains(&base.ty.into()));
                 if bases_have {
                     trace!("    bases have float, so we also have");
                     return self.insert(id);
diff --git a/src/ir/analysis/has_type_param_in_array.rs b/src/ir/analysis/has_type_param_in_array.rs
index 30e2f48b..238ffe60 100644
--- a/src/ir/analysis/has_type_param_in_array.rs
+++ b/src/ir/analysis/has_type_param_in_array.rs
@@ -183,7 +183,7 @@ impl<'ctx> MonotoneFramework for HasTypeParameterInArray<'ctx> {
 
             TypeKind::Comp(ref info) => {
                 let bases_have = info.base_members().iter().any(|base| {
-                    self.has_type_parameter_in_array.contains(&base.ty)
+                    self.has_type_parameter_in_array.contains(&base.ty.into())
                 });
                 if bases_have {
                     trace!("    bases have array, so we also have");
diff --git a/src/ir/analysis/has_vtable.rs b/src/ir/analysis/has_vtable.rs
index a0615daf..92d6a38f 100644
--- a/src/ir/analysis/has_vtable.rs
+++ b/src/ir/analysis/has_vtable.rs
@@ -111,7 +111,7 @@ impl<'ctx> MonotoneFramework for HasVtableAnalysis<'ctx> {
                     return self.insert(id);
                 }
                 let bases_has_vtable = info.base_members().iter().any(|base| {
-                    self.have_vtable.contains(&base.ty)
+                    self.have_vtable.contains(&base.ty.into())
                 });
                 if bases_has_vtable {
                     self.insert(id)
diff --git a/src/ir/comp.rs b/src/ir/comp.rs
index 5cbcaf09..d0641a2b 100644
--- a/src/ir/comp.rs
+++ b/src/ir/comp.rs
@@ -794,7 +794,7 @@ pub enum BaseKind {
 #[derive(Clone, Debug)]
 pub struct Base {
     /// The type of this base class.
-    pub ty: ItemId,
+    pub ty: TypeId,
     /// The kind of inheritance we're doing.
     pub kind: BaseKind,
     /// Name of the field in which this base should be stored.
@@ -914,7 +914,7 @@ impl CompInfo {
     pub fn is_unsized<Id: Into<ItemId>>(&self, ctx: &BindgenContext, id: Id) -> bool {
         !ctx.lookup_item_id_has_vtable(id.into()) && self.fields().is_empty() &&
             self.base_members.iter().all(|base| {
-                ctx.resolve_type(base.ty.as_type_id_unchecked()).canonical_type(ctx).is_unsized(
+                ctx.resolve_type(base.ty).canonical_type(ctx).is_unsized(
                     ctx,
                     base.ty,
                 )
@@ -1193,7 +1193,7 @@ impl CompInfo {
                     let type_id =
                         Item::from_ty_or_ref(cur.cur_type(), cur, None, ctx);
                     ci.base_members.push(Base {
-                        ty: type_id,
+                        ty: type_id.as_type_id_unchecked(),
                         kind: kind,
                         field_name: field_name,
                     });
@@ -1362,7 +1362,7 @@ impl CompInfo {
             // Unfortunately, given the way we implement --match-pat, and also
             // that you can inherit from templated types, we need to handle
             // other cases here too.
-            ctx.resolve_type(base.ty.as_type_id_unchecked())
+            ctx.resolve_type(base.ty)
                 .canonical_type(ctx)
                 .as_comp()
                 .map_or(false, |_| base.ty.has_vtable(ctx))
@@ -1513,7 +1513,7 @@ impl Trace for CompInfo {
         }
 
         for base in self.base_members() {
-            tracer.visit_kind(base.ty, EdgeKind::BaseMember);
+            tracer.visit_kind(base.ty.into(), EdgeKind::BaseMember);
         }
 
         self.fields.trace(context, tracer, &());