Use fully disambiguated name instead of a number for layout tests (fixes #394)

Author: Manishearth

src/codegen/mod.rs

@@ -768,7 +768,7 @@ impl CodeGenerator for TemplateInstantiation {
             let size = layout.size;
             let align = layout.align;
 
-            let name = item.canonical_name(ctx);
+            let name = item.full_disambiguated_name(ctx);
             let mut fn_name = format!("__bindgen_test_layout_{}_instantiation", name);
             let times_seen = result.overload_number(&fn_name);
             if times_seen > 0 {

src/ir/item.rs

@@ -681,6 +681,33 @@ impl Item {
         }
     }
 
+    /// Create a fully disambiguated name for an item, including template
+    /// parameters if it is a type
+    pub fn full_disambiguated_name(&self, ctx: &BindgenContext) -> String {
+        let mut s = String::new();
+        let level = 0;
+        self.push_disambiguated_name(ctx, &mut s, level);
+        s
+    }
+
+    /// Helper function for full_disambiguated_name
+    fn push_disambiguated_name(&self, ctx: &BindgenContext, to: &mut String, level: u8) {
+        to.push_str(&self.canonical_name(ctx));
+        if let ItemKind::Type(ref ty) = *self.kind() {
+            if let TypeKind::TemplateInstantiation(ref inst) = *ty.kind() {
+                to.push_str(&format!("_open{}_", level));
+                for arg in inst.template_arguments() {
+                    arg.into_resolver()
+                       .through_type_refs()
+                       .resolve(ctx)
+                       .push_disambiguated_name(ctx, to, level + 1);
+                    to.push_str("_");
+                }
+                to.push_str(&format!("close{}", level));
+            }
+        }
+    }
+
     /// Get this function item's name, or `None` if this item is not a function.
     fn func_name(&self) -> Option<&str> {
         match *self.kind() {

tests/expectations/tests/anon_union.rs

@@ -80,7 +80,7 @@ impl Default for ErrorResult {
     fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }
 #[test]
-fn __bindgen_test_layout_TErrorResult_instantiation() {
+fn __bindgen_test_layout_TErrorResult_open0_int_close0_instantiation() {
     assert_eq!(::std::mem::size_of::<TErrorResult>() , 24usize , concat ! (
                "Size of template specialization: " , stringify ! (
                TErrorResult ) ));

tests/expectations/tests/class_nested.rs

@@ -78,7 +78,7 @@ extern "C" {
     pub static mut var: A_B;
 }
 #[test]
-fn __bindgen_test_layout_A_D_instantiation() {
+fn __bindgen_test_layout_A_D_open0_int_close0_instantiation() {
     assert_eq!(::std::mem::size_of::<A_D<::std::os::raw::c_int>>() , 4usize ,
                concat ! (
                "Size of template specialization: " , stringify ! (

tests/expectations/tests/class_with_dtor.rs

@@ -35,7 +35,7 @@ impl Default for WithoutDtor {
     fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }
 #[test]
-fn __bindgen_test_layout_HandleWithDtor_instantiation() {
+fn __bindgen_test_layout_HandleWithDtor_open0_int_close0_instantiation() {
     assert_eq!(::std::mem::size_of::<HandleWithDtor<::std::os::raw::c_int>>()
                , 8usize , concat ! (
                "Size of template specialization: " , stringify ! (

tests/expectations/tests/crtp.rs

@@ -51,15 +51,15 @@ impl Default for DerivedFromBaseWithDestructor {
     fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }
 #[test]
-fn __bindgen_test_layout_Base_instantiation() {
+fn __bindgen_test_layout_Base_open0_Derived_close0_instantiation() {
     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() {
+fn __bindgen_test_layout_BaseWithDestructor_open0_DerivedFromBaseWithDestructor_close0_instantiation() {
     assert_eq!(::std::mem::size_of::<BaseWithDestructor>() , 1usize , concat !
                (
                "Size of template specialization: " , stringify ! (

tests/expectations/tests/default-template-parameter.rs

@@ -16,7 +16,7 @@ impl <T, U> Default for Foo<T, U> {
     fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }
 #[test]
-fn __bindgen_test_layout_Foo_instantiation() {
+fn __bindgen_test_layout_Foo_open0_bool__int_close0_instantiation() {
     assert_eq!(::std::mem::size_of::<Foo<bool, ::std::os::raw::c_int>>() ,
                8usize , concat ! (
                "Size of template specialization: " , stringify ! (

tests/expectations/tests/forward-declaration-autoptr.rs

@@ -42,7 +42,7 @@ impl Default for Bar {
     fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }
 #[test]
-fn __bindgen_test_layout_RefPtr_instantiation() {
+fn __bindgen_test_layout_RefPtr_open0_Foo_close0_instantiation() {
     assert_eq!(::std::mem::size_of::<RefPtr<Foo>>() , 8usize , concat ! (
                "Size of template specialization: " , stringify ! ( RefPtr<Foo>
                ) ));

tests/expectations/tests/inner_template_self.rs

@@ -37,7 +37,7 @@ impl Default for InstantiateIt {
     fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }
 #[test]
-fn __bindgen_test_layout_LinkedList_instantiation() {
+fn __bindgen_test_layout_LinkedList_open0_int_close0_instantiation() {
     assert_eq!(::std::mem::size_of::<LinkedList>() , 16usize , concat ! (
                "Size of template specialization: " , stringify ! ( LinkedList
                ) ));

tests/expectations/tests/issue-372.rs

@@ -102,7 +102,7 @@ pub mod root {
         fn default() -> Self { unsafe { ::std::mem::zeroed() } }
     }
     #[test]
-    fn __bindgen_test_layout_C_instantiation() {
+    fn __bindgen_test_layout_C_open0_n_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<[u64; 33usize]>() , 264usize , concat
                    ! (
                    "Size of template specialization: " , stringify ! (