1 files changed, 18 insertions, 17 deletions

diff --git a/src/liballoc/alloc.rs b/src/liballoc/alloc.rs
index b0442026866..67927629ed3 100644
--- a/src/liballoc/alloc.rs
+++ b/src/liballoc/alloc.rs
@@ -169,14 +169,14 @@ unsafe impl AllocRef for Global {
         unsafe {
             let size = layout.size();
             if size == 0 {
-                Ok(MemoryBlock::new(layout.dangling(), 0))
+                Ok(MemoryBlock { ptr: layout.dangling(), size: 0 })
             } else {
                 let raw_ptr = match init {
                     AllocInit::Uninitialized => alloc(layout),
                     AllocInit::Zeroed => alloc_zeroed(layout),
                 };
                 let ptr = NonNull::new(raw_ptr).ok_or(AllocErr)?;
-                Ok(MemoryBlock::new(ptr, size))
+                Ok(MemoryBlock { ptr, size })
             }
         }
     }
@@ -197,14 +197,14 @@ unsafe impl AllocRef for Global {
         placement: ReallocPlacement,
         init: AllocInit,
     ) -> Result<MemoryBlock, AllocErr> {
-        let old_size = layout.size();
+        let size = layout.size();
         debug_assert!(
-            new_size >= old_size,
+            new_size >= size,
             "`new_size` must be greater than or equal to `memory.size()`"
         );
 
-        if old_size == new_size {
-            return Ok(MemoryBlock::new(ptr, old_size));
+        if size == new_size {
+            return Ok(MemoryBlock { ptr, size });
         }
 
         match placement {
@@ -215,10 +215,11 @@ unsafe impl AllocRef for Global {
             }
             ReallocPlacement::MayMove => {
                 // `realloc` probably checks for `new_size > old_size` or something similar.
-                intrinsics::assume(new_size > old_size);
+                intrinsics::assume(new_size > size);
                 let ptr = realloc(ptr.as_ptr(), layout, new_size);
-                let mut memory = MemoryBlock::new(NonNull::new(ptr).ok_or(AllocErr)?, new_size);
-                memory.init_offset(init, old_size);
+                let mut memory =
+                    MemoryBlock { ptr: NonNull::new(ptr).ok_or(AllocErr)?, size: new_size };
+                memory.init_offset(init, size);
                 Ok(memory)
             }
         }
@@ -232,27 +233,27 @@ unsafe impl AllocRef for Global {
         new_size: usize,
         placement: ReallocPlacement,
     ) -> Result<MemoryBlock, AllocErr> {
-        let old_size = layout.size();
+        let size = layout.size();
         debug_assert!(
-            new_size <= old_size,
+            new_size <= size,
             "`new_size` must be smaller than or equal to `memory.size()`"
         );
 
-        if old_size == new_size {
-            return Ok(MemoryBlock::new(ptr, old_size));
+        if size == new_size {
+            return Ok(MemoryBlock { ptr, size });
         }
 
         match placement {
             ReallocPlacement::InPlace => Err(AllocErr),
             ReallocPlacement::MayMove if new_size == 0 => {
                 self.dealloc(ptr, layout);
-                Ok(MemoryBlock::new(layout.dangling(), 0))
+                Ok(MemoryBlock { ptr: layout.dangling(), size: 0 })
             }
             ReallocPlacement::MayMove => {
                 // `realloc` probably checks for `new_size < old_size` or something similar.
-                intrinsics::assume(new_size < old_size);
+                intrinsics::assume(new_size < size);
                 let ptr = realloc(ptr.as_ptr(), layout, new_size);
-                Ok(MemoryBlock::new(NonNull::new(ptr).ok_or(AllocErr)?, new_size))
+                Ok(MemoryBlock { ptr: NonNull::new(ptr).ok_or(AllocErr)?, size: new_size })
             }
         }
     }
@@ -266,7 +267,7 @@ unsafe impl AllocRef for Global {
 unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
     let layout = Layout::from_size_align_unchecked(size, align);
     match Global.alloc(layout, AllocInit::Uninitialized) {
-        Ok(memory) => memory.ptr().as_ptr(),
+        Ok(memory) => memory.ptr.as_ptr(),
         Err(_) => handle_alloc_error(layout),
     }
 }