Reinstate the layout tests for template instantiations

Author: fitzgen

src/codegen/mod.rs

@@ -20,7 +20,7 @@ use ir::item_kind::ItemKind;
 use ir::layout::Layout;
 use ir::module::Module;
 use ir::objc::ObjCInterface;
-use ir::template::AsNamed;
+use ir::template::{AsNamed, TemplateInstantiation};
 use ir::ty::{TemplateDeclaration, Type, TypeKind};
 use ir::var::Var;
 
@@ -518,14 +518,16 @@ impl CodeGenerator for Type {
             TypeKind::Pointer(..) |
             TypeKind::BlockPointer |
             TypeKind::Reference(..) |
-            TypeKind::TemplateInstantiation(..) |
             TypeKind::Function(..) |
             TypeKind::ResolvedTypeRef(..) |
             TypeKind::Named => {
                 // These items don't need code generation, they only need to be
                 // converted to rust types in fields, arguments, and such.
                 return;
             }
+            TypeKind::TemplateInstantiation(ref inst) => {
+                inst.codegen(ctx, result, whitelisted_items, item)
+            }
             TypeKind::Comp(ref ci) => {
                 ci.codegen(ctx, result, whitelisted_items, item)
             }
@@ -821,6 +823,53 @@ impl<'a> Bitfield<'a> {
     }
 }
 
