Unsafe assertions that allow for optimizations in release mode.
These macros use core::hint::unreachable_unchecked, which make it possible to write assertions that simultaneously clarify code as well as hint at optimizations to LLVM.
Add this to your Cargo.toml
toml
[dependencies]
assert_unchecked = "0.1.2"
```rust use assertunchecked::{ assertequnchecked, assertneunchecked, assertunchecked, unreachable_unchecked, };
fn copy(fromarr: &[u8], toarr: &mut [u8]) { asserteq!(fromarr.len(), toarr.len()); for i in 0..toarr.len() { // SAFETY: bounds of toarr is checked outside of loop // Without this line, the compiler isn't smart enough to remove the bounds check unsafe { assertunchecked!(i <= toarr.len()) }; toarr[i] = from_arr[i]; } }
fn getlast(len: usize) -> usize {
if len == 0 {
return 0;
}
let mut v = vec![0];
for i in 1..len {
v.push(i)
}
// SAFETY: len elements have been added to v at this point
// Without this line, the compiler isn't smart enough to remove the bounds check
unsafe { asserteq_unchecked!(len, v.len()) };
v[len - 1]
}
// Modifies a[0] and a[delta], and then returns a[0].
// delta must be non-zero and delta < a.len().
unsafe fn modifystartanddelta(a: &mut [u8], delta: usize) -> u8 {
// SAFETY: requirements are invariants of the unsafe function.
assertunchecked!(delta < a.len());
// With this assertion, we know that a[delta] does not modify a[0],
// which means the function can optimize the return value to always be 0.
// This also means that all bounds checks can be removed.
assertneunchecked!(delta, 0);
a[0] = 0;
a[delta] = 1;
a[0]
}
fn div1(a: u32, b: u32) -> u32 {
// b.saturating_add(1) is always positive (not zero),
// hence checked_div will never return None.
// Therefore, the else branch is unreachable.
a.checkeddiv(b.saturatingadd(1))
.unwraporelse(|| unsafe { unreachableunchecked!("division by zero isn't possible") })
}
```