AtomicUint should not exist

[pythonesque]

At best, it's poorly named, because it should be AtomicUsize, but it's actually always struck me as strange that we special case usize (ne uint) like this. Besides the fact that on many architectures other types are atomic, I wouldn't be shocked to find there are some where pointer-sized words aren't (though probably not any LLVM supports, but isn't that just an implementation detail?) We should really be able to expose Atomic<T> (all our intrinsics already are), and let LLVM and other backends complain at codegen time if they can't generate the appropriate type (or have some other mechanism for determining this).

[sfackler]

AtomicUsize is useful to hold pointers, since AtomicPointer can't be statically initialized.

[sfackler]

e.g. https://github.com/sfackler/log-ng/blob/master/src/lib.rs#L163

[alexcrichton]

The types have downgraded to unstable as a result of the outcome of the usize/isize decision, giving us leeway to change them as necessary. As @sfackler says, we do want to continue providing pointer-sized atomics for all platforms. We may want to consider fixed-size atomics as well for some platforms as well, but those are backwards-compatible additions.

For now though this is likely to fall out of the next stabilization pass of the standard library, so I'm going to close this.

We should really be able to expose Atomic (all our intrinsics already are), and let LLVM and other backends complain at codegen time if they can't generate the appropriate type (or have some other mechanism for determining this).

We have considered something like this in the past, but this would involve some awkward traits involved and the operations between types like AtomicBool and AtomicUint are different enough that we did not wish to pursue this direction for now.

Additionally, the standard library is portable-by-default unless it says otherwise (e.g. std::os::$platform is platform-specific). We can provide more atomics in more experimental locations, but std::sync is intended to be 100% cross-platform.