Atomic<ptr> is no longer possible

[Tazdevil971]

As per title, since the addition of T: NoUninit pointers are no longer allowed inside an Atomic<...>.

This is per definition of NoUninit, which I quote:

It is disallowed for types to contain pointer types, Cell, UnsafeCell, atomics, and any other forms of interior mutability.

It is unclear to me why pointer types are disallowed inside a NoUninit as they do not provide interior mutability directly. Anyway this is clearly limiting, as pointer inside atomics are allowed (proved by the existence of AtomicPtr).

My specific use case is something akin to this:

struct BarPtr(NonNull<Bar>);

// ...

struct Foo {
  // ...
  bar: Atomic<Option<BarPtr>>,
  // ...
}

I think that a way to fix this is to have this crate contain its own trait asserting that a type "is safe inside an Atomic<...>", implement it for all T: NoUninit but still allowing for unsafe manual implementation. This could also be used to make the dependency bytemuck optional.

[Amanieu]

Technically, using pointers is unsound because of Lokathor/bytemuck#64. You can work around it by implementing the NoUninit trait for your type manually.

[Tazdevil971]

Oh, I missed that, thank you. So TL;DR performing a round-trip between pointer/integer using transmute looses provenance, hence could be unsound. So this is by all means formally not possible due to the way this library works.

And if I understand the state of things right now, this might work now, but this is a grey area of the specification, and might be subject to change in the future.

Thank you very much, I needed a proper explanation of why this wasn't possible.

EDIT: I even found the relevant documentation in the rust stdlib docs: https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers

Transmuting integers to pointers is a largely unspecified operation. It is likely not equivalent to an as cast. Doing non-zero-sized memory accesses with a pointer constructed this way is currently considered undefined behavior.