0403948aa2
# Background In `no_std` compatible crates, there is often an `std` feature which will allow access to the standard library. Currently, with the `std` feature _enabled_, the [`std::prelude`](https://doc.rust-lang.org/std/prelude/index.html) is implicitly imported in all modules. With the feature _disabled_, instead the [`core::prelude`](https://doc.rust-lang.org/core/prelude/index.html) is implicitly imported. This creates a subtle and pervasive issue where `alloc` items _may_ be implicitly included (if `std` is enabled), or must be explicitly included (if `std` is not enabled). # Objective - Make the implicit imports for `no_std` crates consistent regardless of what features are/not enabled. ## Solution - Replace the `cfg_attr` "double negative" `no_std` attribute with conditional compilation to _include_ `std` as an external crate. ```rust // Before #![cfg_attr(not(feature = "std"), no_std)] // After #![no_std] #[cfg(feature = "std")] extern crate std; ``` - Fix imports that are currently broken but are only now visible with the above fix. ## Testing - CI ## Notes I had previously used the "double negative" version of `no_std` based on general consensus that it was "cleaner" within the Rust embedded community. However, this implicit prelude issue likely was considered when forming this consensus. I believe the reason why is the items most affected by this issue are provided by the `alloc` crate, which is rarely used within embedded but extensively used within Bevy.
56 lines
1.9 KiB
Rust
56 lines
1.9 KiB
Rust
#![expect(unsafe_code, reason = "SyncCell requires unsafe code.")]
|
|
|
|
//! A reimplementation of the currently unstable [`std::sync::Exclusive`]
|
|
//!
|
|
//! [`std::sync::Exclusive`]: https://doc.rust-lang.org/nightly/std/sync/struct.Exclusive.html
|
|
|
|
use core::ptr;
|
|
|
|
/// See [`Exclusive`](https://github.com/rust-lang/rust/issues/98407) for stdlib's upcoming implementation,
|
|
/// which should replace this one entirely.
|
|
///
|
|
/// Provides a wrapper that allows making any type unconditionally [`Sync`] by only providing mutable access.
|
|
#[repr(transparent)]
|
|
pub struct SyncCell<T: ?Sized> {
|
|
inner: T,
|
|
}
|
|
|
|
impl<T: Sized> SyncCell<T> {
|
|
/// Construct a new instance of a `SyncCell` from the given value.
|
|
pub fn new(inner: T) -> Self {
|
|
Self { inner }
|
|
}
|
|
|
|
/// Deconstruct this `SyncCell` into its inner value.
|
|
pub fn to_inner(Self { inner }: Self) -> T {
|
|
inner
|
|
}
|
|
}
|
|
|
|
impl<T: ?Sized> SyncCell<T> {
|
|
/// Get a reference to this `SyncCell`'s inner value.
|
|
pub fn get(&mut self) -> &mut T {
|
|
&mut self.inner
|
|
}
|
|
|
|
/// For types that implement [`Sync`], get shared access to this `SyncCell`'s inner value.
|
|
pub fn read(&self) -> &T
|
|
where
|
|
T: Sync,
|
|
{
|
|
&self.inner
|
|
}
|
|
|
|
/// Build a mutable reference to a `SyncCell` from a mutable reference
|
|
/// to its inner value, to skip constructing with [`new()`](SyncCell::new()).
|
|
pub fn from_mut(r: &'_ mut T) -> &'_ mut SyncCell<T> {
|
|
// SAFETY: repr is transparent, so refs have the same layout; and `SyncCell` properties are `&mut`-agnostic
|
|
unsafe { &mut *(ptr::from_mut(r) as *mut SyncCell<T>) }
|
|
}
|
|
}
|
|
|
|
// SAFETY: `Sync` only allows multithreaded access via immutable reference.
|
|
// As `SyncCell` requires an exclusive reference to access the wrapped value for `!Sync` types,
|
|
// marking this type as `Sync` does not actually allow unsynchronized access to the inner value.
|
|
unsafe impl<T: ?Sized> Sync for SyncCell<T> {}
|