Handle unions that have non-Copy types

Fixes rust-lang#895

Author: tmfink

src/codegen/mod.rs

@@ -83,6 +83,9 @@ struct CodegenResult<'a> {
     /// need to be referenced by anything.
     codegen_id: &'a Cell<usize>,
 
+    /// Whether a bindgen union has been generated at least once.
+    saw_bindgen_union: bool,
+
     /// Whether an union has been generated at least once.
     saw_union: bool,
 
@@ -123,6 +126,7 @@ impl<'a> CodegenResult<'a> {
         CodegenResult {
             items: vec![],
             saw_union: false,
+            saw_bindgen_union: false,
             saw_incomplete_array: false,
             saw_objc: false,
             codegen_id: codegen_id,
@@ -137,6 +141,11 @@ impl<'a> CodegenResult<'a> {
         self.saw_union = true;
     }
 
+    fn saw_bindgen_union(&mut self) {
+        self.saw_union();
+        self.saw_bindgen_union = true;
+    }
+
     fn saw_incomplete_array(&mut self) {
         self.saw_incomplete_array = true;
     }
@@ -350,7 +359,7 @@ impl CodeGenerator for Module {
             }
 
             if item.id() == ctx.root_module() {
-                if result.saw_union && !ctx.options().rust_features().untagged_union() {
+                if result.saw_bindgen_union {
                     utils::prepend_union_types(ctx, &mut *result);
                 }
                 if result.saw_incomplete_array {
@@ -912,7 +921,7 @@ impl<'a> FieldCodegen<'a> for FieldData {
         let ty = self.ty().to_rust_ty_or_opaque(ctx, &());
 
         // NB: If supported, we use proper `union` types.
-        let ty = if parent.is_union() && !ctx.options().rust_features().untagged_union() {
+        let ty = if parent.is_union() && !parent.can_be_rust_union(ctx) {
             if ctx.options().enable_cxx_namespaces {
                 quote_ty!(ctx.ext_cx(), root::__BindgenUnionField<$ty>)
             } else {
@@ -1449,7 +1458,7 @@ impl CodeGenerator for CompInfo {
         }
 
         let canonical_name = item.canonical_name(ctx);
-        let builder = if is_union && ctx.options().rust_features().untagged_union() {
+        let builder = if is_union && self.can_be_rust_union(ctx) {
             aster::AstBuilder::new()
                 .item()
                 .pub_()
@@ -1528,6 +1537,9 @@ impl CodeGenerator for CompInfo {
         }
         if is_union {
             result.saw_union();
+            if !self.can_be_rust_union(ctx) {
+                result.saw_bindgen_union();
+            }
         }
 
         let layout = item.kind().expect_type().layout(ctx);
@@ -1556,7 +1568,7 @@ impl CodeGenerator for CompInfo {
                           ());
         }
 
-        if is_union && !ctx.options().rust_features().untagged_union() {
+        if is_union && !self.can_be_rust_union(ctx) {
             let layout = layout.expect("Unable to get layout information?");
             let ty = BlobTyBuilder::new(layout).build();
             let field = StructFieldBuilder::named("bindgen_union_field")

src/ir/comp.rs

@@ -10,6 +10,7 @@ use super::traversal::{EdgeKind, Trace, Tracer};
 use super::template::TemplateParameters;
 use clang;
 use codegen::struct_layout::{align_to, bytes_from_bits_pow2};
+use ir::derive::CanDeriveCopy;
 use parse::{ClangItemParser, ParseError};
 use peeking_take_while::PeekableExt;
 use std::cell::Cell;
@@ -1316,6 +1317,22 @@ impl CompInfo {
     pub fn compute_bitfield_units(&mut self, ctx: &BindgenContext) {
         self.fields.compute_bitfield_units(ctx);
     }
+
+    /// Returns whether the current union can be represented as a Rust `union`
+    ///
+    /// Requirements:
+    ///     1. Current RustTarget allows for `untagged_union`
+    ///     2. Each field can derive `Copy`
+    pub fn can_be_rust_union(&self, ctx: &BindgenContext) -> bool {
+        ctx.options().rust_features().untagged_union() &&
+            self.fields().iter().all(|f|
+                match f {
+                    &Field::DataMember(ref field_data) => field_data.ty().can_derive_copy(ctx),
+                    &Field::Bitfields(_) => false,
+                }
+            )
+    }
+
 }
 
 impl DotAttributes for CompInfo {

tests/expectations/tests/issue-493.rs

@@ -4,6 +4,33 @@
 #![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
 
 
+#[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) { }
+}
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone, Hash)]
 pub struct basic_string {
@@ -27,3 +54,58 @@ pub const basic_string___min_cap: basic_string__bindgen_ty_1 =
 #[repr(i32)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum basic_string__bindgen_ty_1 { __min_cap = 0, }
+#[repr(C)]
+pub struct basic_string___short {
+    pub __bindgen_anon_1: basic_string___short__bindgen_ty_1,
+    pub __data_: *mut basic_string_value_type,
+}
+#[repr(C)]
+pub union basic_string___short__bindgen_ty_1 {
+    pub __size_: ::std::os::raw::c_uchar,
+    pub __lx: basic_string_value_type,
+}
+impl Default for basic_string___short__bindgen_ty_1 {
+    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+}
+impl Default for basic_string___short {
+    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+}
+#[repr(C)]
+pub struct basic_string___ulx {
+    pub __lx: __BindgenUnionField<basic_string___long>,
+    pub __lxx: __BindgenUnionField<basic_string___short>,
+    pub bindgen_union_field: [u8; 0usize],
+}
+impl Default for basic_string___ulx {
+    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+}
+pub const basic_string___n_words: basic_string__bindgen_ty_2 =
+    basic_string__bindgen_ty_2::__n_words;
+#[repr(i32)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum basic_string__bindgen_ty_2 { __n_words = 0, }
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash)]
+pub struct basic_string___raw {
+    pub __words: *mut basic_string_size_type,
+}
+impl Default for basic_string___raw {
+    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+}
+#[repr(C)]
+pub struct basic_string___rep {
+    pub __bindgen_anon_1: basic_string___rep__bindgen_ty_1,
+}
+#[repr(C)]
+pub struct basic_string___rep__bindgen_ty_1 {
+    pub __l: __BindgenUnionField<basic_string___long>,
+    pub __s: __BindgenUnionField<basic_string___short>,
+    pub __r: __BindgenUnionField<basic_string___raw>,
+    pub bindgen_union_field: [u8; 0usize],
+}
+impl Default for basic_string___rep__bindgen_ty_1 {
+    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+}
+impl Default for basic_string___rep {
+    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+}

tests/headers/issue-493.hpp

@@ -18,8 +18,6 @@ class basic_string
     enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
                         (sizeof(__long) - 1)/sizeof(value_type) : 2};
 
-// TODO(tmfink) uncomment once test passes
-#if 0
     struct __short
     {
         union
@@ -48,5 +46,4 @@ class basic_string
             __raw   __r;
         };
     };
-#endif
 };