Union fields.

Author: emilio

src/codegen/mod.rs

@@ -511,25 +511,23 @@ impl CodeGenerator for CompInfo {
                 }
             }
 
-            if !is_union {
-                let ty = field.ty().to_rust_ty(ctx);
-
-                let ty = if is_union {
-                    quote_ty!(ctx.ext_cx(), __BindgenUnionField<$ty>)
-                } else {
-                    ty
-                };
-
-                let mut attrs = vec![];
-                if let Some(comment) = field.comment() {
-                    attrs.push(doc!(comment));
-                }
+            let ty = field.ty().to_rust_ty(ctx);
+
+            let ty = if is_union {
+                quote_ty!(ctx.ext_cx(), __BindgenUnionField<$ty>)
+            } else {
+                ty
+            };
 
-                let field = StructFieldBuilder::named(field.name()).pub_()
-                                        .with_attrs(attrs)
-                                        .build_ty(ty);
-                fields.push(field);
+            let mut attrs = vec![];
+            if let Some(comment) = field.comment() {
+                attrs.push(doc!(comment));
             }
+
+            let field = StructFieldBuilder::named(field.name()).pub_()
+                                    .with_attrs(attrs)
+                                    .build_ty(ty);
+            fields.push(field);
         }
 
         if is_union {
@@ -945,14 +943,80 @@ impl CodeGenerator for Function {
 
 pub fn codegen(context: &mut BindgenContext) -> Vec<P<ast::Item>> {
     context.gen(|context| {
-        let mut result = vec![];
+        let mut result = CodegenResult::new();
         for (item_id, item) in context.items() {
             // Non-toplevel item parents are the responsible one for generating
             // them.
             if item.is_toplevel(context) {
                 item.codegen(context, &mut result, &());
             }
         }
+        let saw_union = result.saw_union;
+        let mut result = result.items;
+        if saw_union {
+            utils::prepend_union_types(context, &mut result);
+        }
         result
     })
 }
+
+mod utils {
+    use ir::context::BindgenContext;
+    use syntax::ast;
+    use syntax::ptr::P;
+    use std::mem;
+
+    pub fn prepend_union_types(ctx: &BindgenContext, result: &mut Vec<P<ast::Item>>) {
+        use std::mem;
+        let union_field_decl = quote_item!(ctx.ext_cx(),
+            #[derive(Copy, Debug)]
+            #[repr(C)]
+            pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+        ).unwrap();
+
+        let union_field_impl = quote_item!(&ctx.ext_cx(),
+            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)
+                }
+            }
+        ).unwrap();
+
+        let union_field_default_impl = quote_item!(&ctx.ext_cx(),
+            impl<T> ::std::default::Default for __BindgenUnionField<T> {
+                #[inline]
+                fn default() -> Self {
+                    Self::new()
+                }
+            }
+        ).unwrap();
+
+        let union_field_clone_impl = quote_item!(&ctx.ext_cx(),
+            impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+                #[inline]
+                fn clone(&self) -> Self {
+                    Self::new()
+                }
+            }
+        ).unwrap();
+
+        let items = vec![
+            union_field_decl, union_field_impl,
+            union_field_default_impl, union_field_clone_impl
+        ];
+
+        let old_items = mem::replace(result, items);
+        result.extend(old_items.into_iter());
+    }
+}