Consider hinting to the compiler that indices returned from `memchr()` are within bounds of the haystack

[coolreader18]

Currently, indexing into the haystack with the index returned by memchr usually generates a bounds check, because the compiler doesn't know that it's valid. However, if an assert_unchecked(i < haystack.len()) is inserted, the compiler has enough information to elide the check (godbolt).

Pros:

• Reduces bounds-checking in downstream code; this doesn't remove a ton of overhead but could possibly allow for further optimizations that had been inhibited by the branch.

Cons:

• assert_unchecked() is only available since Rust 1.81, so would either have to feature-gate this, do rust version detection, or (most likely) use if !cond { unreachable_unchecked(); } to polyfill it. The last option should be equivalent to assert_unchecked(), but I'm not sure if it's treated exactly the same by the compiler.
• Returning an out-of-bound index becomes UB rather than just a logic error. I assume there was already downstream code relying on this, though, and also it'd probably already be UB internally.

[BurntSushi]

I think this sounds okay to me in principle. But your godbolt example isn't really sufficient to demonstrate that this will work here. Most of the public routines in this crate won't inline, specifically because they are either quite large or because they use ISA extensions that cannot be inlined unless the caller has those same extensions enabled (which is still rare today on x86-64). So if this assertion is put inside of a non-inlined function, I'd guess it wouldn't have the desired effect. That is, your inline(always) in your godbolt example is load bearing.

So doing this correctly is likely possible, but requires care. I'm open to PRs.

Rust 1.81 was released over a year ago, so I'm fine with the MSRV bump here.

[Dr-Emann]

I believe the important paths are already inline-able:

memchr/src/memchr.rs

Lines 26 to 27 in 1e4b8a8

	#[inline]
	pub fn memchr(needle: u8, haystack: &[u8]) -> Option<usize> {

memchr/src/memchr.rs

Lines 58 to 59 in 1e4b8a8

	#[inline]
	pub fn memrchr(needle: u8, haystack: &[u8]) -> Option<usize> {

And the (always inline) internal function they call is already documented to require exactly what we need to require to assume the result is in bounds.

memchr/src/arch/generic/memchr.rs

Lines 1121 to 1125 in f39b7b3

	/// Callers must ensure that if a pointer is returned by `find_raw`, then the
	/// pointer must be greater than or equal to the starting pointer and less than
	/// the end pointer.
	#[inline(always)]
	pub(crate) unsafe fn search_slice_with_raw(

[xtqqczze]

Is there a similar optimization to be made for memchr_iter?