Unique references to temporary empty arrays are not actually unique

[mcy]

fn two_muts<T>(a: &mut [T], b: &mut [T]) {
    assert_ne!(a.as_ptr(), b.as_ptr());
}

fn main() {
    two_muts::<u8>(&mut [], &mut []);
}

I expected this code to compile and exit without effect; instead, I get an assertion error. It seems that, when passing in unique references to temporary empty slices, the underlying pointers nonetheless alias.

I expected all such pointers to never alias; this even holds when replacing [T] above with the ZST [T; 0], which makes it significantly more worrying, since it does not hold for the same code using ().

I don't know if this behavior is actually specified, but I'd like an answer to whether this is a miscompilation or (un)documented implementation-defined behavior. At any rate, I wonder if it would be a good idea to make this behavior consistent for all ZST temporaries...

Also, I aught to mention that this is about ZSTs lying in distinct allocations. For a type such as ((), ()), we expect the two unit values to have the same addresses. The closest mention of this I could find in the nomicon to this was the implementation of Vec<()>, but that's still regarding same-allocation references, so that didn't give me a particularly satisfying answer.

Meta

This issue is reproducible on latest beta and nightly.

I could not find an issue corresponding to this bug; feel free to close as duplicate.

[the8472]

That isn't specific to temporaries. Mutable references to ZSTs in what normally are heap-allocated containers can also have identical values. References to ZSTs are basically pulled out of thin air and valid as long as they're non-null.

fn main() {
    let mut v1 = vec![(); 1];
    let mut v2 = vec![(); 1];
    assert_ne!(v1.as_mut_ptr(), v2.as_mut_ptr());
}

thread 'main' panicked at 'assertion failed: `(left != right)`
  left: `0x1`,
 right: `0x1`', src/main.rs:4:5

[gendx]

Also, I aught to mention that this is about ZSTs lying in distinct allocations.

Correct me if I'm wrong, but in the original example I don't see any allocation. Aren't the empty arrays supposed to be on the stack (at least before any compiler optimization kicks in)?

two_muts::<u8>(&mut [], &mut []);

Isn't the following memory model a reasonable possible representation?

• The first array [] at stack_start + 0
• The second array [] at stack_start + 0
• The first slice &mut [] at stack_start + 0
• The second slice &mut [] at stack_start + 2 * pointer_size

In that case, both arrays - and even one of the slices - start at the same memory address. However, they don't overlap but simply "touch" each other.

In that sense, even though the underlying pointers point to the same address, the pointed-to objects don't actually alias, right? Or to put it differently, pointers to ZST can never alias, because the underlying zero-sized objects can never overlap each other (at worst they "touch", which isn't aliasing).

[sfackler]

Also, I aught to mention that this is about ZSTs lying in distinct allocations.

Zero bytes of the allocations of those values overlap.