When can usize or u64 overflow?

help
20

I'm asking because of these checks here, and wondering if I could skip them:

synced.rcvr_count = synced.rcvr_count.checked_add(1).unwrap();

synced.sndr_count = synced.sndr_count.checked_add(1).unwrap();

synced.elst_count = synced.elst_count.checked_add(1).unwrap();

I think this is the most relevant argument why to not rely on the usize not overflowing. Unlike Box::leak, when calling std::mem::forget, the memory of the passed value gets released (though any additional heap allocations won't). In my case, the structs look basically like this:

pub struct Sender<T> {
    shared: Arc<Shared<T>>,
}

pub struct Enlister<T> {
    shared: Arc<Shared<T>>,
}

enum Slot {
    A,
    B,
}

pub struct Receiver<T> {
    shared: Arc<Shared<T>>,
    slot: Slot,
}

If I create and forget any of these, then no memory should be allocated over time, thus memory exhaustion wouldn't protect me from an overflow. However, the Arc counter should prohibit an overflow as it will reach <usize>::MAX first.

So I guess I could practically omit the overflow checks, but maybe it would be more clear to keep them (as they won't impose any real performance issues).