Remove the now-unit-struct AllocErr parameter of oom()

SimonSapin · SimonSapin · commit 157ff8cd0562 · 2018-04-12T22:53:13.000+02:00
diff --git a/src/liballoc/alloc.rs b/src/liballoc/alloc.rs
@@ -136,8 +136,8 @@ unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
         align as *mut u8
     } else {
         let layout = Layout::from_size_align_unchecked(size, align);
-        Global.alloc(layout).unwrap_or_else(|err| {
-            Global.oom(err)
+        Global.alloc(layout).unwrap_or_else(|_| {
+            Global.oom()
         })
     }
 }
@@ -166,7 +166,7 @@ mod tests {
         unsafe {
             let layout = Layout::from_size_align(1024, 1).unwrap();
             let ptr = Global.alloc_zeroed(layout.clone())
-                .unwrap_or_else(|e| Global.oom(e));
+                .unwrap_or_else(|_| Global.oom());
 
             let end = ptr.offset(layout.size() as isize);
             let mut i = ptr;
diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs
@@ -555,7 +555,7 @@ impl<T: ?Sized> Arc<T> {
         let layout = Layout::for_value(&*fake_ptr);
 
         let mem = Global.alloc(layout)
-            .unwrap_or_else(|e| Global.oom(e));
+            .unwrap_or_else(|_| Global.oom());
 
         // Initialize the real ArcInner
         let inner = set_data_ptr(ptr as *mut T, mem) as *mut ArcInner<T>;
diff --git a/src/liballoc/heap.rs b/src/liballoc/heap.rs
@@ -52,8 +52,8 @@ unsafe impl<T> Alloc for T where T: CoreAlloc {
         CoreAlloc::dealloc(self, ptr, layout)
     }
 
-    fn oom(&mut self, err: AllocErr) -> ! {
-        CoreAlloc::oom(self, err)
+    fn oom(&mut self, _: AllocErr) -> ! {
+        CoreAlloc::oom(self)
     }
 
     fn usable_size(&self, layout: &Layout) -> (usize, usize) {
diff --git a/src/liballoc/raw_vec.rs b/src/liballoc/raw_vec.rs
@@ -100,7 +100,7 @@ impl<T, A: Alloc> RawVec<T, A> {
                 };
                 match result {
                     Ok(ptr) => ptr,
-                    Err(err) => a.oom(err),
+                    Err(_) => a.oom(),
                 }
             };
 
@@ -316,7 +316,7 @@ impl<T, A: Alloc> RawVec<T, A> {
                                                  new_layout);
                     match ptr_res {
                         Ok(ptr) => (new_cap, Unique::new_unchecked(ptr as *mut T)),
-                        Err(e) => self.a.oom(e),
+                        Err(_) => self.a.oom(),
                     }
                 }
                 None => {
@@ -325,7 +325,7 @@ impl<T, A: Alloc> RawVec<T, A> {
                     let new_cap = if elem_size > (!0) / 8 { 1 } else { 4 };
                     match self.a.alloc_array::<T>(new_cap) {
                         Ok(ptr) => (new_cap, ptr.into()),
-                        Err(e) => self.a.oom(e),
+                        Err(_) => self.a.oom(),
                     }
                 }
             };
@@ -444,7 +444,7 @@ impl<T, A: Alloc> RawVec<T, A> {
     pub fn reserve_exact(&mut self, used_cap: usize, needed_extra_cap: usize) {
         match self.try_reserve_exact(used_cap, needed_extra_cap) {
             Err(CapacityOverflow) => panic!("capacity overflow"),
-            Err(AllocErr(e)) => self.a.oom(e),
+            Err(AllocErr(_)) => self.a.oom(),
             Ok(()) => { /* yay */ }
          }
      }
@@ -554,7 +554,7 @@ impl<T, A: Alloc> RawVec<T, A> {
     pub fn reserve(&mut self, used_cap: usize, needed_extra_cap: usize) {
         match self.try_reserve(used_cap, needed_extra_cap) {
             Err(CapacityOverflow) => panic!("capacity overflow"),
-            Err(AllocErr(e)) => self.a.oom(e),
+            Err(AllocErr(_)) => self.a.oom(),
             Ok(()) => { /* yay */ }
          }
      }
@@ -669,7 +669,7 @@ impl<T, A: Alloc> RawVec<T, A> {
                                      old_layout,
                                      new_layout) {
                     Ok(p) => self.ptr = Unique::new_unchecked(p as *mut T),
-                    Err(err) => self.a.oom(err),
+                    Err(_) => self.a.oom(),
                 }
             }
             self.cap = amount;
diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs
@@ -668,7 +668,7 @@ impl<T: ?Sized> Rc<T> {
         let layout = Layout::for_value(&*fake_ptr);
 
         let mem = Global.alloc(layout)
-            .unwrap_or_else(|e| Global.oom(e));
+            .unwrap_or_else(|_| Global.oom());
 
         // Initialize the real RcBox
         let inner = set_data_ptr(ptr as *mut T, mem) as *mut RcBox<T>;
diff --git a/src/liballoc_system/lib.rs b/src/liballoc_system/lib.rs
@@ -73,8 +73,8 @@ unsafe impl Alloc for System {
         Alloc::realloc(&mut &*self, ptr, old_layout, new_layout)
     }
 
-    fn oom(&mut self, err: AllocErr) -> ! {
-        Alloc::oom(&mut &*self, err)
+    fn oom(&mut self) -> ! {
+        Alloc::oom(&mut &*self)
     }
 
     #[inline]
@@ -242,15 +242,15 @@ mod platform {
     unsafe impl<'a> Alloc for &'a System {
         alloc_methods_based_on_global_alloc!();
 
-        fn oom(&mut self, err: AllocErr) -> ! {
+        fn oom(&mut self) -> ! {
             use core::fmt::{self, Write};
 
             // Print a message to stderr before aborting to assist with
             // debugging. It is critical that this code does not allocate any
             // memory since we are in an OOM situation. Any errors are ignored
             // while printing since there's nothing we can do about them and we
             // are about to exit anyways.
-            drop(writeln!(Stderr, "fatal runtime error: {}", err));
+            drop(writeln!(Stderr, "fatal runtime error: {}", AllocErr));
             unsafe {
                 ::core::intrinsics::abort();
             }
@@ -459,11 +459,11 @@ mod platform {
             }
         }
 
-        fn oom(&mut self, err: AllocErr) -> ! {
+        fn oom(&mut self) -> ! {
             use core::fmt::{self, Write};
 
             // Same as with unix we ignore all errors here
-            drop(writeln!(Stderr, "fatal runtime error: {}", err));
+            drop(writeln!(Stderr, "fatal runtime error: {}", AllocErr));
             unsafe {
                 ::core::intrinsics::abort();
             }
diff --git a/src/libcore/alloc.rs b/src/libcore/alloc.rs
@@ -572,7 +572,7 @@ pub unsafe trait Alloc {
     /// instead they should return an appropriate error from the
     /// invoked method, and let the client decide whether to invoke
     /// this `oom` method in response.
-    fn oom(&mut self, _: AllocErr) -> ! {
+    fn oom(&mut self) -> ! {
         unsafe { ::intrinsics::abort() }
     }
 
diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs
@@ -784,7 +784,7 @@ impl<K, V, S> HashMap<K, V, S>
     pub fn reserve(&mut self, additional: usize) {
         match self.try_reserve(additional) {
             Err(CollectionAllocErr::CapacityOverflow) => panic!("capacity overflow"),
-            Err(CollectionAllocErr::AllocErr(e)) => Global.oom(e),
+            Err(CollectionAllocErr::AllocErr(_)) => Global.oom(),
             Ok(()) => { /* yay */ }
          }
     }
diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs
@@ -772,7 +772,7 @@ impl<K, V> RawTable<K, V> {
     unsafe fn new_uninitialized(capacity: usize) -> RawTable<K, V> {
         match Self::try_new_uninitialized(capacity) {
             Err(CollectionAllocErr::CapacityOverflow) => panic!("capacity overflow"),
-            Err(CollectionAllocErr::AllocErr(e)) => Global.oom(e),
+            Err(CollectionAllocErr::AllocErr(_)) => Global.oom(),
             Ok(table) => { table }
         }
     }
@@ -811,7 +811,7 @@ impl<K, V> RawTable<K, V> {
     pub fn new(capacity: usize) -> RawTable<K, V> {
         match Self::try_new(capacity) {
             Err(CollectionAllocErr::CapacityOverflow) => panic!("capacity overflow"),
-            Err(CollectionAllocErr::AllocErr(e)) => Global.oom(e),
+            Err(CollectionAllocErr::AllocErr(_)) => Global.oom(),
             Ok(table) => { table }
         }
     }
diff --git a/src/test/run-pass/allocator-alloc-one.rs b/src/test/run-pass/allocator-alloc-one.rs
@@ -14,8 +14,8 @@ use std::heap::{Heap, Alloc};
 
 fn main() {
     unsafe {
-        let ptr = Heap.alloc_one::<i32>().unwrap_or_else(|e| {
-            Heap.oom(e)
+        let ptr = Heap.alloc_one::<i32>().unwrap_or_else(|_| {
+            Heap.oom()
         });
         *ptr.as_ptr() = 4;
         assert_eq!(*ptr.as_ptr(), 4);
diff --git a/src/test/run-pass/realloc-16687.rs b/src/test/run-pass/realloc-16687.rs
@@ -50,7 +50,7 @@ unsafe fn test_triangle() -> bool {
             println!("allocate({:?})", layout);
         }
 
-        let ret = Heap.alloc(layout.clone()).unwrap_or_else(|e| Heap.oom(e));
+        let ret = Heap.alloc(layout.clone()).unwrap_or_else(|_| Heap.oom());
 
         if PRINT {
             println!("allocate({:?}) = {:?}", layout, ret);
@@ -73,7 +73,7 @@ unsafe fn test_triangle() -> bool {
         }
 
         let ret = Heap.realloc(ptr, old.clone(), new.clone())
-            .unwrap_or_else(|e| Heap.oom(e));
+            .unwrap_or_else(|_| Heap.oom());
 
         if PRINT {
             println!("reallocate({:?}, old={:?}, new={:?}) = {:?}",
diff --git a/src/test/run-pass/regions-mock-trans.rs b/src/test/run-pass/regions-mock-trans.rs
@@ -32,7 +32,7 @@ struct Ccx {
 fn alloc<'a>(_bcx : &'a arena) -> &'a Bcx<'a> {
     unsafe {
         let ptr = Heap.alloc(Layout::new::<Bcx>())
-            .unwrap_or_else(|e| Heap.oom(e));
+            .unwrap_or_else(|_| Heap.oom());
         &*(ptr as *const _)
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -52,8 +52,8 @@ unsafe impl<T> Alloc for T where T: CoreAlloc {`
`52`	`52`	`CoreAlloc::dealloc(self, ptr, layout)`
`53`	`53`	`}`
`54`	`54`
`55`		`- fn oom(&mut self, err: AllocErr) -> ! {`
`56`		`- CoreAlloc::oom(self, err)`
	`55`	`+ fn oom(&mut self, _: AllocErr) -> ! {`
	`56`	`+ CoreAlloc::oom(self)`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`fn usable_size(&self, layout: &Layout) -> (usize, usize) {`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ impl<T, A: Alloc> RawVec<T, A> {`
`100`	`100`	`};`
`101`	`101`	`match result {`
`102`	`102`	`Ok(ptr) => ptr,`
`103`		`- Err(err) => a.oom(err),`
	`103`	`+ Err(_) => a.oom(),`
`104`	`104`	`}`
`105`	`105`	`};`
`106`	`106`
`@@ -316,7 +316,7 @@ impl<T, A: Alloc> RawVec<T, A> {`
`316`	`316`	`new_layout);`
`317`	`317`	`match ptr_res {`
`318`	`318`	`Ok(ptr) => (new_cap, Unique::new_unchecked(ptr as *mut T)),`
`319`		`- Err(e) => self.a.oom(e),`
	`319`	`+ Err(_) => self.a.oom(),`
`320`	`320`	`}`
`321`	`321`	`}`
`322`	`322`	`None => {`
`@@ -325,7 +325,7 @@ impl<T, A: Alloc> RawVec<T, A> {`
`325`	`325`	`let new_cap = if elem_size > (!0) / 8 { 1 } else { 4 };`
`326`	`326`	`match self.a.alloc_array::<T>(new_cap) {`
`327`	`327`	`Ok(ptr) => (new_cap, ptr.into()),`
`328`		`- Err(e) => self.a.oom(e),`
	`328`	`+ Err(_) => self.a.oom(),`
`329`	`329`	`}`
`330`	`330`	`}`
`331`	`331`	`};`
`@@ -444,7 +444,7 @@ impl<T, A: Alloc> RawVec<T, A> {`
`444`	`444`	`pub fn reserve_exact(&mut self, used_cap: usize, needed_extra_cap: usize) {`
`445`	`445`	`match self.try_reserve_exact(used_cap, needed_extra_cap) {`
`446`	`446`	`Err(CapacityOverflow) => panic!("capacity overflow"),`
`447`		`- Err(AllocErr(e)) => self.a.oom(e),`
	`447`	`+ Err(AllocErr(_)) => self.a.oom(),`
`448`	`448`	`Ok(()) => { /* yay */ }`
`449`	`449`	`}`
`450`	`450`	`}`
`@@ -554,7 +554,7 @@ impl<T, A: Alloc> RawVec<T, A> {`
`554`	`554`	`pub fn reserve(&mut self, used_cap: usize, needed_extra_cap: usize) {`
`555`	`555`	`match self.try_reserve(used_cap, needed_extra_cap) {`
`556`	`556`	`Err(CapacityOverflow) => panic!("capacity overflow"),`
`557`		`- Err(AllocErr(e)) => self.a.oom(e),`
	`557`	`+ Err(AllocErr(_)) => self.a.oom(),`
`558`	`558`	`Ok(()) => { /* yay */ }`
`559`	`559`	`}`
`560`	`560`	`}`
`@@ -669,7 +669,7 @@ impl<T, A: Alloc> RawVec<T, A> {`
`669`	`669`	`old_layout,`
`670`	`670`	`new_layout) {`
`671`	`671`	`Ok(p) => self.ptr = Unique::new_unchecked(p as *mut T),`
`672`		`- Err(err) => self.a.oom(err),`
	`672`	`+ Err(_) => self.a.oom(),`
`673`	`673`	`}`
`674`	`674`	`}`
`675`	`675`	`self.cap = amount;`
Original file line number	Diff line number	Diff line change
`@@ -572,7 +572,7 @@ pub unsafe trait Alloc {`
`572`	`572`	`/// instead they should return an appropriate error from the`
`573`	`573`	`/// invoked method, and let the client decide whether to invoke`
`574`	`574`	/// this `oom` method in response.
`575`		`- fn oom(&mut self, _: AllocErr) -> ! {`
	`575`	`+ fn oom(&mut self) -> ! {`
`576`	`576`	`unsafe { ::intrinsics::abort() }`
`577`	`577`	`}`
`578`	`578`
Original file line number	Diff line number	Diff line change
`@@ -784,7 +784,7 @@ impl<K, V, S> HashMap<K, V, S>`
`784`	`784`	`pub fn reserve(&mut self, additional: usize) {`
`785`	`785`	`match self.try_reserve(additional) {`
`786`	`786`	`Err(CollectionAllocErr::CapacityOverflow) => panic!("capacity overflow"),`
`787`		`- Err(CollectionAllocErr::AllocErr(e)) => Global.oom(e),`
	`787`	`+ Err(CollectionAllocErr::AllocErr(_)) => Global.oom(),`
`788`	`788`	`Ok(()) => { /* yay */ }`
`789`	`789`	`}`
`790`	`790`	`}`
Original file line number	Diff line number	Diff line change
`@@ -772,7 +772,7 @@ impl<K, V> RawTable<K, V> {`
`772`	`772`	`unsafe fn new_uninitialized(capacity: usize) -> RawTable<K, V> {`
`773`	`773`	`match Self::try_new_uninitialized(capacity) {`
`774`	`774`	`Err(CollectionAllocErr::CapacityOverflow) => panic!("capacity overflow"),`
`775`		`- Err(CollectionAllocErr::AllocErr(e)) => Global.oom(e),`
	`775`	`+ Err(CollectionAllocErr::AllocErr(_)) => Global.oom(),`
`776`	`776`	`Ok(table) => { table }`
`777`	`777`	`}`
`778`	`778`	`}`
`@@ -811,7 +811,7 @@ impl<K, V> RawTable<K, V> {`
`811`	`811`	`pub fn new(capacity: usize) -> RawTable<K, V> {`
`812`	`812`	`match Self::try_new(capacity) {`
`813`	`813`	`Err(CollectionAllocErr::CapacityOverflow) => panic!("capacity overflow"),`
`814`		`- Err(CollectionAllocErr::AllocErr(e)) => Global.oom(e),`
	`814`	`+ Err(CollectionAllocErr::AllocErr(_)) => Global.oom(),`
`815`	`815`	`Ok(table) => { table }`
`816`	`816`	`}`
`817`	`817`	`}`