mirror of
https://github.com/rust-lang/rust.git
synced 2026-04-27 18:57:42 +03:00
Rollup merge of #153038 - pthariensflame:syncview-rename, r=Amanieu
core::sync: rename `Exclusive` to `SyncView` and make improvements This PR implements the renaming of `core::sync::Exclusive` to `SyncView` as decided in rust-lang/rust#98407. To preserve the ability to search for the old name, it adds `Exclusive` as a `doc_alias`. It also makes the following additional changes: - Converting the `get_mut` method to being an instance of `AsMut::as_mut`. In the process, it makes both the new `impl AsMut` and the existing `impl AsRef` `const`, and it also renames `get_pin_mut` to `as_pin_mut` for consistency. This direction follows a suggestion from rust-lang/rust#98407. - Adding an `as_pin` method that can only be used when the wrapped type implements `Sync`, to complete the square of access methods. - Making as many of the existing `impl`s `const` as possible; this involved making the existing `impl Default` no longer derived. - Adding `impl`s for `AsyncFnOnce`, `AsyncFnMut`, and `AsyncFn`, akin to the existing `impls` for `FnOnce`, `FnMut`, and `Fn`. It does not yet do the following, which may be desirable: - Fixing/improving the documentation to address the concern pointed out in rust-lang/rust#146245. It previously did the following, but this was removed after discussion: - Adding an `impl` for (`const`) `Iterator`, which felt in line with the existing `impl`s for `Future` and `Coroutine`.
This commit is contained in:
Jacob Pratt
@@ -1,322 +0,0 @@
|
||||
//! Defines [`Exclusive`].
|
||||
|
||||
use core::clone::TrivialClone;
|
||||
use core::cmp::Ordering;
|
||||
use core::fmt;
|
||||
use core::future::Future;
|
||||
use core::hash::{Hash, Hasher};
|
||||
use core::marker::{StructuralPartialEq, Tuple};
|
||||
use core::ops::{Coroutine, CoroutineState};
|
||||
use core::pin::Pin;
|
||||
use core::task::{Context, Poll};
|
||||
|
||||
/// `Exclusive` provides _mutable_ access, also referred to as _exclusive_
|
||||
/// access to the underlying value. However, it only permits _immutable_, or _shared_
|
||||
/// access to the underlying value when that value is [`Sync`].
|
||||
///
|
||||
/// While this may seem not very useful, it allows `Exclusive` to _unconditionally_
|
||||
/// implement `Sync`. Indeed, the safety requirements of `Sync` state that for `Exclusive`
|
||||
/// to be `Sync`, it must be sound to _share_ across threads, that is, it must be sound
|
||||
/// for `&Exclusive` to cross thread boundaries. By design, a `&Exclusive<T>` for non-`Sync` T
|
||||
/// has no API whatsoever, making it useless, thus harmless, thus memory safe.
|
||||
///
|
||||
/// Certain constructs like [`Future`]s can only be used with _exclusive_ access,
|
||||
/// and are often `Send` but not `Sync`, so `Exclusive` can be used as hint to the
|
||||
/// Rust compiler that something is `Sync` in practice.
|
||||
///
|
||||
/// ## Examples
|
||||
///
|
||||
/// Using a non-`Sync` future prevents the wrapping struct from being `Sync`:
|
||||
///
|
||||
/// ```compile_fail
|
||||
/// use core::cell::Cell;
|
||||
///
|
||||
/// async fn other() {}
|
||||
/// fn assert_sync<T: Sync>(t: T) {}
|
||||
/// struct State<F> {
|
||||
/// future: F
|
||||
/// }
|
||||
///
|
||||
/// assert_sync(State {
|
||||
/// future: async {
|
||||
/// let cell = Cell::new(1);
|
||||
/// let cell_ref = &cell;
|
||||
/// other().await;
|
||||
/// let value = cell_ref.get();
|
||||
/// }
|
||||
/// });
|
||||
/// ```
|
||||
///
|
||||
/// `Exclusive` ensures the struct is `Sync` without stripping the future of its
|
||||
/// functionality:
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(exclusive_wrapper)]
|
||||
/// use core::cell::Cell;
|
||||
/// use core::sync::Exclusive;
|
||||
///
|
||||
/// async fn other() {}
|
||||
/// fn assert_sync<T: Sync>(t: T) {}
|
||||
/// struct State<F> {
|
||||
/// future: Exclusive<F>
|
||||
/// }
|
||||
///
|
||||
/// assert_sync(State {
|
||||
/// future: Exclusive::new(async {
|
||||
/// let cell = Cell::new(1);
|
||||
/// let cell_ref = &cell;
|
||||
/// other().await;
|
||||
/// let value = cell_ref.get();
|
||||
/// })
|
||||
/// });
|
||||
/// ```
|
||||
///
|
||||
/// ## Parallels with a mutex
|
||||
///
|
||||
/// In some sense, `Exclusive` can be thought of as a _compile-time_ version of
|
||||
/// a mutex, as the borrow-checker guarantees that only one `&mut` can exist
|
||||
/// for any value. This is a parallel with the fact that
|
||||
/// `&` and `&mut` references together can be thought of as a _compile-time_
|
||||
/// version of a read-write lock.
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[doc(alias = "SyncWrapper")]
|
||||
#[doc(alias = "SyncCell")]
|
||||
#[doc(alias = "Unique")]
|
||||
// `Exclusive` can't have derived `PartialOrd`, `Clone`, etc. impls as they would
|
||||
// use `&` access to the inner value, violating the `Sync` impl's safety
|
||||
// requirements.
|
||||
#[derive(Default)]
|
||||
#[repr(transparent)]
|
||||
pub struct Exclusive<T: ?Sized> {
|
||||
inner: T,
|
||||
}
|
||||
|
||||
// See `Exclusive`'s docs for justification.
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
unsafe impl<T: ?Sized> Sync for Exclusive<T> {}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<T: ?Sized> fmt::Debug for Exclusive<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
|
||||
f.debug_struct("Exclusive").finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Sized> Exclusive<T> {
|
||||
/// Wrap a value in an `Exclusive`
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[must_use]
|
||||
#[inline]
|
||||
pub const fn new(t: T) -> Self {
|
||||
Self { inner: t }
|
||||
}
|
||||
|
||||
/// Unwrap the value contained in the `Exclusive`
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[must_use]
|
||||
#[inline]
|
||||
pub const fn into_inner(self) -> T {
|
||||
self.inner
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: ?Sized> Exclusive<T> {
|
||||
/// Gets exclusive access to the underlying value.
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[must_use]
|
||||
#[inline]
|
||||
pub const fn get_mut(&mut self) -> &mut T {
|
||||
&mut self.inner
|
||||
}
|
||||
|
||||
/// Gets pinned exclusive access to the underlying value.
|
||||
///
|
||||
/// `Exclusive` is considered to _structurally pin_ the underlying
|
||||
/// value, which means _unpinned_ `Exclusive`s can produce _unpinned_
|
||||
/// access to the underlying value, but _pinned_ `Exclusive`s only
|
||||
/// produce _pinned_ access to the underlying value.
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[must_use]
|
||||
#[inline]
|
||||
pub const fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T> {
|
||||
// SAFETY: `Exclusive` can only produce `&mut T` if itself is unpinned
|
||||
// `Pin::map_unchecked_mut` is not const, so we do this conversion manually
|
||||
unsafe { Pin::new_unchecked(&mut self.get_unchecked_mut().inner) }
|
||||
}
|
||||
|
||||
/// Build a _mutable_ reference to an `Exclusive<T>` from
|
||||
/// a _mutable_ reference to a `T`. This allows you to skip
|
||||
/// building an `Exclusive` with [`Exclusive::new`].
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[must_use]
|
||||
#[inline]
|
||||
pub const fn from_mut(r: &'_ mut T) -> &'_ mut Exclusive<T> {
|
||||
// SAFETY: repr is ≥ C, so refs have the same layout; and `Exclusive` properties are `&mut`-agnostic
|
||||
unsafe { &mut *(r as *mut T as *mut Exclusive<T>) }
|
||||
}
|
||||
|
||||
/// Build a _pinned mutable_ reference to an `Exclusive<T>` from
|
||||
/// a _pinned mutable_ reference to a `T`. This allows you to skip
|
||||
/// building an `Exclusive` with [`Exclusive::new`].
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[must_use]
|
||||
#[inline]
|
||||
pub const fn from_pin_mut(r: Pin<&'_ mut T>) -> Pin<&'_ mut Exclusive<T>> {
|
||||
// SAFETY: `Exclusive` can only produce `&mut T` if itself is unpinned
|
||||
// `Pin::map_unchecked_mut` is not const, so we do this conversion manually
|
||||
unsafe { Pin::new_unchecked(Self::from_mut(r.get_unchecked_mut())) }
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
|
||||
impl<T> const From<T> for Exclusive<T> {
|
||||
#[inline]
|
||||
fn from(t: T) -> Self {
|
||||
Self::new(t)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<F, Args> FnOnce<Args> for Exclusive<F>
|
||||
where
|
||||
F: FnOnce<Args>,
|
||||
Args: Tuple,
|
||||
{
|
||||
type Output = F::Output;
|
||||
|
||||
extern "rust-call" fn call_once(self, args: Args) -> Self::Output {
|
||||
self.into_inner().call_once(args)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<F, Args> FnMut<Args> for Exclusive<F>
|
||||
where
|
||||
F: FnMut<Args>,
|
||||
Args: Tuple,
|
||||
{
|
||||
extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output {
|
||||
self.get_mut().call_mut(args)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<F, Args> Fn<Args> for Exclusive<F>
|
||||
where
|
||||
F: Sync + Fn<Args>,
|
||||
Args: Tuple,
|
||||
{
|
||||
extern "rust-call" fn call(&self, args: Args) -> Self::Output {
|
||||
self.as_ref().call(args)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<T> Future for Exclusive<T>
|
||||
where
|
||||
T: Future + ?Sized,
|
||||
{
|
||||
type Output = T::Output;
|
||||
|
||||
#[inline]
|
||||
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||
self.get_pin_mut().poll(cx)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "coroutine_trait", issue = "43122")] // also #98407
|
||||
impl<R, G> Coroutine<R> for Exclusive<G>
|
||||
where
|
||||
G: Coroutine<R> + ?Sized,
|
||||
{
|
||||
type Yield = G::Yield;
|
||||
type Return = G::Return;
|
||||
|
||||
#[inline]
|
||||
fn resume(self: Pin<&mut Self>, arg: R) -> CoroutineState<Self::Yield, Self::Return> {
|
||||
G::resume(self.get_pin_mut(), arg)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<T> AsRef<T> for Exclusive<T>
|
||||
where
|
||||
T: Sync + ?Sized,
|
||||
{
|
||||
#[inline]
|
||||
fn as_ref(&self) -> &T {
|
||||
&self.inner
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<T> Clone for Exclusive<T>
|
||||
where
|
||||
T: Sync + Clone,
|
||||
{
|
||||
#[inline]
|
||||
fn clone(&self) -> Self {
|
||||
Self { inner: self.inner.clone() }
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
#[unstable(feature = "trivial_clone", issue = "none")]
|
||||
unsafe impl<T> TrivialClone for Exclusive<T> where T: Sync + TrivialClone {}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<T> Copy for Exclusive<T> where T: Sync + Copy {}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<T, U> PartialEq<Exclusive<U>> for Exclusive<T>
|
||||
where
|
||||
T: Sync + PartialEq<U> + ?Sized,
|
||||
U: Sync + ?Sized,
|
||||
{
|
||||
#[inline]
|
||||
fn eq(&self, other: &Exclusive<U>) -> bool {
|
||||
self.inner == other.inner
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<T> StructuralPartialEq for Exclusive<T> where T: Sync + StructuralPartialEq + ?Sized {}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<T> Eq for Exclusive<T> where T: Sync + Eq + ?Sized {}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<T> Hash for Exclusive<T>
|
||||
where
|
||||
T: Sync + Hash + ?Sized,
|
||||
{
|
||||
#[inline]
|
||||
fn hash<H: Hasher>(&self, state: &mut H) {
|
||||
Hash::hash(&self.inner, state)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<T, U> PartialOrd<Exclusive<U>> for Exclusive<T>
|
||||
where
|
||||
T: Sync + PartialOrd<U> + ?Sized,
|
||||
U: Sync + ?Sized,
|
||||
{
|
||||
#[inline]
|
||||
fn partial_cmp(&self, other: &Exclusive<U>) -> Option<Ordering> {
|
||||
self.inner.partial_cmp(&other.inner)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<T> Ord for Exclusive<T>
|
||||
where
|
||||
T: Sync + Ord + ?Sized,
|
||||
{
|
||||
#[inline]
|
||||
fn cmp(&self, other: &Self) -> Ordering {
|
||||
self.inner.cmp(&other.inner)
|
||||
}
|
||||
}
|
||||
@@ -3,6 +3,6 @@
|
||||
#![stable(feature = "rust1", since = "1.0.0")]
|
||||
|
||||
pub mod atomic;
|
||||
mod exclusive;
|
||||
mod sync_view;
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
pub use exclusive::Exclusive;
|
||||
pub use sync_view::SyncView;
|
||||
|
||||
@@ -0,0 +1,414 @@
|
||||
//! Defines [`SyncView`].
|
||||
|
||||
use core::clone::TrivialClone;
|
||||
use core::cmp::Ordering;
|
||||
use core::fmt;
|
||||
use core::future::Future;
|
||||
use core::hash::{Hash, Hasher};
|
||||
use core::marker::{StructuralPartialEq, Tuple};
|
||||
use core::ops::{Coroutine, CoroutineState};
|
||||
use core::pin::Pin;
|
||||
use core::task::{Context, Poll};
|
||||
|
||||
/// `SyncView` provides _mutable_ access, also referred to as _exclusive_
|
||||
/// access to the underlying value. However, it only permits _immutable_, or _shared_
|
||||
/// access to the underlying value when that value is [`Sync`].
|
||||
///
|
||||
/// While this may seem not very useful, it allows `SyncView` to _unconditionally_
|
||||
/// implement `Sync`. Indeed, the safety requirements of `Sync` state that for `SyncView`
|
||||
/// to be `Sync`, it must be sound to _share_ across threads, that is, it must be sound
|
||||
/// for `&SyncView` to cross thread boundaries. By design, a `&SyncView<T>` for non-`Sync`
|
||||
/// `T` has no API whatsoever, making it useless, thus harmless, thus memory safe.
|
||||
///
|
||||
/// Certain constructs like [`Future`]s can only be used with _exclusive_ access,
|
||||
/// and are often [`Send`] but not `Sync`, so `SyncView` can be used as hint to the
|
||||
/// Rust compiler that something is `Sync` in practice.
|
||||
///
|
||||
/// ## Examples
|
||||
///
|
||||
/// Using a non-`Sync` future prevents the wrapping struct from being `Sync`:
|
||||
///
|
||||
/// ```compile_fail
|
||||
/// use core::cell::Cell;
|
||||
///
|
||||
/// async fn other() {}
|
||||
/// fn assert_sync<T: Sync>(t: T) {}
|
||||
/// struct State<F> {
|
||||
/// future: F
|
||||
/// }
|
||||
///
|
||||
/// assert_sync(State {
|
||||
/// future: async {
|
||||
/// let cell = Cell::new(1);
|
||||
/// let cell_ref = &cell;
|
||||
/// other().await;
|
||||
/// let value = cell_ref.get();
|
||||
/// }
|
||||
/// });
|
||||
/// ```
|
||||
///
|
||||
/// `SyncView` ensures the struct is `Sync` without stripping the future of its
|
||||
/// functionality:
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(exclusive_wrapper)]
|
||||
/// use core::cell::Cell;
|
||||
/// use core::sync::SyncView;
|
||||
///
|
||||
/// async fn other() {}
|
||||
/// fn assert_sync<T: Sync>(t: T) {}
|
||||
/// struct State<F> {
|
||||
/// future: SyncView<F>
|
||||
/// }
|
||||
///
|
||||
/// assert_sync(State {
|
||||
/// future: SyncView::new(async {
|
||||
/// let cell = Cell::new(1);
|
||||
/// let cell_ref = &cell;
|
||||
/// other().await;
|
||||
/// let value = cell_ref.get();
|
||||
/// })
|
||||
/// });
|
||||
/// ```
|
||||
///
|
||||
/// ## Parallels with a mutex
|
||||
///
|
||||
/// In some sense, `SyncView` can be thought of as a _compile-time_ version of
|
||||
/// a mutex, as the borrow-checker guarantees that only one `&mut` can exist
|
||||
/// for any value. This is a parallel with the fact that
|
||||
/// `&` and `&mut` references together can be thought of as a _compile-time_
|
||||
/// version of a read-write lock.
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[doc(alias = "SyncWrapper")]
|
||||
#[doc(alias = "SyncCell")]
|
||||
#[doc(alias = "Unique")]
|
||||
#[doc(alias = "Exclusive")]
|
||||
// `SyncView` can't have derived `PartialOrd`, `Clone`, etc. impls as they would
|
||||
// use `&` access to the inner value, violating the `Sync` impl's safety
|
||||
// requirements.
|
||||
#[repr(transparent)]
|
||||
pub struct SyncView<T: ?Sized> {
|
||||
inner: T,
|
||||
}
|
||||
|
||||
// See `SyncView`'s docs for justification.
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
unsafe impl<T: ?Sized> Sync for SyncView<T> {}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "const_default", issue = "143894")]
|
||||
impl<T> const Default for SyncView<T>
|
||||
where
|
||||
T: [const] Default,
|
||||
{
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
Self { inner: Default::default() }
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<T: ?Sized> fmt::Debug for SyncView<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
|
||||
f.debug_struct("SyncView").finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Sized> SyncView<T> {
|
||||
/// Wrap a value in an `SyncView`
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[must_use]
|
||||
#[inline]
|
||||
pub const fn new(t: T) -> Self {
|
||||
Self { inner: t }
|
||||
}
|
||||
|
||||
/// Unwrap the value contained in the `SyncView`
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[must_use]
|
||||
#[inline]
|
||||
pub const fn into_inner(self) -> T {
|
||||
self.inner
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: ?Sized> SyncView<T> {
|
||||
/// Gets pinned exclusive access to the underlying value.
|
||||
///
|
||||
/// `SyncView` is considered to _structurally pin_ the underlying
|
||||
/// value, which means _unpinned_ `SyncView`s can produce _unpinned_
|
||||
/// access to the underlying value, but _pinned_ `SyncView`s only
|
||||
/// produce _pinned_ access to the underlying value.
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[must_use]
|
||||
#[inline]
|
||||
pub const fn as_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T> {
|
||||
// SAFETY: `SyncView` can only produce `&mut T` if itself is unpinned
|
||||
// `Pin::map_unchecked_mut` is not const, so we do this conversion manually
|
||||
unsafe { Pin::new_unchecked(&mut self.get_unchecked_mut().inner) }
|
||||
}
|
||||
|
||||
/// Build a _mutable_ reference to an `SyncView<T>` from
|
||||
/// a _mutable_ reference to a `T`. This allows you to skip
|
||||
/// building an `SyncView` with [`SyncView::new`].
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[must_use]
|
||||
#[inline]
|
||||
pub const fn from_mut(r: &'_ mut T) -> &'_ mut SyncView<T> {
|
||||
// SAFETY: repr is ≥ C, so refs have the same layout; and `SyncView` properties are `&mut`-agnostic
|
||||
unsafe { &mut *(r as *mut T as *mut SyncView<T>) }
|
||||
}
|
||||
|
||||
/// Build a _pinned mutable_ reference to an `SyncView<T>` from
|
||||
/// a _pinned mutable_ reference to a `T`. This allows you to skip
|
||||
/// building an `SyncView` with [`SyncView::new`].
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[must_use]
|
||||
#[inline]
|
||||
pub const fn from_pin_mut(r: Pin<&'_ mut T>) -> Pin<&'_ mut SyncView<T>> {
|
||||
// SAFETY: `SyncView` can only produce `&mut T` if itself is unpinned
|
||||
// `Pin::map_unchecked_mut` is not const, so we do this conversion manually
|
||||
unsafe { Pin::new_unchecked(Self::from_mut(r.get_unchecked_mut())) }
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: ?Sized + Sync> SyncView<T> {
|
||||
/// Gets pinned shared access to the underlying value.
|
||||
///
|
||||
/// `SyncView` is considered to _structurally pin_ the underlying
|
||||
/// value, which means _unpinned_ `SyncView`s can produce _unpinned_
|
||||
/// access to the underlying value, but _pinned_ `SyncView`s only
|
||||
/// produce _pinned_ access to the underlying value.
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[must_use]
|
||||
#[inline]
|
||||
pub const fn as_pin(self: Pin<&Self>) -> Pin<&T> {
|
||||
// SAFETY: `SyncView` can only produce `&T` if itself is unpinned
|
||||
// `Pin::map_unchecked` is not const, so we do this conversion manually
|
||||
unsafe { Pin::new_unchecked(&self.get_ref().inner) }
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
|
||||
impl<T> const From<T> for SyncView<T> {
|
||||
#[inline]
|
||||
fn from(t: T) -> Self {
|
||||
Self::new(t)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "const_trait_impl", issue = "143874")]
|
||||
impl<F, Args> const FnOnce<Args> for SyncView<F>
|
||||
where
|
||||
F: [const] FnOnce<Args>,
|
||||
Args: Tuple,
|
||||
{
|
||||
type Output = F::Output;
|
||||
|
||||
extern "rust-call" fn call_once(self, args: Args) -> Self::Output {
|
||||
self.into_inner().call_once(args)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "const_trait_impl", issue = "143874")]
|
||||
impl<F, Args> const FnMut<Args> for SyncView<F>
|
||||
where
|
||||
F: [const] FnMut<Args>,
|
||||
Args: Tuple,
|
||||
{
|
||||
extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output {
|
||||
self.as_mut().call_mut(args)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "const_trait_impl", issue = "143874")]
|
||||
impl<F, Args> const Fn<Args> for SyncView<F>
|
||||
where
|
||||
F: Sync + [const] Fn<Args>,
|
||||
Args: Tuple,
|
||||
{
|
||||
extern "rust-call" fn call(&self, args: Args) -> Self::Output {
|
||||
self.as_ref().call(args)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<F, Args> AsyncFnOnce<Args> for SyncView<F>
|
||||
where
|
||||
F: AsyncFnOnce<Args>,
|
||||
Args: Tuple,
|
||||
{
|
||||
type CallOnceFuture = F::CallOnceFuture;
|
||||
|
||||
type Output = F::Output;
|
||||
|
||||
extern "rust-call" fn async_call_once(self, args: Args) -> Self::CallOnceFuture {
|
||||
self.into_inner().async_call_once(args)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<F, Args> AsyncFnMut<Args> for SyncView<F>
|
||||
where
|
||||
F: AsyncFnMut<Args>,
|
||||
Args: Tuple,
|
||||
{
|
||||
type CallRefFuture<'a>
|
||||
= F::CallRefFuture<'a>
|
||||
where
|
||||
F: 'a;
|
||||
|
||||
extern "rust-call" fn async_call_mut(&mut self, args: Args) -> Self::CallRefFuture<'_> {
|
||||
self.as_mut().async_call_mut(args)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<F, Args> AsyncFn<Args> for SyncView<F>
|
||||
where
|
||||
F: Sync + AsyncFn<Args>,
|
||||
Args: Tuple,
|
||||
{
|
||||
extern "rust-call" fn async_call(&self, args: Args) -> Self::CallRefFuture<'_> {
|
||||
self.as_ref().async_call(args)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<T> Future for SyncView<T>
|
||||
where
|
||||
T: Future + ?Sized,
|
||||
{
|
||||
type Output = T::Output;
|
||||
|
||||
#[inline]
|
||||
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||
self.as_pin_mut().poll(cx)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "coroutine_trait", issue = "43122")] // also #98407
|
||||
impl<R, G> Coroutine<R> for SyncView<G>
|
||||
where
|
||||
G: Coroutine<R> + ?Sized,
|
||||
{
|
||||
type Yield = G::Yield;
|
||||
type Return = G::Return;
|
||||
|
||||
#[inline]
|
||||
fn resume(self: Pin<&mut Self>, arg: R) -> CoroutineState<Self::Yield, Self::Return> {
|
||||
G::resume(self.as_pin_mut(), arg)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
|
||||
impl<T> const AsRef<T> for SyncView<T>
|
||||
where
|
||||
T: Sync + ?Sized,
|
||||
{
|
||||
/// Gets shared access to the underlying value.
|
||||
#[inline]
|
||||
fn as_ref(&self) -> &T {
|
||||
&self.inner
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
|
||||
impl<T> const AsMut<T> for SyncView<T>
|
||||
where
|
||||
T: ?Sized,
|
||||
{
|
||||
/// Gets exclusive access to the underlying value.
|
||||
#[inline]
|
||||
fn as_mut(&mut self) -> &mut T {
|
||||
&mut self.inner
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "const_clone", issue = "142757")]
|
||||
impl<T> const Clone for SyncView<T>
|
||||
where
|
||||
T: Sync + [const] Clone,
|
||||
{
|
||||
#[inline]
|
||||
fn clone(&self) -> Self {
|
||||
Self { inner: self.inner.clone() }
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
#[unstable(feature = "trivial_clone", issue = "none")]
|
||||
#[rustc_const_unstable(feature = "const_clone", issue = "142757")]
|
||||
unsafe impl<T> const TrivialClone for SyncView<T> where T: Sync + [const] TrivialClone {}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<T> Copy for SyncView<T> where T: Sync + Copy {}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
|
||||
impl<T, U> const PartialEq<SyncView<U>> for SyncView<T>
|
||||
where
|
||||
T: Sync + [const] PartialEq<U> + ?Sized,
|
||||
U: Sync + ?Sized,
|
||||
{
|
||||
#[inline]
|
||||
fn eq(&self, other: &SyncView<U>) -> bool {
|
||||
self.inner == other.inner
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<T> StructuralPartialEq for SyncView<T> where T: Sync + StructuralPartialEq + ?Sized {}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
|
||||
impl<T> const Eq for SyncView<T> where T: Sync + [const] Eq + ?Sized {}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
impl<T> Hash for SyncView<T>
|
||||
where
|
||||
T: Sync + Hash + ?Sized,
|
||||
{
|
||||
#[inline]
|
||||
fn hash<H: Hasher>(&self, state: &mut H) {
|
||||
Hash::hash(&self.inner, state)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
|
||||
impl<T, U> const PartialOrd<SyncView<U>> for SyncView<T>
|
||||
where
|
||||
T: Sync + [const] PartialOrd<U> + ?Sized,
|
||||
U: Sync + ?Sized,
|
||||
{
|
||||
#[inline]
|
||||
fn partial_cmp(&self, other: &SyncView<U>) -> Option<Ordering> {
|
||||
self.inner.partial_cmp(&other.inner)
|
||||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
|
||||
impl<T> const Ord for SyncView<T>
|
||||
where
|
||||
T: Sync + [const] Ord + ?Sized,
|
||||
{
|
||||
#[inline]
|
||||
fn cmp(&self, other: &Self) -> Ordering {
|
||||
self.inner.cmp(&other.inner)
|
||||
}
|
||||
}
|
||||
@@ -172,7 +172,7 @@
|
||||
|
||||
// These come from `core` & `alloc` and only in one flavor: no poisoning.
|
||||
#[unstable(feature = "exclusive_wrapper", issue = "98407")]
|
||||
pub use core::sync::Exclusive;
|
||||
pub use core::sync::SyncView;
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub use core::sync::atomic;
|
||||
|
||||
|
||||
@@ -4,11 +4,11 @@
|
||||
fn f() {}
|
||||
|
||||
fn g() {
|
||||
become std::sync::Exclusive::new(f)() //~ error: tail calls can only be performed with function definitions or pointers
|
||||
become std::sync::SyncView::new(f)() //~ error: tail calls can only be performed with function definitions or pointers
|
||||
}
|
||||
|
||||
fn h() {
|
||||
become (&mut &std::sync::Exclusive::new(f))() //~ error: tail calls can only be performed with function definitions or pointers
|
||||
become (&mut &std::sync::SyncView::new(f))() //~ error: tail calls can only be performed with function definitions or pointers
|
||||
}
|
||||
|
||||
fn i() {
|
||||
|
||||
@@ -1,18 +1,18 @@
|
||||
error: tail calls can only be performed with function definitions or pointers
|
||||
--> $DIR/callee_is_weird.rs:7:12
|
||||
|
|
||||
LL | become std::sync::Exclusive::new(f)()
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
LL | become std::sync::SyncView::new(f)()
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: callee has type `Exclusive<fn() {f}>`
|
||||
= note: callee has type `SyncView<fn() {f}>`
|
||||
|
||||
error: tail calls can only be performed with function definitions or pointers
|
||||
--> $DIR/callee_is_weird.rs:11:12
|
||||
|
|
||||
LL | become (&mut &std::sync::Exclusive::new(f))()
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
LL | become (&mut &std::sync::SyncView::new(f))()
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: callee has type `&Exclusive<fn() {f}>`
|
||||
= note: callee has type `&SyncView<fn() {f}>`
|
||||
|
||||
error: tail calls can only be performed with function definitions or pointers
|
||||
--> $DIR/callee_is_weird.rs:22:12
|
||||
|
||||
@@ -387,7 +387,7 @@ LL | fn in_impl_Fn_return_in_return() -> &'static impl Fn() -> impl Debug { pani
|
||||
where A: std::marker::Tuple, F: Fn<A>, F: ?Sized;
|
||||
- impl<Args, F, A> Fn<Args> for Box<F, A>
|
||||
where Args: std::marker::Tuple, F: Fn<Args>, A: Allocator, F: ?Sized;
|
||||
- impl<F, Args> Fn<Args> for Exclusive<F>
|
||||
- impl<F, Args> Fn<Args> for SyncView<F>
|
||||
where F: Sync, F: Fn<Args>, Args: std::marker::Tuple;
|
||||
|
||||
error: unconstrained opaque type
|
||||
|
||||
@@ -12,7 +12,7 @@ LL | x = unconstrained_map();
|
||||
where A: std::marker::Tuple, F: Fn<A>, F: ?Sized;
|
||||
- impl<Args, F, A> Fn<Args> for Box<F, A>
|
||||
where Args: std::marker::Tuple, F: Fn<Args>, A: Allocator, F: ?Sized;
|
||||
- impl<F, Args> Fn<Args> for Exclusive<F>
|
||||
- impl<F, Args> Fn<Args> for SyncView<F>
|
||||
where F: Sync, F: Fn<Args>, Args: std::marker::Tuple;
|
||||
note: required by a bound in `unconstrained_map`
|
||||
--> $DIR/well-formed-in-relate.rs:21:25
|
||||
|
||||
Reference in New Issue
Block a user