+impl CodeGenerator for TemplateInstantiation {
+    type Extra = Item;
+
+    fn codegen<'a>(&self,
+                   ctx: &BindgenContext,
+                   result: &mut CodegenResult<'a>,
+                   _whitelisted_items: &ItemSet,
+                   item: &Item) {
+        // Although uses of instantiations don't need code generation, and are
+        // just converted to rust types in fields, vars, etc, we take this
+        // opportunity to generate tests for their layout here.
+
+        let layout = item.kind().expect_type().layout(ctx);
+
+        if let Some(layout) = layout {
+            let size = layout.size;
+            let align = layout.align;
+
+            let name = item.canonical_name(ctx);
+            let fn_name = format!("__bindgen_test_layout_{}_instantiation_{}",
+                                  name,
+                                  item.id().as_usize());
+            let fn_name = ctx.rust_ident_raw(&fn_name);
+
+            let prefix = ctx.trait_prefix();
+            let ident = item.to_rust_ty(ctx);
+            let size_of_expr = quote_expr!(ctx.ext_cx(),
+                                           ::$prefix::mem::size_of::<$ident>());
+            let align_of_expr = quote_expr!(ctx.ext_cx(),
+                                            ::$prefix::mem::align_of::<$ident>());
+
+            let item = quote_item!(
+                ctx.ext_cx(),
+                #[test]
+                fn $fn_name() {
+                    assert_eq!($size_of_expr, $size,
+                               concat!("Size of template specialization: ", stringify!($ident)));
+                    assert_eq!($align_of_expr, $align,
+                               concat!("Alignment of template specialization: ", stringify!($ident)));
+                })
+                .unwrap();
+
+            result.push(item);
+        }
+    }
+}
+
 impl CodeGenerator for CompInfo {
     type Extra = Item;
 

tests/expectations/tests/anon_union.rs

@@ -79,3 +79,12 @@ impl Clone for ErrorResult {
 impl Default for ErrorResult {
     fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }
+#[test]
+fn __bindgen_test_layout_TErrorResult_instantiation_21() {
+    assert_eq!(::std::mem::size_of::<TErrorResult>() , 24usize , concat ! (
+               "Size of template specialization: " , stringify ! (
+               TErrorResult ) ));
+    assert_eq!(::std::mem::align_of::<TErrorResult>() , 8usize , concat ! (
+               "Alignment of template specialization: " , stringify ! (
+               TErrorResult ) ));
+}

tests/expectations/tests/class_nested.rs

@@ -76,6 +76,17 @@ extern "C" {
     #[link_name = "var"]
     pub static mut var: A_B;
 }
+#[test]
+fn __bindgen_test_layout_A_D_instantiation_16() {
+    assert_eq!(::std::mem::size_of::<A_D<::std::os::raw::c_int>>() , 4usize ,
+               concat ! (
+               "Size of template specialization: " , stringify ! (
+               A_D<::std::os::raw::c_int> ) ));
+    assert_eq!(::std::mem::align_of::<A_D<::std::os::raw::c_int>>() , 4usize ,
+               concat ! (
+               "Alignment of template specialization: " , stringify ! (
+               A_D<::std::os::raw::c_int> ) ));
+}
 extern "C" {
     #[link_name = "baz"]
     pub static mut baz: A_D<::std::os::raw::c_int>;

tests/expectations/tests/class_with_dtor.rs

@@ -33,3 +33,14 @@ fn bindgen_test_layout_WithoutDtor() {
 impl Default for WithoutDtor {
     fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }
+#[test]
+fn __bindgen_test_layout_HandleWithDtor_instantiation_10() {
+    assert_eq!(::std::mem::size_of::<HandleWithDtor<::std::os::raw::c_int>>()
+               , 8usize , concat ! (
+               "Size of template specialization: " , stringify ! (
+               HandleWithDtor<::std::os::raw::c_int> ) ));
+    assert_eq!(::std::mem::align_of::<HandleWithDtor<::std::os::raw::c_int>>()
+               , 8usize , concat ! (
+               "Alignment of template specialization: " , stringify ! (
+               HandleWithDtor<::std::os::raw::c_int> ) ));
+}

tests/expectations/tests/crtp.rs

@@ -50,3 +50,22 @@ fn bindgen_test_layout_DerivedFromBaseWithDestructor() {
 impl Default for DerivedFromBaseWithDestructor {
     fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }
+#[test]
+fn __bindgen_test_layout_Base_instantiation_9() {
+    assert_eq!(::std::mem::size_of::<Base>() , 1usize , concat ! (
+               "Size of template specialization: " , stringify ! ( Base ) ));
+    assert_eq!(::std::mem::align_of::<Base>() , 1usize , concat ! (
+               "Alignment of template specialization: " , stringify ! ( Base )
+               ));
+}
+#[test]
+fn __bindgen_test_layout_BaseWithDestructor_instantiation_12() {
+    assert_eq!(::std::mem::size_of::<BaseWithDestructor>() , 1usize , concat !
+               (
+               "Size of template specialization: " , stringify ! (
+               BaseWithDestructor ) ));
+    assert_eq!(::std::mem::align_of::<BaseWithDestructor>() , 1usize , concat
+               ! (
+               "Alignment of template specialization: " , stringify ! (
+               BaseWithDestructor ) ));
+}

tests/expectations/tests/template.rs

@@ -232,3 +232,36 @@ impl <T> Default for ReplacedWithoutDestructorFwd<T> {
 pub struct TemplateWithVar {
     pub _address: u8,
 }
+#[test]
+fn __bindgen_test_layout_Foo_instantiation_95() {
+    assert_eq!(::std::mem::size_of::<Foo<::std::os::raw::c_int>>() , 24usize ,
+               concat ! (
+               "Size of template specialization: " , stringify ! (
+               Foo<::std::os::raw::c_int> ) ));
+    assert_eq!(::std::mem::align_of::<Foo<::std::os::raw::c_int>>() , 8usize ,
+               concat ! (
+               "Alignment of template specialization: " , stringify ! (
+               Foo<::std::os::raw::c_int> ) ));
+}
+#[test]
+fn __bindgen_test_layout_Rooted_instantiation_106() {
+    assert_eq!(::std::mem::size_of::<Rooted<*mut ::std::os::raw::c_void>>() ,
+               24usize , concat ! (
+               "Size of template specialization: " , stringify ! (
+               Rooted<*mut ::std::os::raw::c_void> ) ));
+    assert_eq!(::std::mem::align_of::<Rooted<*mut ::std::os::raw::c_void>>() ,
+               8usize , concat ! (
+               "Alignment of template specialization: " , stringify ! (
+               Rooted<*mut ::std::os::raw::c_void> ) ));
+}
+#[test]
+fn __bindgen_test_layout_WithDtor_instantiation_114() {
+    assert_eq!(::std::mem::size_of::<WithDtor<::std::os::raw::c_int>>() ,
+               4usize , concat ! (
+               "Size of template specialization: " , stringify ! (
+               WithDtor<::std::os::raw::c_int> ) ));
+    assert_eq!(::std::mem::align_of::<WithDtor<::std::os::raw::c_int>>() ,
+               4usize , concat ! (
+               "Alignment of template specialization: " , stringify ! (
+               WithDtor<::std::os::raw::c_int> ) ));
+}