Strongly type ids

src/codegen/mod.rs

@@ -6,6 +6,7 @@ pub mod struct_layout;
 use self::helpers::attributes;
 use self::struct_layout::StructLayoutTracker;
 
+use ir::analysis::HasVtable;
 use ir::annotations::FieldAccessorKind;
 use ir::comment;
 use ir::comp::{Base, Bitfield, BitfieldUnit, CompInfo, CompKind, Field,
@@ -151,12 +152,12 @@ impl<'a> CodegenResult<'a> {
         self.saw_objc = true;
     }
 
-    fn seen(&self, item: ItemId) -> bool {
-        self.items_seen.contains(&item)
+    fn seen<Id: Into<ItemId>>(&self, item: Id) -> bool {
+        self.items_seen.contains(&item.into())
     }
 
-    fn set_seen(&mut self, item: ItemId) {
-        self.items_seen.insert(item);
+    fn set_seen<Id: Into<ItemId>>(&mut self, item: Id) {
+        self.items_seen.insert(item.into());
     }
 
     fn seen_function(&self, name: &str) -> bool {
@@ -599,7 +600,7 @@ impl CodeGenerator for Type {
                 // If this is a known named type, disallow generating anything
                 // for it too.
                 let spelling = self.name().expect("Unnamed alias?");
-                if utils::type_from_named(ctx, spelling, inner).is_some() {
+                if utils::type_from_named(ctx, spelling).is_some() {
                     return;
                 }
 
@@ -1546,7 +1547,7 @@ impl CodeGenerator for CompInfo {
                 // 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.
-                if base_ty.is_unsized(ctx, &base.ty) {
+                if base_ty.is_unsized(ctx, base.ty) {
                     continue;
                 }
 
@@ -1625,7 +1626,7 @@ impl CodeGenerator for CompInfo {
                     warn!("Opaque type without layout! Expect dragons!");
                 }
             }
-        } else if !is_union && !self.is_unsized(ctx, &item.id()) {
+        } else if !is_union && !self.is_unsized(ctx, item.id().expect_type_id(ctx)) {
             if let Some(padding_field) =
                 layout.and_then(|layout| struct_layout.pad_struct(layout))
             {
@@ -1649,7 +1650,7 @@ impl CodeGenerator for CompInfo {
         //
         // NOTE: This check is conveniently here to avoid the dummy fields we
         // may add for unused template parameters.
-        if self.is_unsized(ctx, &item.id()) {
+        if self.is_unsized(ctx, item.id().expect_type_id(ctx)) {
             let has_address = if is_opaque {
                 // Generate the address field if it's an opaque type and
                 // couldn't determine the layout of the blob.
@@ -1758,9 +1759,8 @@ impl CodeGenerator for CompInfo {
                     // FIXME when [issue #465](https://github.com/rust-lang-nursery/rust-bindgen/issues/465) ready
                     let too_many_base_vtables = self.base_members()
                         .iter()
-                        .filter(|base| ctx.lookup_item_id_has_vtable(&base.ty))
-                        .count() >
-                        1;
+                        .filter(|base| base.ty.has_vtable(ctx))
+                        .count() > 1;
 
                     let should_skip_field_offset_checks = is_opaque ||
                         too_many_base_vtables;
@@ -2728,27 +2728,33 @@ where
     }
 }
 
-impl TryToOpaque for ItemId {
+impl<T> TryToOpaque for T
+where
+    T: Copy + Into<ItemId>
+{
     type Extra = ();
 
     fn try_get_layout(
         &self,
         ctx: &BindgenContext,
         _: &(),
     ) -> error::Result<Layout> {
-        ctx.resolve_item(*self).try_get_layout(ctx, &())
+        ctx.resolve_item((*self).into()).try_get_layout(ctx, &())
     }
 }
 
-impl TryToRustTy for ItemId {
+impl<T> TryToRustTy for T
+where
+    T: Copy + Into<ItemId>
+{
     type Extra = ();
 
     fn try_to_rust_ty(
         &self,
         ctx: &BindgenContext,
         _: &(),
     ) -> error::Result<quote::Tokens> {
-        ctx.resolve_item(*self).try_to_rust_ty(ctx, &())
+        ctx.resolve_item((*self).into()).try_to_rust_ty(ctx, &())
     }
 }
 
@@ -2889,8 +2895,8 @@ impl TryToRustTy for Type {
                 inst.try_to_rust_ty(ctx, item)
             }
             TypeKind::ResolvedTypeRef(inner) => inner.try_to_rust_ty(ctx, &()),
-            TypeKind::TemplateAlias(inner, _) |
-            TypeKind::Alias(inner) => {
+            TypeKind::TemplateAlias(..) |
+            TypeKind::Alias(..) => {
                 let template_params = item.used_template_params(ctx)
                     .unwrap_or(vec![])
                     .into_iter()
@@ -2903,12 +2909,11 @@ impl TryToRustTy for Type {
                 } else if let Some(ty) = utils::type_from_named(
                     ctx,
                     spelling,
-                    inner,
                 )
                 {
                     Ok(ty)
                 } else {
-                    utils::build_templated_path(item, ctx, vec![]) //template_params)
+                    utils::build_path(item, ctx)
                 }
             }
             TypeKind::Comp(ref info) => {
@@ -2919,8 +2924,7 @@ impl TryToRustTy for Type {
                     return self.try_to_opaque(ctx, item);
                 }
 
-                // let template_params = template_params.unwrap_or(vec![]);
-                utils::build_templated_path(item, ctx, vec![])
+                utils::build_path(item, ctx)
             }
             TypeKind::Opaque => self.try_to_opaque(ctx, item),
             TypeKind::BlockPointer => {
@@ -3326,8 +3330,8 @@ pub fn codegen(context: &mut BindgenContext) -> Vec<quote::Tokens> {
 }
 
 mod utils {
-    use super::{ToRustTyOrOpaque, TryToRustTy, error};
-    use ir::context::{BindgenContext, ItemId};
+    use super::{ToRustTyOrOpaque, error};
+    use ir::context::BindgenContext;
     use ir::function::FunctionSig;
     use ir::item::{Item, ItemCanonicalPath};
     use ir::ty::TypeKind;
@@ -3549,28 +3553,16 @@ mod utils {
         result.extend(old_items.into_iter());
     }
 
-    pub fn build_templated_path(
+    pub fn build_path(
         item: &Item,
         ctx: &BindgenContext,
-        template_params: Vec<ItemId>,
     ) -> error::Result<quote::Tokens> {
         let path = item.namespace_aware_canonical_path(ctx);
 
-        let template_params = template_params
-            .iter()
-            .map(|param| param.try_to_rust_ty(ctx, &()))
-            .collect::<error::Result<Vec<_>>>()?;
-
         let mut tokens = quote! {};
         tokens.append_separated(path.into_iter().map(quote::Ident::new), "::");
 
-        if template_params.is_empty() {
-            Ok(tokens)
-        } else {
-            Ok(quote! {
-                #tokens < #( #template_params ),* >
-            })
-        }
+        Ok(tokens)
     }
 
     fn primitive_ty(ctx: &BindgenContext, name: &str) -> quote::Tokens {
@@ -3583,7 +3575,6 @@ mod utils {
     pub fn type_from_named(
         ctx: &BindgenContext,
         name: &str,
-        _inner: ItemId,
     ) -> Option<quote::Tokens> {
         // FIXME: We could use the inner item to check this is really a
         // primitive type but, who the heck overrides these anyway?

src/ir/analysis/derive_copy.rs

@@ -73,7 +73,8 @@ impl<'ctx> CannotDeriveCopy<'ctx> {
         }
     }
 
-    fn insert(&mut self, id: ItemId) -> ConstrainResult {
+    fn insert<Id: Into<ItemId>>(&mut self, id: Id) -> ConstrainResult {
+        let id = id.into();
         trace!("inserting {:?} into the cannot_derive_copy set", id);
 
         let was_not_already_in_set = self.cannot_derive_copy.insert(id);
@@ -89,7 +90,8 @@ impl<'ctx> CannotDeriveCopy<'ctx> {
 
     /// A type is not `Copy` if we've determined it is not copy, or if it is
     /// blacklisted.
-    fn is_not_copy(&self, id: ItemId) -> bool {
+    fn is_not_copy<Id: Into<ItemId>>(&self, id: Id) -> bool {
+        let id = id.into();
         self.cannot_derive_copy.contains(&id) ||
             !self.ctx.whitelisted_items().contains(&id)
     }
@@ -222,7 +224,7 @@ impl<'ctx> MonotoneFramework for CannotDeriveCopy<'ctx> {
                 // NOTE: Take into account that while unions in C and C++ are copied by
                 // default, the may have an explicit destructor in C++, so we can't
                 // defer this check just for the union case.
-                if self.ctx.lookup_item_id_has_destructor(&id) {
+                if self.ctx.lookup_has_destructor(id.expect_type_id(self.ctx)) {
                     trace!("    comp has destructor which cannot derive copy");
                     return self.insert(id);
                 }
@@ -307,7 +309,7 @@ impl<'ctx> MonotoneFramework for CannotDeriveCopy<'ctx> {
                     "The early ty.is_opaque check should have handled this case"
                 );
                 let def_cannot_derive = self.is_not_copy(
-                    template.template_definition(),
+                    template.template_definition()
                 );
                 if def_cannot_derive {
                     trace!(

src/ir/analysis/derive_debug.rs

@@ -74,7 +74,8 @@ impl<'ctx> CannotDeriveDebug<'ctx> {
         }
     }
 
-    fn insert(&mut self, id: ItemId) -> ConstrainResult {
+    fn insert<Id: Into<ItemId>>(&mut self, id: Id) -> ConstrainResult {
+        let id = id.into();
         trace!("inserting {:?} into the cannot_derive_debug set", id);
 
         let was_not_already_in_set = self.cannot_derive_debug.insert(id);
@@ -90,7 +91,8 @@ impl<'ctx> CannotDeriveDebug<'ctx> {
 
     /// A type is not `Debug` if we've determined it is not debug, or if it is
     /// blacklisted.
-    fn is_not_debug(&self, id: ItemId) -> bool {
+    fn is_not_debug<Id: Into<ItemId>>(&self, id: Id) -> bool {
+        let id = id.into();
         self.cannot_derive_debug.contains(&id) ||
             !self.ctx.whitelisted_items().contains(&id)
     }
@@ -325,7 +327,7 @@ impl<'ctx> MonotoneFramework for CannotDeriveDebug<'ctx> {
                     "The early ty.is_opaque check should have handled this case"
                 );
                 let def_cannot_derive = self.is_not_debug(
-                    template.template_definition(),
+                    template.template_definition()
                 );
                 if def_cannot_derive {
                     trace!(

src/ir/analysis/derive_default.rs

@@ -71,7 +71,8 @@ impl<'ctx> CannotDeriveDefault<'ctx> {
         }
     }
 
-    fn insert(&mut self, id: ItemId) -> ConstrainResult {
+    fn insert<Id: Into<ItemId>>(&mut self, id: Id) -> ConstrainResult {
+        let id = id.into();
         trace!("inserting {:?} into the cannot_derive_default set", id);
 
         let was_not_already_in_set = self.cannot_derive_default.insert(id);
@@ -85,7 +86,8 @@ impl<'ctx> CannotDeriveDefault<'ctx> {
         ConstrainResult::Changed
     }
 
-    fn is_not_default(&self, id: ItemId) -> bool {
+    fn is_not_default<Id: Into<ItemId>>(&self, id: Id) -> bool {
+        let id = id.into();
         self.cannot_derive_default.contains(&id) ||
             !self.ctx.whitelisted_items().contains(&id)
     }
@@ -288,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 {
@@ -303,7 +305,7 @@ impl<'ctx> MonotoneFramework for CannotDeriveDefault<'ctx> {
                     info.fields().iter().any(|f| match *f {
                         Field::DataMember(ref data) => {
                             !self.ctx.whitelisted_items().contains(
-                                &data.ty(),
+                                &data.ty().into(),
                             ) ||
                                 self.is_not_default(data.ty())
                         }
@@ -318,7 +320,7 @@ impl<'ctx> MonotoneFramework for CannotDeriveDefault<'ctx> {
 
                             bfu.bitfields().iter().any(|b| {
                                 !self.ctx.whitelisted_items().contains(
-                                    &b.ty(),
+                                    &b.ty().into(),
                                 ) ||
                                     self.is_not_default(b.ty())
                             })

src/ir/analysis/derive_hash.rs

@@ -74,7 +74,8 @@ impl<'ctx> CannotDeriveHash<'ctx> {
         }
     }
 
-    fn insert(&mut self, id: ItemId) -> ConstrainResult {
+    fn insert<Id: Into<ItemId>>(&mut self, id: Id) -> ConstrainResult {
+        let id = id.into();
         trace!("inserting {:?} into the cannot_derive_hash set", id);
 
         let was_not_already_in_set = self.cannot_derive_hash.insert(id);
@@ -178,7 +179,7 @@ impl<'ctx> MonotoneFramework for CannotDeriveHash<'ctx> {
             }
 
             TypeKind::Array(t, len) => {
-                if self.cannot_derive_hash.contains(&t) {
+                if self.cannot_derive_hash.contains(&t.into()) {
                     trace!(
                         "    arrays of T for which we cannot derive Hash \
                             also cannot derive Hash"
@@ -222,7 +223,7 @@ impl<'ctx> MonotoneFramework for CannotDeriveHash<'ctx> {
             TypeKind::ResolvedTypeRef(t) |
             TypeKind::TemplateAlias(t, _) |
             TypeKind::Alias(t) => {
-                if self.cannot_derive_hash.contains(&t) {
+                if self.cannot_derive_hash.contains(&t.into()) {
                     trace!(
                         "    aliases and type refs to T which cannot derive \
                             Hash also cannot derive Hash"
@@ -263,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!(
@@ -278,9 +279,9 @@ impl<'ctx> MonotoneFramework for CannotDeriveHash<'ctx> {
                     info.fields().iter().any(|f| match *f {
                         Field::DataMember(ref data) => {
                             !self.ctx.whitelisted_items().contains(
-                                &data.ty(),
+                                &data.ty().into(),
                             ) ||
-                                self.cannot_derive_hash.contains(&data.ty())
+                                self.cannot_derive_hash.contains(&data.ty().into())
                         }
                         Field::Bitfields(ref bfu) => {
                             if bfu.layout().align > RUST_DERIVE_IN_ARRAY_LIMIT {
@@ -293,9 +294,9 @@ impl<'ctx> MonotoneFramework for CannotDeriveHash<'ctx> {
 
                             bfu.bitfields().iter().any(|b| {
                                 !self.ctx.whitelisted_items().contains(
-                                    &b.ty(),
+                                    &b.ty().into(),
                                 ) ||
-                                    self.cannot_derive_hash.contains(&b.ty())
+                                    self.cannot_derive_hash.contains(&b.ty().into())
                             })
                         }
                     });
@@ -311,7 +312,7 @@ impl<'ctx> MonotoneFramework for CannotDeriveHash<'ctx> {
             TypeKind::TemplateInstantiation(ref template) => {
                 let args_cannot_derive =
                     template.template_arguments().iter().any(|arg| {
-                        self.cannot_derive_hash.contains(&arg)
+                        self.cannot_derive_hash.contains(&arg.into())
                     });
                 if args_cannot_derive {
                     trace!(
@@ -326,7 +327,7 @@ impl<'ctx> MonotoneFramework for CannotDeriveHash<'ctx> {
                     "The early ty.is_opaque check should have handled this case"
                 );
                 let def_cannot_derive = self.cannot_derive_hash.contains(
-                    &template.template_definition(),
+                    &template.template_definition().into(),
                 );
                 if def_cannot_derive {
                     trace!(