From 366fccdffd799728615867b4e2248b518b7ebf15 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Wed, 16 Jan 2019 23:34:56 +0100
Subject: [PATCH] ir: Whitelist items that don't generate code to improve
 derive behavior.

When not whitelisting recursively.

Fixes #1454
---
 src/codegen/mod.rs                            |  2 +
 src/ir/context.rs                             | 22 ++++++++
 tests/expectations/tests/issue-1285.rs        | 53 +++----------------
 .../tests/no-recursive-whitelisting.rs        |  9 +++-
 4 files changed, 37 insertions(+), 49 deletions(-)

diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index 0956eb7ae2..8d1327b34d 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -610,6 +610,8 @@ impl CodeGenerator for Type {
             TypeKind::TypeParam => {
                 // These items don't need code generation, they only need to be
                 // converted to rust types in fields, arguments, and such.
+                // NOTE(emilio): If you add to this list, make sure to also add
+                // it to BindgenContext::compute_whitelisted_and_codegen_items.
                 return;
             }
             TypeKind::TemplateInstantiation(ref inst) => {
diff --git a/src/ir/context.rs b/src/ir/context.rs
index 914a89b2fd..0fe720f92d 100644
--- a/src/ir/context.rs
+++ b/src/ir/context.rs
@@ -2314,6 +2314,28 @@ If you encounter an error missing from this list, please file an issue or a PR!"
                                 return true;
                             }
 
+                            // Auto-whitelist types that don't need code
+                            // generation if not whitelisting recursively, to
+                            // make the #[derive] analysis not be lame.
+                            if !self.options().whitelist_recursively {
+                                match *ty.kind() {
+                                    TypeKind::Void |
+                                    TypeKind::NullPtr |
+                                    TypeKind::Int(..) |
+                                    TypeKind::Float(..) |
+                                    TypeKind::Complex(..) |
+                                    TypeKind::Array(..) |
+                                    TypeKind::Vector(..) |
+                                    TypeKind::Pointer(..) |
+                                    TypeKind::Reference(..) |
+                                    TypeKind::Function(..) |
+                                    TypeKind::ResolvedTypeRef(..) |
+                                    TypeKind::Opaque |
+                                    TypeKind::TypeParam => return true,
+                                    _ => {},
+                                };
+                            }
+
                             // Unnamed top-level enums are special and we
                             // whitelist them via the `whitelisted_vars` filter,
                             // since they're effectively top-level constants,
diff --git a/tests/expectations/tests/issue-1285.rs b/tests/expectations/tests/issue-1285.rs
index 8497c3f241..d0328d340e 100644
--- a/tests/expectations/tests/issue-1285.rs
+++ b/tests/expectations/tests/issue-1285.rs
@@ -8,57 +8,16 @@
 )]
 
 #[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
+#[derive(Copy, Clone)]
 pub struct foo {
     pub bar: foo__bindgen_ty_1,
 }
 #[repr(C)]
-pub struct foo__bindgen_ty_1 {
-    pub a: __BindgenUnionField<::std::os::raw::c_uint>,
-    pub b: __BindgenUnionField<::std::os::raw::c_ushort>,
-    pub bindgen_union_field: u32,
+#[derive(Copy, Clone)]
+pub union foo__bindgen_ty_1 {
+    pub a: ::std::os::raw::c_uint,
+    pub b: ::std::os::raw::c_ushort,
+    _bindgen_union_align: u32,
 }
 #[test]
 fn bindgen_test_layout_foo__bindgen_ty_1() {
diff --git a/tests/expectations/tests/no-recursive-whitelisting.rs b/tests/expectations/tests/no-recursive-whitelisting.rs
index e8fb69447a..e7e71efcc7 100644
--- a/tests/expectations/tests/no-recursive-whitelisting.rs
+++ b/tests/expectations/tests/no-recursive-whitelisting.rs
@@ -1,11 +1,16 @@
 /* automatically generated by rust-bindgen */
 
-
-#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
 
 pub enum Bar {}
 
 #[repr(C)]
+#[derive(Debug, Copy, Clone)]
 pub struct Foo {
     pub baz: *mut Bar,
 }