[experiment] use unreachable_unchecked() everywhere

Author: ljedrz

src/liballoc/borrow.rs

@@ -208,7 +208,7 @@ impl<'a, B: ?Sized> Cow<'a, B>
             Borrowed(borrowed) => {
                 *self = Owned(borrowed.to_owned());
                 match *self {
-                    Borrowed(..) => unreachable!(),
+                    Borrowed(..) => unsafe { ::core::hint::unreachable_unchecked() },
                     Owned(ref mut owned) => owned,
                 }
             }

src/liballoc/collections/btree/map.rs

@@ -164,7 +164,7 @@ impl<K: Clone, V: Clone> Clone for BTreeMap<K, V> {
                     {
                         let mut out_node = match out_tree.root.as_mut().force() {
                             Leaf(leaf) => leaf,
-                            Internal(_) => unreachable!(),
+                            Internal(_) => unsafe { ::core::hint::unreachable_unchecked() },
                         };
 
                         let mut in_edge = leaf.first_edge();
@@ -979,7 +979,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
                 // We need to steal.
                 let mut last_kv = match last_edge.left_kv() {
                     Ok(left) => left,
-                    Err(_) => unreachable!(),
+                    Err(_) => unsafe { ::core::hint::unreachable_unchecked() },
                 };
                 last_kv.bulk_steal_left(node::MIN_LEN - right_child_len);
                 last_edge = last_kv.right_edge();
@@ -1057,7 +1057,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
                         break;
                     }
                     _ => {
-                        unreachable!();
+                        unsafe { ::core::hint::unreachable_unchecked() };
                     }
                 }
             }
@@ -2508,7 +2508,7 @@ impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
         while cur_node.len() < node::CAPACITY / 2 {
             match handle_underfull_node(cur_node) {
                 AtRoot => break,
-                EmptyParent(_) => unreachable!(),
+                EmptyParent(_) => unsafe { ::core::hint::unreachable_unchecked() },
                 Merged(parent) => {
                     if parent.len() == 0 {
                         // We must be at the root

src/liballoc/collections/btree/node.rs

@@ -1425,7 +1425,7 @@ impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::
                     move_edges(left, new_left_len + 1, right, 0, count);
                 },
                 (ForceResult::Leaf(_), ForceResult::Leaf(_)) => { }
-                _ => { unreachable!(); }
+                _ => { ::core::hint::unreachable_unchecked(); }
             }
         }
     }
@@ -1486,7 +1486,7 @@ impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::
                     right.correct_childrens_parent_links(0, new_right_len + 1);
                 },
                 (ForceResult::Leaf(_), ForceResult::Leaf(_)) => { }
-                _ => { unreachable!(); }
+                _ => { ::core::hint::unreachable_unchecked(); }
             }
         }
     }
@@ -1571,7 +1571,7 @@ impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal>, ma
                     move_edges(left, left_new_len + 1, right, 1, right_new_len);
                 },
                 (ForceResult::Leaf(_), ForceResult::Leaf(_)) => { }
-                _ => { unreachable!(); }
+                _ => { ::core::hint::unreachable_unchecked(); }
             }
         }
     }

src/liballoc/raw_vec.rs

