Generate unique names for unnamed template parameters

Fixes rust-lang#446

Author: fitzgen

src/ir/comp.rs

@@ -627,13 +627,15 @@ impl CompInfo {
                     // Yes! You can arrive here with an empty template parameter
                     // name! Awesome, isn't it?
                     //
-                    // see tests/headers/empty_template_param_name.hpp
-                    if cur.spelling().is_empty() {
-                        return CXChildVisit_Continue;
-                    }
+                    // See tests/headers/empty_template_param_name.hpp
+                    let name = cur.spelling();
+                    let name = if name.is_empty() {
+                        format!("__anon_named_type_{}", ctx.allocate_anon_named_type_id())
+                    } else {
+                        name
+                    };
 
-                    let param =
-                        Item::named_type(cur.spelling(), potential_id, ctx);
+                    let param = Item::named_type(name, potential_id, ctx);
                     ci.template_args.push(param);
                 }
                 CXCursor_CXXBaseSpecifier => {

src/ir/context.rs

@@ -141,6 +141,9 @@ pub struct BindgenContext<'ctx> {
 
     /// Whether a bindgen complex was generated
     generated_bindegen_complex: Cell<bool>,
+
+    /// Counter for making our generated names for anonymous named types unique.
+    anon_named_type_counter: usize,
 }
 
 impl<'ctx> BindgenContext<'ctx> {
@@ -178,6 +181,7 @@ impl<'ctx> BindgenContext<'ctx> {
             translation_unit: translation_unit,
             options: options,
             generated_bindegen_complex: Cell::new(false),
+            anon_named_type_counter: 0,
         };
 
         me.add_item(root_module, None, None);
@@ -1145,6 +1149,33 @@ impl<'ctx> BindgenContext<'ctx> {
     pub fn need_bindegen_complex_type(&self) -> bool {
         self.generated_bindegen_complex.get()
     }
+
+    /// We must generate a unique name for unnamed template parameters.
+    ///
+    /// For example:
+    ///
+    /// ```c++
+    /// template <typename> Foo { int x; };
+    /// ```
+    ///
+    /// Must become something like this:
+    ///
+    /// ```ignore
+    /// struct Foo<__anon_named_type_36> {
+    ///     x: std::os::raw::c_int,
+    ///     _phantom_0: PhantomData<__anon_named_type_36>,
+    /// }
+    /// ```
+    ///
+    /// Ideally, this counter would only be locally unique within an Item's
+    /// direct siblings, parent, and children. However, we currently construct
+    /// these names at parse time, before each item has a local ID, and it isn't
+    /// clear that the extant local ID is unique enough for this purpose.
+    pub fn allocate_anon_named_type_id(&mut self) -> usize {
+        let id = self.anon_named_type_counter;
+        self.anon_named_type_counter += 1;
+        id
+    }
 }
 
 /// An iterator over whitelisted items.

tests/expectations/tests/bad-namespace-parenthood-inheritance.rs

@@ -11,10 +11,8 @@ pub struct std_char_traits<_CharT> {
     pub _phantom_0: ::std::marker::PhantomData<_CharT>,
 }
 #[repr(C)]
-#[derive(Debug, Copy)]
-pub struct __gnu_cxx_char_traits {
+#[derive(Debug, Copy, Clone)]
+pub struct __gnu_cxx_char_traits<__bindgen_named_type_0> {
     pub _address: u8,
-}
-impl Clone for __gnu_cxx_char_traits {
-    fn clone(&self) -> Self { *self }
+    pub _phantom_0: ::std::marker::PhantomData<__bindgen_named_type_0>,
 }

tests/expectations/tests/empty_template_param_name.rs

@@ -7,7 +7,8 @@
 pub type __void_t = ::std::os::raw::c_void;
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
-pub struct __iterator_traits<_Iterator> {
+pub struct __iterator_traits<_Iterator, __bindgen_named_type_0> {
     pub _address: u8,
     pub _phantom_0: ::std::marker::PhantomData<_Iterator>,
+    pub _phantom_1: ::std::marker::PhantomData<__bindgen_named_type_0>,
 }

tests/expectations/tests/typename-with-no-name.rs

@@ -0,0 +1,22 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(non_snake_case)]
+
+
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    #[repr(C)]
+    #[derive(Debug, Copy, Clone)]
+    pub struct a<__bindgen_named_type_0> {
+        pub _address: u8,
+        pub _phantom_0: ::std::marker::PhantomData<__bindgen_named_type_0>,
+    }
+    pub type b<T> = root::a<T>;
+    #[repr(C)]
+    #[derive(Debug, Copy, Clone)]
+    pub struct Rooted<T> {
+        pub c: root::b<T>,
+    }
+}

tests/headers/typename-with-no-name.hpp

@@ -0,0 +1,4 @@
+// bindgen-flags: --enable-cxx-namespaces -- --std=c++14
+template <typename> struct a {};
+template <typename T> using b = a<T>;
+template <typename T> class Rooted { b<T> c; };