codegen: Fix remaining cases of missing core prefix.

Author: emilio

src/codegen/helpers.rs

@@ -89,7 +89,10 @@ pub mod ast_ty {
                 let prefix = ctx.rust_ident_raw(prefix);
                 quote_ty!(ctx.ext_cx(), $prefix::$ident)
             }
-            None => quote_ty!(ctx.ext_cx(), ::std::os::raw::$ident),
+            None => {
+                let prefix = ctx.trait_prefix();
+                quote_ty!(ctx.ext_cx(), ::$prefix::os::raw::$ident)
+            }
         }
     }
 

src/codegen/mod.rs

@@ -1593,9 +1593,10 @@ impl MethodCodegen for Method {
         // If it's a constructor, we need to insert an extra parameter with a
         // variable called `__bindgen_tmp` we're going to create.
         if self.is_constructor() {
+            let prefix = ctx.trait_prefix();
             let tmp_variable_decl =
                 quote_stmt!(ctx.ext_cx(),
-                            let mut __bindgen_tmp = ::std::mem::uninitialized())
+                            let mut __bindgen_tmp = ::$prefix::mem::uninitialized())
                 .unwrap();
             stmts.push(tmp_variable_decl);
             exprs[0] = quote_expr!(ctx.ext_cx(), &mut __bindgen_tmp);
@@ -2137,7 +2138,7 @@ impl ToRustTy for Type {
                         .map(|arg| arg.to_rust_ty(ctx))
                         .collect::<Vec<_>>();
 
-                    path.segments.last_mut().unwrap().parameters = if 
+                    path.segments.last_mut().unwrap().parameters = if
                         template_args.is_empty() {
                         None
                     } else {
@@ -2550,9 +2551,9 @@ mod utils {
             .unwrap();
 
         let union_field_debug_impl = quote_item!(ctx.ext_cx(),
-            impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-                fn fmt(&self, fmt: &mut ::std::fmt::Formatter)
-                       -> ::std::fmt::Result {
+            impl<T> ::$prefix::fmt::Debug for __BindgenUnionField<T> {
+                fn fmt(&self, fmt: &mut ::$prefix::fmt::Formatter)
+                       -> ::$prefix::fmt::Result {
                     fmt.write_str("__BindgenUnionField")
                 }
             }

tests/expectations/tests/use-core.rs

@@ -5,12 +5,36 @@
 
 extern crate core;
 
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::core::marker::PhantomData<T>);
+impl <T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self { __BindgenUnionField(::core::marker::PhantomData) }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T { ::core::mem::transmute(self) }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T { ::core::mem::transmute(self) }
+}
+impl <T> ::core::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self { Self::new() }
+}
+impl <T> ::core::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self { Self::new() }
+}
+impl <T> ::core::marker::Copy for __BindgenUnionField<T> { }
+impl <T> ::core::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
 #[repr(C)]
 #[derive(Debug, Copy)]
 pub struct foo {
-    pub a: ::std::os::raw::c_int,
-    pub b: ::std::os::raw::c_int,
-    pub bar: *mut ::std::os::raw::c_void,
+    pub a: ::core::os::raw::c_int,
+    pub b: ::core::os::raw::c_int,
+    pub bar: *mut ::core::os::raw::c_void,
 }
 #[test]
 fn bindgen_test_layout_foo() {
@@ -29,5 +53,30 @@ fn bindgen_test_layout_foo() {
 impl Clone for foo {
     fn clone(&self) -> Self { *self }
 }
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct _bindgen_ty_1 {
+    pub bar: __BindgenUnionField<::core::os::raw::c_int>,
+    pub baz: __BindgenUnionField<::core::os::raw::c_long>,
+    pub bindgen_union_field: u64,
+}
+#[test]
+fn bindgen_test_layout__bindgen_ty_1() {
+    assert_eq!(::core::mem::size_of::<_bindgen_ty_1>() , 8usize);
+    assert_eq! (::core::mem::align_of::<_bindgen_ty_1>() , 8usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const _bindgen_ty_1 ) ) . bar as * const _ as
+                usize } , 0usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const _bindgen_ty_1 ) ) . baz as * const _ as
+                usize } , 0usize);
+}
+impl Clone for _bindgen_ty_1 {
+    fn clone(&self) -> Self { *self }
+}
+extern "C" {
+    #[link_name = "bazz"]
+    pub static mut bazz: _bindgen_ty_1;
+}
 pub type fooFunction =
-    ::core::option::Option<unsafe extern "C" fn(bar: ::std::os::raw::c_int)>;
+    ::core::option::Option<unsafe extern "C" fn(bar: ::core::os::raw::c_int)>;

tests/headers/use-core.h

@@ -5,4 +5,9 @@ struct foo {
   void* bar;
 };
 
+union {
+  int bar;
+  long baz;
+} bazz;
+
 typedef void (*fooFunction)(int bar);