@@ -421,7 +421,7 @@ impl<T, A: Alloc> RawVec<T, A> {
     pub fn reserve_exact(&mut self, used_cap: usize, needed_extra_cap: usize) {
         match self.reserve_internal(used_cap, needed_extra_cap, Infallible, Exact) {
             Err(CapacityOverflow) => capacity_overflow(),
-            Err(AllocErr) => unreachable!(),
+            Err(AllocErr) => unsafe { ::core::hint::unreachable_unchecked() },
             Ok(()) => { /* yay */ }
          }
      }
@@ -501,7 +501,7 @@ impl<T, A: Alloc> RawVec<T, A> {
     pub fn reserve(&mut self, used_cap: usize, needed_extra_cap: usize) {
         match self.reserve_internal(used_cap, needed_extra_cap, Infallible, Amortized) {
             Err(CapacityOverflow) => capacity_overflow(),
-            Err(AllocErr) => unreachable!(),
+            Err(AllocErr) => unsafe { ::core::hint::unreachable_unchecked() },
             Ok(()) => { /* yay */ }
         }
     }

src/liballoc/tests/btree/map.rs

@@ -368,7 +368,7 @@ fn test_entry() {
 
     // Existing key (insert)
     match map.entry(1) {
-        Vacant(_) => unreachable!(),
+        Vacant(_) => unsafe { ::core::hint::unreachable_unchecked() },
         Occupied(mut view) => {
             assert_eq!(view.get(), &10);
             assert_eq!(view.insert(100), 10);
@@ -380,7 +380,7 @@ fn test_entry() {
 
     // Existing key (update)
     match map.entry(2) {
-        Vacant(_) => unreachable!(),
+        Vacant(_) => unsafe { ::core::hint::unreachable_unchecked() },
         Occupied(mut view) => {
             let v = view.get_mut();
             *v *= 10;
@@ -391,7 +391,7 @@ fn test_entry() {
 
     // Existing key (take)
     match map.entry(3) {
-        Vacant(_) => unreachable!(),
+        Vacant(_) => unsafe { ::core::hint::unreachable_unchecked() },
         Occupied(view) => {
             assert_eq!(view.remove(), 30);
         }
@@ -402,7 +402,7 @@ fn test_entry() {
 
     // Inexistent key (insert)
     match map.entry(10) {
-        Occupied(_) => unreachable!(),
+        Occupied(_) => unsafe { ::core::hint::unreachable_unchecked() },
         Vacant(view) => {
             assert_eq!(*view.insert(1000), 1000);
         }

src/libcore/iter/mod.rs

@@ -323,6 +323,7 @@ use ops::{self, Try};
 use usize;
 use intrinsics;
 use mem;
+use super::hint;
 
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::iterator::Iterator;
@@ -1177,7 +1178,7 @@ impl<A, B> ZipImpl<A, B> for Zip<A, B>
         match (self.a.next_back(), self.b.next_back()) {
             (Some(x), Some(y)) => Some((x, y)),
             (None, None) => None,
-            _ => unreachable!(),
+            _ => unsafe { hint::unreachable_unchecked() },
         }
     }
 
@@ -2035,7 +2036,7 @@ impl<I: Iterator> Peekable<I> {
         match self.peeked {
             Some(Some(ref value)) => Some(value),
             Some(None) => None,
-            _ => unreachable!(),
+            _ => unsafe { hint::unreachable_unchecked() },
         }
     }
 }

src/libcore/macros.rs

@@ -459,7 +459,7 @@ macro_rules! writeln {
 ///         if 3*i < i { panic!("u32 overflow"); }
 ///         if x < 3*i { return i-1; }
 ///     }
-///     unreachable!();
+///     unreachable!()
 /// }
 /// ```
 #[macro_export]

src/libcore/num/dec2flt/rawfp.rs

@@ -36,6 +36,7 @@ use num::FpCategory::{Infinite, Zero, Subnormal, Normal, Nan};
 use num::FpCategory;
 use num::dec2flt::num::{self, Big};
 use num::dec2flt::table;
+use super::super::super::hint;
 
 #[derive(Copy, Clone, Debug)]
 pub struct Unpacked {
@@ -298,14 +299,16 @@ pub fn encode_normal<T: RawFloat>(x: Unpacked) -> T {
         "encode_normal: exponent out of range");
     // Leave sign bit at 0 ("+"), our numbers are all positive
     let bits = (k_enc as u64) << T::EXPLICIT_SIG_BITS | sig_enc;
-    T::from_bits(bits.try_into().unwrap_or_else(|_| unreachable!()))
+    T::from_bits(bits.try_into().unwrap_or_else(|_|
+        unsafe { hint::unreachable_unchecked() }))
 }
 
 /// Construct a subnormal. A mantissa of 0 is allowed and constructs zero.
 pub fn encode_subnormal<T: RawFloat>(significand: u64) -> T {
     assert!(significand < T::MIN_SIG, "encode_subnormal: not actually subnormal");
     // Encoded exponent is 0, the sign bit is 0, so we just have to reinterpret the bits.
-    T::from_bits(significand.try_into().unwrap_or_else(|_| unreachable!()))
+    T::from_bits(significand.try_into().unwrap_or_else(|_|
+        unsafe { hint::unreachable_unchecked() }))
 }
 
 /// Approximate a bignum with an Fp. Rounds within 0.5 ULP with half-to-even.

src/libcore/tests/slice.rs

@@ -399,7 +399,7 @@ fn test_iter_ref_consistency() {
         let v : &[T] = &[x, x, x];
         let v_ptrs : [*const T; 3] = match v {
             [ref v1, ref v2, ref v3] => [v1 as *const _, v2 as *const _, v3 as *const _],
-            _ => unreachable!()
+            _ => unsafe { ::core::hint::unreachable_unchecked() }
         };
         let len = v.len();
 
@@ -455,7 +455,7 @@ fn test_iter_ref_consistency() {
         let v_ptrs : [*mut T; 3] = match v {
             [ref v1, ref v2, ref v3] =>
               [v1 as *const _ as *mut _, v2 as *const _ as *mut _, v3 as *const _ as *mut _],
-            _ => unreachable!()
+            _ => unsafe { ::core::hint::unreachable_unchecked() }
         };
         let len = v.len();
 

src/libpanic_unwind/emcc.rs

@@ -46,7 +46,7 @@ pub unsafe fn panic(data: Box<dyn Any + Send>) -> u32 {
     ptr::write(exception, data);
     __cxa_throw(exception as *mut _, ptr::null_mut(), ptr::null_mut());
 
-    unreachable!()
+    unsafe { ::core::hint::unreachable_unchecked() }
 }
 
 #[lang = "eh_personality"]