Make fields in `MemoryBlock` public

7 files changed, 29 insertions, 28 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),
     }
 }
diff --git a/src/liballoc/alloc/tests.rs b/src/liballoc/alloc/tests.rs
index 7fa71f72ee7..1ad40eca93b 100644
--- a/src/liballoc/alloc/tests.rs
+++ b/src/liballoc/alloc/tests.rs
@@ -12,13 +12,13 @@ fn allocate_zeroed() {
             .alloc(layout.clone(), AllocInit::Zeroed)
             .unwrap_or_else(|_| handle_alloc_error(layout));
 
-        let mut i = memory.ptr().cast::<u8>().as_ptr();
+        let mut i = memory.ptr.cast::<u8>().as_ptr();
         let end = i.add(layout.size());
         while i < end {
             assert_eq!(*i, 0);
             i = i.offset(1);
         }
-        Global.dealloc(memory.ptr(), layout);
+        Global.dealloc(memory.ptr, layout);
     }
 }
 
diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs
index 03d759e4a9a..5406956a528 100644
--- a/src/liballoc/boxed.rs
+++ b/src/liballoc/boxed.rs
@@ -198,7 +198,7 @@ impl<T> Box<T> {
         let ptr = Global
             .alloc(layout, AllocInit::Uninitialized)
             .unwrap_or_else(|_| alloc::handle_alloc_error(layout))
-            .ptr()
+            .ptr
             .cast();
         unsafe { Box::from_raw(ptr.as_ptr()) }
     }
@@ -227,7 +227,7 @@ impl<T> Box<T> {
         let ptr = Global
             .alloc(layout, AllocInit::Zeroed)
             .unwrap_or_else(|_| alloc::handle_alloc_error(layout))
-            .ptr()
+            .ptr
             .cast();
         unsafe { Box::from_raw(ptr.as_ptr()) }
     }
diff --git a/src/liballoc/raw_vec.rs b/src/liballoc/raw_vec.rs
index a1f9a9291af..590e82357fb 100644
--- a/src/liballoc/raw_vec.rs
+++ b/src/liballoc/raw_vec.rs
@@ -152,8 +152,8 @@ impl<T, A: AllocRef> RawVec<T, A> {
 
             let memory = alloc.alloc(layout, init).unwrap_or_else(|_| handle_alloc_error(layout));
             Self {
-                ptr: memory.ptr().cast().into(),
-                cap: Self::capacity_from_bytes(memory.size()),
+                ptr: memory.ptr.cast().into(),
+                cap: Self::capacity_from_bytes(memory.size),
                 alloc,
             }
         }
@@ -470,8 +470,8 @@ impl<T, A: AllocRef> RawVec<T, A> {
     }
 
     fn set_memory(&mut self, memory: MemoryBlock) {
-        self.ptr = memory.ptr().cast().into();
-        self.cap = Self::capacity_from_bytes(memory.size());
+        self.ptr = memory.ptr.cast().into();
+        self.cap = Self::capacity_from_bytes(memory.size);
     }
 
     /// Single method to handle all possibilities of growing the buffer.
diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs
index ab344be12de..6a78a7398a6 100644
--- a/src/liballoc/rc.rs
+++ b/src/liballoc/rc.rs
@@ -941,7 +941,7 @@ impl<T: ?Sized> Rc<T> {
             .unwrap_or_else(|_| handle_alloc_error(layout));
 
         // Initialize the RcBox
-        let inner = mem_to_rcbox(mem.ptr().as_ptr());
+        let inner = mem_to_rcbox(mem.ptr.as_ptr());
         debug_assert_eq!(Layout::for_value(&*inner), layout);
 
         ptr::write(&mut (*inner).strong, Cell::new(1));
diff --git a/src/liballoc/sync.rs b/src/liballoc/sync.rs
index 1adc7fa3040..111a7651b5e 100644
--- a/src/liballoc/sync.rs
+++ b/src/liballoc/sync.rs
@@ -819,7 +819,7 @@ impl<T: ?Sized> Arc<T> {
             .unwrap_or_else(|_| handle_alloc_error(layout));
 
         // Initialize the ArcInner
-        let inner = mem_to_arcinner(mem.ptr().as_ptr());
+        let inner = mem_to_arcinner(mem.ptr.as_ptr());
         debug_assert_eq!(Layout::for_value(&*inner), layout);
 
         ptr::write(&mut (*inner).strong, atomic::AtomicUsize::new(1));
diff --git a/src/liballoc/tests/heap.rs b/src/liballoc/tests/heap.rs
index 709e8c148d5..62f062b83d7 100644
--- a/src/liballoc/tests/heap.rs
+++ b/src/liballoc/tests/heap.rs
@@ -26,7 +26,7 @@ fn check_overalign_requests<T: AllocRef>(mut allocator: T) {
                                 AllocInit::Uninitialized,
                             )
                             .unwrap()
-                            .ptr()
+                            .ptr
                     })
                     .collect();
                 for &ptr in &pointers {