Google Git
Sign in
fuchsia/third_party/github.com/rust-lang/rust-bindgen/refs/heads/upstream/layouttests-ub^!/.
commit
284dd3c78058fb9560c024d04cc1be2b8afeeda8
[log]
author
Emilio Cobos Álvarez <emilio@crisal.io>
Sun Jun 06 14:31:13 2021 +0200
committer
Emilio Cobos Álvarez <emilio@crisal.io>
Fri Nov 26 02:44:01 2021 +0100
tree
b71c4c7f7e5ceb40aec6417f04b2928914a12638
parent
20ef0b6d15a3cf1c978b040a07c3b5daf0f6afa1 [diff]
Use core when appropriate.

diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index 3dcb50c..f08fc81 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs

@@ -2116,6 +2116,7 @@
                         .count() >
                         1;
 
+                    let prefix = ctx.trait_prefix();
 
                     // The offset of #[repr(C)] union is always 0, don't need to recheck it.
                     let is_not_packed_union = is_union && !packed;
@@ -2144,19 +2145,19 @@
                                                 {
                                                     // Create an instance of #canonical_ident struct from zero bit pattern
                                                     let struct_instance = unsafe {
-                                                        std::mem::zeroed::<#canonical_ident>()
+                                                        #prefix::mem::zeroed::<#canonical_ident>()
                                                     };
 
                                                     // Get the pointers to the struct and its field
                                                     let struct_ptr = &struct_instance as *const #canonical_ident;
-                                                    let field_ptr = std::ptr::addr_of!(struct_instance.#field_name);
+                                                    let field_ptr = #prefix::ptr::addr_of!(struct_instance.#field_name);
 
                                                     // Get the offset of the field
                                                     let struct_address =  struct_ptr as usize;
                                                     let field_address = field_ptr as usize;
 
                                                     //Do not call the destructor
-                                                    std::mem::forget(struct_instance);
+                                                    #prefix::mem::forget(struct_instance);
 
                                                     field_address.checked_sub(struct_address).unwrap()
                                                 },

diff --git a/tests/expectations/tests/ctypes-prefix-path.rs b/tests/expectations/tests/ctypes-prefix-path.rs
index 25ee0cc..e30de34 100644
--- a/tests/expectations/tests/ctypes-prefix-path.rs
+++ b/tests/expectations/tests/ctypes-prefix-path.rs

@@ -33,12 +33,12 @@
     );
     assert_eq!(
         {
-            let struct_instance = unsafe { std::mem::zeroed::<foo>() };
+            let struct_instance = unsafe { core::mem::zeroed::<foo>() };
             let struct_ptr = &struct_instance as *const foo;
-            let field_ptr = std::ptr::addr_of!(struct_instance.a);
+            let field_ptr = core::ptr::addr_of!(struct_instance.a);
             let struct_address = struct_ptr as usize;
             let field_address = field_ptr as usize;
-            std::mem::forget(struct_instance);
+            core::mem::forget(struct_instance);
             field_address.checked_sub(struct_address).unwrap()
         },
         0usize,
@@ -46,12 +46,12 @@
     );
     assert_eq!(
         {
-            let struct_instance = unsafe { std::mem::zeroed::<foo>() };
+            let struct_instance = unsafe { core::mem::zeroed::<foo>() };
             let struct_ptr = &struct_instance as *const foo;
-            let field_ptr = std::ptr::addr_of!(struct_instance.b);
+            let field_ptr = core::ptr::addr_of!(struct_instance.b);
             let struct_address = struct_ptr as usize;
             let field_address = field_ptr as usize;
-            std::mem::forget(struct_instance);
+            core::mem::forget(struct_instance);
             field_address.checked_sub(struct_address).unwrap()
         },
         4usize,
@@ -59,12 +59,12 @@
     );
     assert_eq!(
         {
-            let struct_instance = unsafe { std::mem::zeroed::<foo>() };
+            let struct_instance = unsafe { core::mem::zeroed::<foo>() };
             let struct_ptr = &struct_instance as *const foo;
-            let field_ptr = std::ptr::addr_of!(struct_instance.bar);
+            let field_ptr = core::ptr::addr_of!(struct_instance.bar);
             let struct_address = struct_ptr as usize;
             let field_address = field_ptr as usize;
-            std::mem::forget(struct_instance);
+            core::mem::forget(struct_instance);
             field_address.checked_sub(struct_address).unwrap()
         },
         8usize,

diff --git a/tests/expectations/tests/derive-debug-bitfield-core.rs b/tests/expectations/tests/derive-debug-bitfield-core.rs
index 366923e..dea02ca 100644
--- a/tests/expectations/tests/derive-debug-bitfield-core.rs
+++ b/tests/expectations/tests/derive-debug-bitfield-core.rs

@@ -114,12 +114,12 @@
     );
     assert_eq!(
         {
-            let struct_instance = unsafe { std::mem::zeroed::<C>() };
+            let struct_instance = unsafe { core::mem::zeroed::<C>() };
             let struct_ptr = &struct_instance as *const C;
-            let field_ptr = std::ptr::addr_of!(struct_instance.large_array);
+            let field_ptr = core::ptr::addr_of!(struct_instance.large_array);
             let struct_address = struct_ptr as usize;
             let field_address = field_ptr as usize;
-            std::mem::forget(struct_instance);
+            core::mem::forget(struct_instance);
             field_address.checked_sub(struct_address).unwrap()
         },
         4usize,

diff --git a/tests/expectations/tests/derive-partialeq-core.rs b/tests/expectations/tests/derive-partialeq-core.rs
index 2079d8b..4362a40 100644
--- a/tests/expectations/tests/derive-partialeq-core.rs
+++ b/tests/expectations/tests/derive-partialeq-core.rs

@@ -26,12 +26,12 @@
     );
     assert_eq!(
         {
-            let struct_instance = unsafe { std::mem::zeroed::<C>() };
+            let struct_instance = unsafe { core::mem::zeroed::<C>() };
             let struct_ptr = &struct_instance as *const C;
-            let field_ptr = std::ptr::addr_of!(struct_instance.large_array);
+            let field_ptr = core::ptr::addr_of!(struct_instance.large_array);
             let struct_address = struct_ptr as usize;
             let field_address = field_ptr as usize;
-            std::mem::forget(struct_instance);
+            core::mem::forget(struct_instance);
             field_address.checked_sub(struct_address).unwrap()
         },
         0usize,

diff --git a/tests/expectations/tests/no-std.rs b/tests/expectations/tests/no-std.rs
index 9de5d52..7b79f30 100644
--- a/tests/expectations/tests/no-std.rs
+++ b/tests/expectations/tests/no-std.rs

@@ -31,12 +31,12 @@
     );
     assert_eq!(
         {
-            let struct_instance = unsafe { std::mem::zeroed::<foo>() };
+            let struct_instance = unsafe { core::mem::zeroed::<foo>() };
             let struct_ptr = &struct_instance as *const foo;
-            let field_ptr = std::ptr::addr_of!(struct_instance.a);
+            let field_ptr = core::ptr::addr_of!(struct_instance.a);
             let struct_address = struct_ptr as usize;
             let field_address = field_ptr as usize;
-            std::mem::forget(struct_instance);
+            core::mem::forget(struct_instance);
             field_address.checked_sub(struct_address).unwrap()
         },
         0usize,
@@ -44,12 +44,12 @@
     );
     assert_eq!(
         {
-            let struct_instance = unsafe { std::mem::zeroed::<foo>() };
+            let struct_instance = unsafe { core::mem::zeroed::<foo>() };
             let struct_ptr = &struct_instance as *const foo;
-            let field_ptr = std::ptr::addr_of!(struct_instance.b);
+            let field_ptr = core::ptr::addr_of!(struct_instance.b);
             let struct_address = struct_ptr as usize;
             let field_address = field_ptr as usize;
-            std::mem::forget(struct_instance);
+            core::mem::forget(struct_instance);
             field_address.checked_sub(struct_address).unwrap()
         },
         4usize,
@@ -57,12 +57,12 @@
     );
     assert_eq!(
         {
-            let struct_instance = unsafe { std::mem::zeroed::<foo>() };
+            let struct_instance = unsafe { core::mem::zeroed::<foo>() };
             let struct_ptr = &struct_instance as *const foo;
-            let field_ptr = std::ptr::addr_of!(struct_instance.bar);
+            let field_ptr = core::ptr::addr_of!(struct_instance.bar);
             let struct_address = struct_ptr as usize;
             let field_address = field_ptr as usize;
-            std::mem::forget(struct_instance);
+            core::mem::forget(struct_instance);
             field_address.checked_sub(struct_address).unwrap()
         },
         8usize,

diff --git a/tests/expectations/tests/use-core.rs b/tests/expectations/tests/use-core.rs
index 006a98b..3c30c09 100644
--- a/tests/expectations/tests/use-core.rs
+++ b/tests/expectations/tests/use-core.rs

@@ -28,12 +28,12 @@
     );
     assert_eq!(
         {
-            let struct_instance = unsafe { std::mem::zeroed::<foo>() };
+            let struct_instance = unsafe { core::mem::zeroed::<foo>() };
             let struct_ptr = &struct_instance as *const foo;
-            let field_ptr = std::ptr::addr_of!(struct_instance.a);
+            let field_ptr = core::ptr::addr_of!(struct_instance.a);
             let struct_address = struct_ptr as usize;
             let field_address = field_ptr as usize;
-            std::mem::forget(struct_instance);
+            core::mem::forget(struct_instance);
             field_address.checked_sub(struct_address).unwrap()
         },
         0usize,
@@ -41,12 +41,12 @@
     );
     assert_eq!(
         {
-            let struct_instance = unsafe { std::mem::zeroed::<foo>() };
+            let struct_instance = unsafe { core::mem::zeroed::<foo>() };
             let struct_ptr = &struct_instance as *const foo;
-            let field_ptr = std::ptr::addr_of!(struct_instance.b);
+            let field_ptr = core::ptr::addr_of!(struct_instance.b);
             let struct_address = struct_ptr as usize;
             let field_address = field_ptr as usize;
-            std::mem::forget(struct_instance);
+            core::mem::forget(struct_instance);
             field_address.checked_sub(struct_address).unwrap()
         },
         4usize,
@@ -54,12 +54,12 @@
     );
     assert_eq!(
         {
-            let struct_instance = unsafe { std::mem::zeroed::<foo>() };
+            let struct_instance = unsafe { core::mem::zeroed::<foo>() };
             let struct_ptr = &struct_instance as *const foo;
-            let field_ptr = std::ptr::addr_of!(struct_instance.bar);
+            let field_ptr = core::ptr::addr_of!(struct_instance.bar);
             let struct_address = struct_ptr as usize;
             let field_address = field_ptr as usize;
-            std::mem::forget(struct_instance);
+            core::mem::forget(struct_instance);
             field_address.checked_sub(struct_address).unwrap()
         },
         8usize,

diff --git a/tests/expectations/tests/use-core_1_0.rs b/tests/expectations/tests/use-core_1_0.rs
index c0cb163..6794862 100644
--- a/tests/expectations/tests/use-core_1_0.rs
+++ b/tests/expectations/tests/use-core_1_0.rs

@@ -71,12 +71,12 @@
     );
     assert_eq!(
         {
-            let struct_instance = unsafe { std::mem::zeroed::<foo>() };
+            let struct_instance = unsafe { core::mem::zeroed::<foo>() };
             let struct_ptr = &struct_instance as *const foo;
-            let field_ptr = std::ptr::addr_of!(struct_instance.a);
+            let field_ptr = core::ptr::addr_of!(struct_instance.a);
             let struct_address = struct_ptr as usize;
             let field_address = field_ptr as usize;
-            std::mem::forget(struct_instance);
+            core::mem::forget(struct_instance);
             field_address.checked_sub(struct_address).unwrap()
         },
         0usize,
@@ -84,12 +84,12 @@
     );
     assert_eq!(
         {
-            let struct_instance = unsafe { std::mem::zeroed::<foo>() };
+            let struct_instance = unsafe { core::mem::zeroed::<foo>() };
             let struct_ptr = &struct_instance as *const foo;
-            let field_ptr = std::ptr::addr_of!(struct_instance.b);
+            let field_ptr = core::ptr::addr_of!(struct_instance.b);
             let struct_address = struct_ptr as usize;
             let field_address = field_ptr as usize;
-            std::mem::forget(struct_instance);
+            core::mem::forget(struct_instance);
             field_address.checked_sub(struct_address).unwrap()
         },
         4usize,
@@ -97,12 +97,12 @@
     );
     assert_eq!(
         {
-            let struct_instance = unsafe { std::mem::zeroed::<foo>() };
+            let struct_instance = unsafe { core::mem::zeroed::<foo>() };
             let struct_ptr = &struct_instance as *const foo;
-            let field_ptr = std::ptr::addr_of!(struct_instance.bar);
+            let field_ptr = core::ptr::addr_of!(struct_instance.bar);
             let struct_address = struct_ptr as usize;
             let field_address = field_ptr as usize;
-            std::mem::forget(struct_instance);
+            core::mem::forget(struct_instance);
             field_address.checked_sub(struct_address).unwrap()
         },
         8usize,