Improve slice::binary_search_by

Author: krtab

library/core/src/slice/mod.rs

@@ -2787,15 +2787,28 @@ impl<T> [T] {
     where
         F: FnMut(&'a T) -> Ordering,
     {
+        if T::IS_ZST {
+            let res = if self.len() == 0 {
+                Err(0)
+            } else {
+                match f(&self[0]) {
+                    Less => Err(self.len()),
+                    Equal => Ok(0),
+                    Greater => Err(0),
+                }
+            };
+            return res;
+        }
         // INVARIANTS:
-        // - 0 <= left <= left + size = right <= self.len()
+        // - 0 <= left <= right  <= self.len()
         // - f returns Less for everything in self[..left]
         // - f returns Greater for everything in self[right..]
-        let mut size = self.len();
+        let mut right = self.len();
         let mut left = 0;
-        let mut right = size;
         while left < right {
-            let mid = left + size / 2;
+            // This is an okay way to compute the mean because left and right are
+            // <= isize::MAX so the addition won't overflow
+            let mid = (left + right) / 2;
 
             // SAFETY: the while condition means `size` is strictly positive, so
             // `size/2 < size`. Thus `left + size/2 < left + size`, which
@@ -2807,19 +2820,16 @@ impl<T> [T] {
             // fewer branches and instructions than if/else or matching on
             // cmp::Ordering.
             // This is x86 asm for u8: https://rust.godbolt.org/z/698eYffTx.
+
             left = if cmp == Less { mid + 1 } else { left };
             right = if cmp == Greater { mid } else { right };
             if cmp == Equal {
                 // SAFETY: same as the `get_unchecked` above
                 unsafe { hint::assert_unchecked(mid < self.len()) };
                 return Ok(mid);
             }
-
-            size = right - left;
         }
-
-        // SAFETY: directly true from the overall invariant.
-        // Note that this is `<=`, unlike the assume in the `Ok` path.
+        // SAFETY: yolo
         unsafe { hint::assert_unchecked(left <= self.len()) };
         Err(left)
     }

library/core/tests/slice.rs

@@ -69,13 +69,13 @@ fn test_binary_search() {
     assert_eq!(b.binary_search(&8), Err(5));
 
     let b = [(); usize::MAX];
-    assert_eq!(b.binary_search(&()), Ok(usize::MAX / 2));
+    assert_eq!(b.binary_search(&()), Ok(0));
 }
 
 #[test]
 fn test_binary_search_by_overflow() {
     let b = [(); usize::MAX];
-    assert_eq!(b.binary_search_by(|_| Ordering::Equal), Ok(usize::MAX / 2));
+    assert_eq!(b.binary_search_by(|_| Ordering::Equal), Ok(0));
     assert_eq!(b.binary_search_by(|_| Ordering::Greater), Err(0));
     assert_eq!(b.binary_search_by(|_| Ordering::Less), Err(usize::MAX));
 }