From 422113a49188f6c4e1e625f6efbe78da87441f09 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 5 Aug 2020 13:38:15 +0200
Subject: [PATCH] rustup

---
 rust-version                     |  2 +-
 tests/run-pass/heap_allocator.rs | 19 ++++++++++---------
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/rust-version b/rust-version
index 807d4e85591..4fb52f22fa0 100644
--- a/rust-version
+++ b/rust-version
@@ -1 +1 @@
-dbc2ef25fb5e15445de38f19ba75547a6cf35cae
+1d69e3b1d753951bc7df0f02d6fd4719065d98c3
diff --git a/tests/run-pass/heap_allocator.rs b/tests/run-pass/heap_allocator.rs
index c2fcfea58cd..557550d6f43 100644
--- a/tests/run-pass/heap_allocator.rs
+++ b/tests/run-pass/heap_allocator.rs
@@ -1,7 +1,7 @@
-#![feature(allocator_api)]
+#![feature(allocator_api, slice_ptr_get)]
 
 use std::ptr::NonNull;
-use std::alloc::{Global, AllocRef, Layout, System, AllocInit, ReallocPlacement};
+use std::alloc::{Global, AllocRef, Layout, System};
 use std::slice;
 
 fn check_alloc<T: AllocRef>(mut allocator: T) { unsafe {
@@ -9,29 +9,30 @@ fn check_alloc<T: AllocRef>(mut allocator: T) { unsafe {
         let layout = Layout::from_size_align(20, align).unwrap();
 
         for _ in 0..32 {
-            let a = allocator.alloc(layout, AllocInit::Uninitialized).unwrap().ptr;
+            let a = allocator.alloc(layout).unwrap().as_non_null_ptr();
             assert_eq!(a.as_ptr() as usize % align, 0, "pointer is incorrectly aligned");
             allocator.dealloc(a, layout);
         }
 
-        let p1 = allocator.alloc(layout, AllocInit::Zeroed).unwrap().ptr;
+        let p1 = allocator.alloc_zeroed(layout).unwrap().as_non_null_ptr();
         assert_eq!(p1.as_ptr() as usize % align, 0, "pointer is incorrectly aligned");
+        assert_eq!(*p1.as_ptr(), 0);
 
         // old size < new size
-        let p2 = allocator.grow(p1, layout, 40, ReallocPlacement::MayMove, AllocInit::Uninitialized).unwrap().ptr;
+        let p2 = allocator.grow(p1, layout, 40).unwrap().as_non_null_ptr();
         let layout = Layout::from_size_align(40, align).unwrap();
         assert_eq!(p2.as_ptr() as usize % align, 0, "pointer is incorrectly aligned");
         let slice = slice::from_raw_parts(p2.as_ptr(), 20);
         assert_eq!(&slice, &[0_u8; 20]);
 
         // old size == new size
-        let p3 = allocator.grow(p2, layout, 40, ReallocPlacement::MayMove, AllocInit::Uninitialized).unwrap().ptr;
+        let p3 = allocator.grow(p2, layout, 40).unwrap().as_non_null_ptr();
         assert_eq!(p3.as_ptr() as usize % align, 0, "pointer is incorrectly aligned");
         let slice = slice::from_raw_parts(p3.as_ptr(), 20);
         assert_eq!(&slice, &[0_u8; 20]);
 
         // old size > new size
-        let p4 = allocator.shrink(p3, layout, 10, ReallocPlacement::MayMove).unwrap().ptr;
+        let p4 = allocator.shrink(p3, layout, 10).unwrap().as_non_null_ptr();
         let layout = Layout::from_size_align(10, align).unwrap();
         assert_eq!(p4.as_ptr() as usize % align, 0, "pointer is incorrectly aligned");
         let slice = slice::from_raw_parts(p4.as_ptr(), 10);
@@ -47,7 +48,7 @@ fn check_align_requests<T: AllocRef>(mut allocator: T) {
             let iterations = 32;
             unsafe {
                 let pointers: Vec<_> = (0..iterations).map(|_| {
-                    allocator.alloc(Layout::from_size_align(size, align).unwrap(), AllocInit::Uninitialized).unwrap().ptr
+                    allocator.alloc(Layout::from_size_align(size, align).unwrap()).unwrap().as_non_null_ptr()
                 }).collect();
                 for &ptr in &pointers {
                     assert_eq!((ptr.as_ptr() as usize) % align, 0,
@@ -68,7 +69,7 @@ fn global_to_box() {
     let l = Layout::new::<T>();
     // allocate manually with global allocator, then turn into Box and free there
     unsafe {
-        let ptr = Global.alloc(l, AllocInit::Uninitialized).unwrap().ptr.as_ptr() as *mut T;
+        let ptr = Global.alloc(l).unwrap().as_non_null_ptr().as_ptr() as *mut T;
         let b = Box::from_raw(ptr);
         drop(b);
     }