Disallow Copy/Clone/Eq*/Ord* for opaque types

Author: elichai

src/codegen/impl_partialeq.rs

@@ -12,13 +12,13 @@ pub fn gen_partialeq_impl(
     item: &Item,
     ty_for_impl: &proc_macro2::TokenStream,
 ) -> Option<proc_macro2::TokenStream> {
+    debug_assert!(
+        !item.is_opaque(ctx, &()),
+        "You're not supposed to call this on an opaque type"
+    );
     let mut tokens = vec![];
 
-    if item.is_opaque(ctx, &()) {
-        tokens.push(quote! {
-            &self._bindgen_opaque_blob[..] == &other._bindgen_opaque_blob[..]
-        });
-    } else if comp_info.kind() == CompKind::Union {
+    if comp_info.kind() == CompKind::Union {
         assert!(!ctx.options().rust_features().untagged_union);
         tokens.push(quote! {
             &self.bindgen_union_field[..] == &other.bindgen_union_field[..]

src/ir/analysis/derive.rs

@@ -156,37 +156,14 @@ impl<'ctx> CannotDerive<'ctx> {
 
         trace!("ty: {:?}", ty);
         if item.is_opaque(self.ctx, &()) {
-            if !self.derive_trait.can_derive_union() &&
-                ty.is_union() &&
-                self.ctx.options().rust_features().untagged_union
-            {
-                trace!(
-                    "    cannot derive {} for Rust unions",
-                    self.derive_trait
-                );
-                return CanDerive::No;
-            }
-
-            let layout_can_derive =
-                ty.layout(self.ctx).map_or(CanDerive::Yes, |l| {
+            let can_derive_opaque = self.derive_trait.can_derive_opaque();
+            if can_derive_opaque == CanDerive::Yes {
+                return ty.layout(self.ctx).map_or(can_derive_opaque, |l| {
                     l.opaque().array_size_within_derive_limit(self.ctx)
                 });
-
-            match layout_can_derive {
-                CanDerive::Yes => {
-                    trace!(
-                        "    we can trivially derive {} for the layout",
-                        self.derive_trait
-                    );
-                }
-                _ => {
-                    trace!(
-                        "    we cannot derive {} for the layout",
-                        self.derive_trait
-                    );
-                }
-            };
-            return layout_can_derive;
+            } else {
+                return can_derive_opaque;
+            }
         }
 
         match *ty.kind() {
@@ -513,6 +490,16 @@ impl DeriveTrait {
         }
     }
 
+    fn can_derive_opaque(&self) -> CanDerive {
+        match self {
+            DeriveTrait::Copy |
+            DeriveTrait::Hash |
+            DeriveTrait::PartialEqOrPartialOrd => CanDerive::No,
+            DeriveTrait::Default => CanDerive::Yes,
+            DeriveTrait::Debug => CanDerive::Manually,
+        }
+    }
+
     fn can_derive_fnptr(&self, f: &FunctionSig) -> CanDerive {
         match (self, f.function_pointers_can_derive()) {
             (DeriveTrait::Copy, _) | (DeriveTrait::Default, _) | (_, true) => {