core::slice code may overflow with slices of zero-sized elements

[lilyball]

The core::slice code appears to have been written to work correctly for slices of zero-sized elements where s.as_ptr() + s.len() overflows. Specifically, the iterators calculate an end value like that, but doesn't rely on end > ptr (it does equality tests, and for size_hint it calculates the delta), and the iterators also explicitly always yield &mut *(1 as *mut _) as the pointer value for zero-sized types to avoid the case of yielding null (which would be interpreted as None instead of Some(_)).

But all this code was written before we had overflow checks. With overflow checks enabled, there's a number of places that can now inadvertently overflow. As such, the whole module needs to be looked over and converted to use wrapping arithmetic where it makes sense.

Also see #24997.

[lilyball]

Working on a patch for this I ran across a related bug:

fn main() {
    let v = [(); 10];
    let mut it = v.iter();
    let _ = it.nth(4);
    assert_eq!(it.count(), 5);
}

This fails the assertion because it.count() returns 9.

[lilyball]

#25300 fixes the aforementioned related bug as well.

[lilyball]

Another bug:

#![feature(core)]

use std::slice;

fn foo<T>(v: &[T]) -> Option<&[T]> {
    let mut it = v.iter();
    for _ in 0..5 {
        let _ = it.next();
    }
    Some(it.as_slice())
}

fn main() {
    let v: &[()] = unsafe { slice::from_raw_parts(-5isize as *const (), 10) };
    assert!(foo(v).is_some());
}