Update to mem::MaybeUninit and Once::new()

nipunn1313 · nipunn1313 · commit c4efd5063a51 · 2020-02-08T02:31:05.000-08:00
Newest version of rust compiler does not like mem::uninitialized
and ONCE_INIT - prefers these versions.
diff --git a/openssl-sys/src/lib.rs b/openssl-sys/src/lib.rs
@@ -103,7 +103,7 @@ pub fn init() {
     use std::io::{self, Write};
     use std::mem;
     use std::process;
-    use std::sync::{Mutex, MutexGuard, Once, ONCE_INIT};
+    use std::sync::{Mutex, MutexGuard, Once};
 
     static mut MUTEXES: *mut Vec<Mutex<()>> = 0 as *mut Vec<Mutex<()>>;
     static mut GUARDS: *mut Vec<Option<MutexGuard<'static, ()>>> =
@@ -147,7 +147,7 @@ pub fn init() {
         }
     }
 
-    static INIT: Once = ONCE_INIT;
+    static INIT: Once = Once::new();;
 
     INIT.call_once(|| unsafe {
         SSL_library_init();
diff --git a/openssl-sys/src/sha.rs b/openssl-sys/src/sha.rs
@@ -21,8 +21,8 @@ pub struct SHA_CTX {
 extern "C" {
     pub fn SHA1_Init(c: *mut SHA_CTX) -> c_int;
     pub fn SHA1_Update(c: *mut SHA_CTX, data: *const c_void, len: size_t) -> c_int;
-    pub fn SHA1_Final(md: *mut c_uchar, c: *mut SHA_CTX) -> c_int;
-    pub fn SHA1(d: *const c_uchar, n: size_t, md: *mut c_uchar) -> *mut c_uchar;
+    pub fn SHA1_Final(md: *mut [c_uchar; 20], c: *mut SHA_CTX) -> c_int;
+    pub fn SHA1(d: *const c_uchar, n: size_t, md: *mut [c_uchar; 20]) -> *mut [c_uchar; 20];
 }
 
 #[repr(C)]
@@ -39,12 +39,12 @@ pub struct SHA256_CTX {
 extern "C" {
     pub fn SHA224_Init(c: *mut SHA256_CTX) -> c_int;
     pub fn SHA224_Update(c: *mut SHA256_CTX, data: *const c_void, len: size_t) -> c_int;
-    pub fn SHA224_Final(md: *mut c_uchar, c: *mut SHA256_CTX) -> c_int;
-    pub fn SHA224(d: *const c_uchar, n: size_t, md: *mut c_uchar) -> *mut c_uchar;
+    pub fn SHA224_Final(md: *mut [c_uchar; 28], c: *mut SHA256_CTX) -> c_int;
+    pub fn SHA224(d: *const c_uchar, n: size_t, md: *mut [c_uchar; 28]) -> *mut [c_uchar; 28];
     pub fn SHA256_Init(c: *mut SHA256_CTX) -> c_int;
     pub fn SHA256_Update(c: *mut SHA256_CTX, data: *const c_void, len: size_t) -> c_int;
-    pub fn SHA256_Final(md: *mut c_uchar, c: *mut SHA256_CTX) -> c_int;
-    pub fn SHA256(d: *const c_uchar, n: size_t, md: *mut c_uchar) -> *mut c_uchar;
+    pub fn SHA256_Final(md: *mut [c_uchar; 32], c: *mut SHA256_CTX) -> c_int;
+    pub fn SHA256(d: *const c_uchar, n: size_t, md: *mut [c_uchar; 32]) -> *mut [c_uchar; 32];
 }
 
 pub type SHA_LONG64 = u64;
@@ -64,10 +64,10 @@ pub struct SHA512_CTX {
 extern "C" {
     pub fn SHA384_Init(c: *mut SHA512_CTX) -> c_int;
     pub fn SHA384_Update(c: *mut SHA512_CTX, data: *const c_void, len: size_t) -> c_int;
-    pub fn SHA384_Final(md: *mut c_uchar, c: *mut SHA512_CTX) -> c_int;
-    pub fn SHA384(d: *const c_uchar, n: size_t, md: *mut c_uchar) -> *mut c_uchar;
+    pub fn SHA384_Final(md: *mut [c_uchar; 48], c: *mut SHA512_CTX) -> c_int;
+    pub fn SHA384(d: *const c_uchar, n: size_t, md: *mut [c_uchar; 48]) -> *mut [c_uchar; 48];
     pub fn SHA512_Init(c: *mut SHA512_CTX) -> c_int;
     pub fn SHA512_Update(c: *mut SHA512_CTX, data: *const c_void, len: size_t) -> c_int;
-    pub fn SHA512_Final(md: *mut c_uchar, c: *mut SHA512_CTX) -> c_int;
-    pub fn SHA512(d: *const c_uchar, n: size_t, md: *mut c_uchar) -> *mut c_uchar;
+    pub fn SHA512_Final(md: *mut [c_uchar; 64], c: *mut SHA512_CTX) -> c_int;
+    pub fn SHA512(d: *const c_uchar, n: size_t, md: *mut [c_uchar; 64]) -> *mut [c_uchar; 64];
 }
diff --git a/openssl/src/aes.rs b/openssl/src/aes.rs
@@ -78,14 +78,14 @@ impl AesKey {
         unsafe {
             assert!(key.len() <= c_int::max_value() as usize / 8);
 
-            let mut aes_key = mem::uninitialized();
+            let mut aes_key = mem::MaybeUninit::uninit();
             let r = ffi::AES_set_encrypt_key(
                 key.as_ptr() as *const _,
                 key.len() as c_int * 8,
-                &mut aes_key,
+                aes_key.as_mut_ptr(),
             );
             if r == 0 {
-                Ok(AesKey(aes_key))
+                Ok(AesKey(aes_key.assume_init()))
             } else {
                 Err(KeyError(()))
             }
@@ -101,15 +101,15 @@ impl AesKey {
         unsafe {
             assert!(key.len() <= c_int::max_value() as usize / 8);
 
-            let mut aes_key = mem::uninitialized();
+            let mut aes_key = mem::MaybeUninit::uninit();
             let r = ffi::AES_set_decrypt_key(
                 key.as_ptr() as *const _,
                 key.len() as c_int * 8,
-                &mut aes_key,
+                aes_key.as_mut_ptr(),
             );
 
             if r == 0 {
-                Ok(AesKey(aes_key))
+                Ok(AesKey(aes_key.assume_init()))
             } else {
                 Err(KeyError(()))
             }
diff --git a/openssl/src/sha.rs b/openssl/src/sha.rs
@@ -58,49 +58,49 @@ use std::mem;
 #[inline]
 pub fn sha1(data: &[u8]) -> [u8; 20] {
     unsafe {
-        let mut hash: [u8; 20] = mem::uninitialized();
+        let mut hash: mem::MaybeUninit<[u8; 20]> = mem::MaybeUninit::uninit();
         ffi::SHA1(data.as_ptr(), data.len(), hash.as_mut_ptr());
-        hash
+        hash.assume_init()
     }
 }
 
 /// Computes the SHA224 hash of some data.
 #[inline]
 pub fn sha224(data: &[u8]) -> [u8; 28] {
     unsafe {
-        let mut hash: [u8; 28] = mem::uninitialized();
+        let mut hash: mem::MaybeUninit<[u8; 28]> = mem::MaybeUninit::uninit();
         ffi::SHA224(data.as_ptr(), data.len(), hash.as_mut_ptr());
-        hash
+        hash.assume_init()
     }
 }
 
 /// Computes the SHA256 hash of some data.
 #[inline]
 pub fn sha256(data: &[u8]) -> [u8; 32] {
     unsafe {
-        let mut hash: [u8; 32] = mem::uninitialized();
+        let mut hash: mem::MaybeUninit<[u8; 32]> = mem::MaybeUninit::uninit();
         ffi::SHA256(data.as_ptr(), data.len(), hash.as_mut_ptr());
-        hash
+        hash.assume_init()
     }
 }
 
 /// Computes the SHA384 hash of some data.
 #[inline]
 pub fn sha384(data: &[u8]) -> [u8; 48] {
     unsafe {
-        let mut hash: [u8; 48] = mem::uninitialized();
+        let mut hash: mem::MaybeUninit<[u8; 48]> = mem::MaybeUninit::uninit();
         ffi::SHA384(data.as_ptr(), data.len(), hash.as_mut_ptr());
-        hash
+        hash.assume_init()
     }
 }
 
 /// Computes the SHA512 hash of some data.
 #[inline]
 pub fn sha512(data: &[u8]) -> [u8; 64] {
     unsafe {
-        let mut hash: [u8; 64] = mem::uninitialized();
+        let mut hash: mem::MaybeUninit<[u8; 64]> = mem::MaybeUninit::uninit();
         ffi::SHA512(data.as_ptr(), data.len(), hash.as_mut_ptr());
-        hash
+        hash.assume_init()
     }
 }
 
@@ -118,9 +118,9 @@ impl Sha1 {
     #[inline]
     pub fn new() -> Sha1 {
         unsafe {
-            let mut ctx = mem::uninitialized();
-            ffi::SHA1_Init(&mut ctx);
-            Sha1(ctx)
+            let mut ctx: mem::MaybeUninit<ffi::SHA_CTX> = mem::MaybeUninit::uninit();
+            ffi::SHA1_Init(ctx.as_mut_ptr());
+            Sha1(ctx.assume_init())
         }
     }
 
@@ -138,9 +138,9 @@ impl Sha1 {
     #[inline]
     pub fn finish(mut self) -> [u8; 20] {
         unsafe {
-            let mut hash: [u8; 20] = mem::uninitialized();
+            let mut hash: mem::MaybeUninit<[u8; 20]> = mem::MaybeUninit::uninit();
             ffi::SHA1_Final(hash.as_mut_ptr(), &mut self.0);
-            hash
+            hash.assume_init()
         }
     }
 }
@@ -154,9 +154,9 @@ impl Sha224 {
     #[inline]
     pub fn new() -> Sha224 {
         unsafe {
-            let mut ctx = mem::uninitialized();
-            ffi::SHA224_Init(&mut ctx);
-            Sha224(ctx)
+            let mut ctx: mem::MaybeUninit<ffi::SHA256_CTX> = mem::MaybeUninit::uninit();
+            ffi::SHA224_Init(ctx.as_mut_ptr());
+            Sha224(ctx.assume_init())
         }
     }
 
@@ -174,9 +174,9 @@ impl Sha224 {
     #[inline]
     pub fn finish(mut self) -> [u8; 28] {
         unsafe {
-            let mut hash: [u8; 28] = mem::uninitialized();
+            let mut hash: mem::MaybeUninit<[u8; 28]> = mem::MaybeUninit::uninit();
             ffi::SHA224_Final(hash.as_mut_ptr(), &mut self.0);
-            hash
+            hash.assume_init()
         }
     }
 }
@@ -190,9 +190,9 @@ impl Sha256 {
     #[inline]
     pub fn new() -> Sha256 {
         unsafe {
-            let mut ctx = mem::uninitialized();
-            ffi::SHA256_Init(&mut ctx);
-            Sha256(ctx)
+            let mut ctx: mem::MaybeUninit<ffi::SHA256_CTX> = mem::MaybeUninit::uninit();
+            ffi::SHA256_Init(ctx.as_mut_ptr());
+            Sha256(ctx.assume_init())
         }
     }
 
@@ -210,9 +210,9 @@ impl Sha256 {
     #[inline]
     pub fn finish(mut self) -> [u8; 32] {
         unsafe {
-            let mut hash: [u8; 32] = mem::uninitialized();
+            let mut hash: mem::MaybeUninit<[u8; 32]> = mem::MaybeUninit::uninit();
             ffi::SHA256_Final(hash.as_mut_ptr(), &mut self.0);
-            hash
+            hash.assume_init()
         }
     }
 }
@@ -226,9 +226,9 @@ impl Sha384 {
     #[inline]
     pub fn new() -> Sha384 {
         unsafe {
-            let mut ctx = mem::uninitialized();
-            ffi::SHA384_Init(&mut ctx);
-            Sha384(ctx)
+            let mut ctx: mem::MaybeUninit<ffi::SHA512_CTX> = mem::MaybeUninit::uninit();
+            ffi::SHA384_Init(ctx.as_mut_ptr());
+            Sha384(ctx.assume_init())
         }
     }
 
@@ -246,9 +246,9 @@ impl Sha384 {
     #[inline]
     pub fn finish(mut self) -> [u8; 48] {
         unsafe {
-            let mut hash: [u8; 48] = mem::uninitialized();
+            let mut hash: mem::MaybeUninit<[u8; 48]> = mem::MaybeUninit::uninit();
             ffi::SHA384_Final(hash.as_mut_ptr(), &mut self.0);
-            hash
+            hash.assume_init()
         }
     }
 }
@@ -262,9 +262,9 @@ impl Sha512 {
     #[inline]
     pub fn new() -> Sha512 {
         unsafe {
-            let mut ctx = mem::uninitialized();
-            ffi::SHA512_Init(&mut ctx);
-            Sha512(ctx)
+            let mut ctx: mem::MaybeUninit<ffi::SHA512_CTX> = mem::MaybeUninit::uninit();
+            ffi::SHA512_Init(ctx.as_mut_ptr());
+            Sha512(ctx.assume_init())
         }
     }
 
@@ -282,9 +282,9 @@ impl Sha512 {
     #[inline]
     pub fn finish(mut self) -> [u8; 64] {
         unsafe {
-            let mut hash: [u8; 64] = mem::uninitialized();
+            let mut hash: mem::MaybeUninit<[u8; 64]> = mem::MaybeUninit::uninit();
             ffi::SHA512_Final(hash.as_mut_ptr(), &mut self.0);
-            hash
+            hash.assume_init()
         }
     }
 }
diff --git a/openssl/src/ssl/mod.rs b/openssl/src/ssl/mod.rs
@@ -3928,11 +3928,11 @@ cfg_if! {
             )
         }
     } else {
-        use std::sync::{Once, ONCE_INIT};
+        use std::sync::Once;
 
         unsafe fn get_new_idx(f: ffi::CRYPTO_EX_free) -> c_int {
             // hack around https://rt.openssl.org/Ticket/Display.html?id=3710&user=guest&pass=guest
-            static ONCE: Once = ONCE_INIT;
+            static ONCE: Once = Once::new();
             ONCE.call_once(|| {
                 ffi::SSL_CTX_get_ex_new_index(0, ptr::null_mut(), None, None, None);
             });
@@ -3942,7 +3942,7 @@ cfg_if! {
 
         unsafe fn get_new_ssl_idx(f: ffi::CRYPTO_EX_free) -> c_int {
             // hack around https://rt.openssl.org/Ticket/Display.html?id=3710&user=guest&pass=guest
-            static ONCE: Once = ONCE_INIT;
+            static ONCE: Once = Once::new();
             ONCE.call_once(|| {
                 ffi::SSL_get_ex_new_index(0, ptr::null_mut(), None, None, None);
             });

Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ pub fn init() {`
`103`	`103`	`use std::io::{self, Write};`
`104`	`104`	`use std::mem;`
`105`	`105`	`use std::process;`
`106`		`- use std::sync::{Mutex, MutexGuard, Once, ONCE_INIT};`
	`106`	`+ use std::sync::{Mutex, MutexGuard, Once};`
`107`	`107`
`108`	`108`	`static mut MUTEXES: mut Vec<Mutex<()>> = 0 as mut Vec<Mutex<()>>;`
`109`	`109`	`static mut GUARDS: *mut Vec<Option<MutexGuard<'static, ()>>> =`
`@@ -147,7 +147,7 @@ pub fn init() {`
`147`	`147`	`}`
`148`	`148`	`}`
`149`	`149`
`150`		`- static INIT: Once = ONCE_INIT;`
	`150`	`+ static INIT: Once = Once::new();;`
`151`	`151`
`152`	`152`	`INIT.call_once(\|\| unsafe {`
`153`	`153`	`SSL_library_init();`
Original file line number	Diff line number	Diff line change
`@@ -58,49 +58,49 @@ use std::mem;`
`58`	`58`	`#[inline]`
`59`	`59`	`pub fn sha1(data: &[u8]) -> [u8; 20] {`
`60`	`60`	`unsafe {`
`61`		`- let mut hash: [u8; 20] = mem::uninitialized();`
	`61`	`+ let mut hash: mem::MaybeUninit<[u8; 20]> = mem::MaybeUninit::uninit();`
`62`	`62`	`ffi::SHA1(data.as_ptr(), data.len(), hash.as_mut_ptr());`
`63`		`- hash`
	`63`	`+ hash.assume_init()`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`/// Computes the SHA224 hash of some data.`
`68`	`68`	`#[inline]`
`69`	`69`	`pub fn sha224(data: &[u8]) -> [u8; 28] {`
`70`	`70`	`unsafe {`
`71`		`- let mut hash: [u8; 28] = mem::uninitialized();`
	`71`	`+ let mut hash: mem::MaybeUninit<[u8; 28]> = mem::MaybeUninit::uninit();`
`72`	`72`	`ffi::SHA224(data.as_ptr(), data.len(), hash.as_mut_ptr());`
`73`		`- hash`
	`73`	`+ hash.assume_init()`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`/// Computes the SHA256 hash of some data.`
`78`	`78`	`#[inline]`
`79`	`79`	`pub fn sha256(data: &[u8]) -> [u8; 32] {`
`80`	`80`	`unsafe {`
`81`		`- let mut hash: [u8; 32] = mem::uninitialized();`
	`81`	`+ let mut hash: mem::MaybeUninit<[u8; 32]> = mem::MaybeUninit::uninit();`
`82`	`82`	`ffi::SHA256(data.as_ptr(), data.len(), hash.as_mut_ptr());`
`83`		`- hash`
	`83`	`+ hash.assume_init()`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`/// Computes the SHA384 hash of some data.`
`88`	`88`	`#[inline]`
`89`	`89`	`pub fn sha384(data: &[u8]) -> [u8; 48] {`
`90`	`90`	`unsafe {`
`91`		`- let mut hash: [u8; 48] = mem::uninitialized();`
	`91`	`+ let mut hash: mem::MaybeUninit<[u8; 48]> = mem::MaybeUninit::uninit();`
`92`	`92`	`ffi::SHA384(data.as_ptr(), data.len(), hash.as_mut_ptr());`
`93`		`- hash`
	`93`	`+ hash.assume_init()`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`/// Computes the SHA512 hash of some data.`
`98`	`98`	`#[inline]`
`99`	`99`	`pub fn sha512(data: &[u8]) -> [u8; 64] {`
`100`	`100`	`unsafe {`
`101`		`- let mut hash: [u8; 64] = mem::uninitialized();`
	`101`	`+ let mut hash: mem::MaybeUninit<[u8; 64]> = mem::MaybeUninit::uninit();`
`102`	`102`	`ffi::SHA512(data.as_ptr(), data.len(), hash.as_mut_ptr());`
`103`		`- hash`
	`103`	`+ hash.assume_init()`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`
`@@ -118,9 +118,9 @@ impl Sha1 {`
`118`	`118`	`#[inline]`
`119`	`119`	`pub fn new() -> Sha1 {`
`120`	`120`	`unsafe {`
`121`		`- let mut ctx = mem::uninitialized();`
`122`		`- ffi::SHA1_Init(&mut ctx);`
`123`		`- Sha1(ctx)`
	`121`	`+ let mut ctx: mem::MaybeUninit<ffi::SHA_CTX> = mem::MaybeUninit::uninit();`
	`122`	`+ ffi::SHA1_Init(ctx.as_mut_ptr());`
	`123`	`+ Sha1(ctx.assume_init())`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`
`@@ -138,9 +138,9 @@ impl Sha1 {`
`138`	`138`	`#[inline]`
`139`	`139`	`pub fn finish(mut self) -> [u8; 20] {`
`140`	`140`	`unsafe {`
`141`		`- let mut hash: [u8; 20] = mem::uninitialized();`
	`141`	`+ let mut hash: mem::MaybeUninit<[u8; 20]> = mem::MaybeUninit::uninit();`
`142`	`142`	`ffi::SHA1_Final(hash.as_mut_ptr(), &mut self.0);`
`143`		`- hash`
	`143`	`+ hash.assume_init()`
`144`	`144`	`}`
`145`	`145`	`}`
`146`	`146`	`}`
`@@ -154,9 +154,9 @@ impl Sha224 {`
`154`	`154`	`#[inline]`
`155`	`155`	`pub fn new() -> Sha224 {`
`156`	`156`	`unsafe {`
`157`		`- let mut ctx = mem::uninitialized();`
`158`		`- ffi::SHA224_Init(&mut ctx);`
`159`		`- Sha224(ctx)`
	`157`	`+ let mut ctx: mem::MaybeUninit<ffi::SHA256_CTX> = mem::MaybeUninit::uninit();`
	`158`	`+ ffi::SHA224_Init(ctx.as_mut_ptr());`
	`159`	`+ Sha224(ctx.assume_init())`
`160`	`160`	`}`
`161`	`161`	`}`
`162`	`162`
`@@ -174,9 +174,9 @@ impl Sha224 {`
`174`	`174`	`#[inline]`
`175`	`175`	`pub fn finish(mut self) -> [u8; 28] {`
`176`	`176`	`unsafe {`
`177`		`- let mut hash: [u8; 28] = mem::uninitialized();`
	`177`	`+ let mut hash: mem::MaybeUninit<[u8; 28]> = mem::MaybeUninit::uninit();`
`178`	`178`	`ffi::SHA224_Final(hash.as_mut_ptr(), &mut self.0);`
`179`		`- hash`
	`179`	`+ hash.assume_init()`
`180`	`180`	`}`
`181`	`181`	`}`
`182`	`182`	`}`
`@@ -190,9 +190,9 @@ impl Sha256 {`
`190`	`190`	`#[inline]`
`191`	`191`	`pub fn new() -> Sha256 {`
`192`	`192`	`unsafe {`
`193`		`- let mut ctx = mem::uninitialized();`
`194`		`- ffi::SHA256_Init(&mut ctx);`
`195`		`- Sha256(ctx)`
	`193`	`+ let mut ctx: mem::MaybeUninit<ffi::SHA256_CTX> = mem::MaybeUninit::uninit();`
	`194`	`+ ffi::SHA256_Init(ctx.as_mut_ptr());`
	`195`	`+ Sha256(ctx.assume_init())`
`196`	`196`	`}`
`197`	`197`	`}`
`198`	`198`
`@@ -210,9 +210,9 @@ impl Sha256 {`
`210`	`210`	`#[inline]`
`211`	`211`	`pub fn finish(mut self) -> [u8; 32] {`
`212`	`212`	`unsafe {`
`213`		`- let mut hash: [u8; 32] = mem::uninitialized();`
	`213`	`+ let mut hash: mem::MaybeUninit<[u8; 32]> = mem::MaybeUninit::uninit();`
`214`	`214`	`ffi::SHA256_Final(hash.as_mut_ptr(), &mut self.0);`
`215`		`- hash`
	`215`	`+ hash.assume_init()`
`216`	`216`	`}`
`217`	`217`	`}`
`218`	`218`	`}`
`@@ -226,9 +226,9 @@ impl Sha384 {`
`226`	`226`	`#[inline]`
`227`	`227`	`pub fn new() -> Sha384 {`
`228`	`228`	`unsafe {`
`229`		`- let mut ctx = mem::uninitialized();`
`230`		`- ffi::SHA384_Init(&mut ctx);`
`231`		`- Sha384(ctx)`
	`229`	`+ let mut ctx: mem::MaybeUninit<ffi::SHA512_CTX> = mem::MaybeUninit::uninit();`
	`230`	`+ ffi::SHA384_Init(ctx.as_mut_ptr());`
	`231`	`+ Sha384(ctx.assume_init())`
`232`	`232`	`}`
`233`	`233`	`}`
`234`	`234`
`@@ -246,9 +246,9 @@ impl Sha384 {`
`246`	`246`	`#[inline]`
`247`	`247`	`pub fn finish(mut self) -> [u8; 48] {`
`248`	`248`	`unsafe {`
`249`		`- let mut hash: [u8; 48] = mem::uninitialized();`
	`249`	`+ let mut hash: mem::MaybeUninit<[u8; 48]> = mem::MaybeUninit::uninit();`
`250`	`250`	`ffi::SHA384_Final(hash.as_mut_ptr(), &mut self.0);`
`251`		`- hash`
	`251`	`+ hash.assume_init()`
`252`	`252`	`}`
`253`	`253`	`}`
`254`	`254`	`}`
`@@ -262,9 +262,9 @@ impl Sha512 {`
`262`	`262`	`#[inline]`
`263`	`263`	`pub fn new() -> Sha512 {`
`264`	`264`	`unsafe {`
`265`		`- let mut ctx = mem::uninitialized();`
`266`		`- ffi::SHA512_Init(&mut ctx);`
`267`		`- Sha512(ctx)`
	`265`	`+ let mut ctx: mem::MaybeUninit<ffi::SHA512_CTX> = mem::MaybeUninit::uninit();`
	`266`	`+ ffi::SHA512_Init(ctx.as_mut_ptr());`
	`267`	`+ Sha512(ctx.assume_init())`
`268`	`268`	`}`
`269`	`269`	`}`
`270`	`270`
`@@ -282,9 +282,9 @@ impl Sha512 {`
`282`	`282`	`#[inline]`
`283`	`283`	`pub fn finish(mut self) -> [u8; 64] {`
`284`	`284`	`unsafe {`
`285`		`- let mut hash: [u8; 64] = mem::uninitialized();`
	`285`	`+ let mut hash: mem::MaybeUninit<[u8; 64]> = mem::MaybeUninit::uninit();`
`286`	`286`	`ffi::SHA512_Final(hash.as_mut_ptr(), &mut self.0);`
`287`		`- hash`
	`287`	`+ hash.assume_init()`
`288`	`288`	`}`
`289`	`289`	`}`
`290`	`290`	`}`