From 13da951868a1b48108592cadbf7627d48322c859 Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Thu, 9 Aug 2018 18:20:22 +0300 Subject: [PATCH 01/18] move PinMut into pin module and export through std --- src/liballoc/boxed.rs | 3 +- src/libcore/future/future.rs | 2 +- src/libcore/future/future_obj.rs | 2 +- src/libcore/lib.rs | 1 + src/libcore/mem.rs | 149 +--------------------------- src/libcore/option.rs | 2 +- src/libcore/pin.rs | 162 +++++++++++++++++++++++++++++++ src/libstd/future.rs | 2 +- src/libstd/lib.rs | 1 + src/libstd/macros.rs | 2 +- src/libstd/panic.rs | 2 +- src/libstd/pin.rs | 15 +++ src/test/run-pass/async-await.rs | 2 +- src/test/run-pass/futures-api.rs | 2 +- 14 files changed, 191 insertions(+), 156 deletions(-) create mode 100644 src/libcore/pin.rs create mode 100644 src/libstd/pin.rs diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index 32292e61f94d2..94c7b87317951 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -64,7 +64,8 @@ use core::future::{Future, FutureObj, LocalFutureObj, UnsafeFutureObj}; use core::hash::{Hash, Hasher}; use core::iter::FusedIterator; use core::marker::{Unpin, Unsize}; -use core::mem::{self, PinMut}; +use core::mem; +use core::pin::PinMut; use core::ops::{CoerceUnsized, Deref, DerefMut, Generator, GeneratorState}; use core::ptr::{self, NonNull, Unique}; use core::task::{Context, Poll, Spawn, SpawnErrorKind, SpawnObjError}; diff --git a/src/libcore/future/future.rs b/src/libcore/future/future.rs index 10b4ca9b0b27a..520b6ebbbaaa5 100644 --- a/src/libcore/future/future.rs +++ b/src/libcore/future/future.rs @@ -12,7 +12,7 @@ reason = "futures in libcore are unstable", issue = "50547")] -use mem::PinMut; +use pin::PinMut; use marker::Unpin; use task::{self, Poll}; diff --git a/src/libcore/future/future_obj.rs b/src/libcore/future/future_obj.rs index 2df870a011dcb..68fe461aeae86 100644 --- a/src/libcore/future/future_obj.rs +++ b/src/libcore/future/future_obj.rs @@ -15,7 +15,7 @@ use fmt; use future::Future; use marker::{PhantomData, Unpin}; -use mem::PinMut; +use pin::PinMut; use task::{Context, Poll}; /// A custom trait object for polling futures, roughly akin to diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index e85bf1dfcad23..aaeacd1576140 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -191,6 +191,7 @@ pub mod cell; pub mod char; pub mod panic; pub mod panicking; +pub mod pin; pub mod iter; pub mod option; pub mod raw; diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs index ea711c69393a4..aac6b3333ed19 100644 --- a/src/libcore/mem.rs +++ b/src/libcore/mem.rs @@ -18,13 +18,11 @@ use clone; use cmp; use fmt; -use future::{Future, UnsafeFutureObj}; use hash; use intrinsics; -use marker::{Copy, PhantomData, Sized, Unpin, Unsize}; +use marker::{Copy, PhantomData, Sized}; use ptr; -use task::{Context, Poll}; -use ops::{Deref, DerefMut, CoerceUnsized}; +use ops::{Deref, DerefMut}; #[stable(feature = "rust1", since = "1.0.0")] pub use intrinsics::transmute; @@ -1024,146 +1022,3 @@ impl DerefMut for ManuallyDrop { &mut self.value } } - -/// A pinned reference. -/// -/// A pinned reference is a lot like a mutable reference, except that it is not -/// safe to move a value out of a pinned reference unless the type of that -/// value implements the `Unpin` trait. -#[unstable(feature = "pin", issue = "49150")] -#[fundamental] -pub struct PinMut<'a, T: ?Sized + 'a> { - inner: &'a mut T, -} - -#[unstable(feature = "pin", issue = "49150")] -impl<'a, T: ?Sized + Unpin> PinMut<'a, T> { - /// Construct a new `PinMut` around a reference to some data of a type that - /// implements `Unpin`. - #[unstable(feature = "pin", issue = "49150")] - pub fn new(reference: &'a mut T) -> PinMut<'a, T> { - PinMut { inner: reference } - } - - /// Get a mutable reference to the data inside of this `PinMut`. - #[unstable(feature = "pin", issue = "49150")] - pub fn get_mut(this: PinMut<'a, T>) -> &'a mut T { - this.inner - } -} - - -#[unstable(feature = "pin", issue = "49150")] -impl<'a, T: ?Sized> PinMut<'a, T> { - /// Construct a new `PinMut` around a reference to some data of a type that - /// may or may not implement `Unpin`. - /// - /// This constructor is unsafe because we do not know what will happen with - /// that data after the reference ends. If you cannot guarantee that the - /// data will never move again, calling this constructor is invalid. - #[unstable(feature = "pin", issue = "49150")] - pub unsafe fn new_unchecked(reference: &'a mut T) -> PinMut<'a, T> { - PinMut { inner: reference } - } - - /// Reborrow a `PinMut` for a shorter lifetime. - /// - /// For example, `PinMut::get_mut(x.reborrow())` (unsafely) returns a - /// short-lived mutable reference reborrowing from `x`. - #[unstable(feature = "pin", issue = "49150")] - pub fn reborrow<'b>(&'b mut self) -> PinMut<'b, T> { - PinMut { inner: self.inner } - } - - /// Get a mutable reference to the data inside of this `PinMut`. - /// - /// This function is unsafe. You must guarantee that you will never move - /// the data out of the mutable reference you receive when you call this - /// function. - #[unstable(feature = "pin", issue = "49150")] - pub unsafe fn get_mut_unchecked(this: PinMut<'a, T>) -> &'a mut T { - this.inner - } - - /// Construct a new pin by mapping the interior value. - /// - /// For example, if you wanted to get a `PinMut` of a field of something, - /// you could use this to get access to that field in one line of code. - /// - /// This function is unsafe. You must guarantee that the data you return - /// will not move so long as the argument value does not move (for example, - /// because it is one of the fields of that value), and also that you do - /// not move out of the argument you receive to the interior function. - #[unstable(feature = "pin", issue = "49150")] - pub unsafe fn map_unchecked(this: PinMut<'a, T>, f: F) -> PinMut<'a, U> where - F: FnOnce(&mut T) -> &mut U - { - PinMut { inner: f(this.inner) } - } - - /// Assign a new value to the memory behind the pinned reference. - #[unstable(feature = "pin", issue = "49150")] - pub fn set(this: PinMut<'a, T>, value: T) - where T: Sized, - { - *this.inner = value; - } -} - -#[unstable(feature = "pin", issue = "49150")] -impl<'a, T: ?Sized> Deref for PinMut<'a, T> { - type Target = T; - - fn deref(&self) -> &T { - &*self.inner - } -} - -#[unstable(feature = "pin", issue = "49150")] -impl<'a, T: ?Sized + Unpin> DerefMut for PinMut<'a, T> { - fn deref_mut(&mut self) -> &mut T { - self.inner - } -} - -#[unstable(feature = "pin", issue = "49150")] -impl<'a, T: fmt::Debug + ?Sized> fmt::Debug for PinMut<'a, T> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Debug::fmt(&**self, f) - } -} - -#[unstable(feature = "pin", issue = "49150")] -impl<'a, T: fmt::Display + ?Sized> fmt::Display for PinMut<'a, T> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(&**self, f) - } -} - -#[unstable(feature = "pin", issue = "49150")] -impl<'a, T: ?Sized> fmt::Pointer for PinMut<'a, T> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Pointer::fmt(&(&*self.inner as *const T), f) - } -} - -#[unstable(feature = "pin", issue = "49150")] -impl<'a, T: ?Sized + Unsize, U: ?Sized> CoerceUnsized> for PinMut<'a, T> {} - -#[unstable(feature = "pin", issue = "49150")] -impl<'a, T: ?Sized> Unpin for PinMut<'a, T> {} - -#[unstable(feature = "futures_api", issue = "50547")] -unsafe impl<'a, T, F> UnsafeFutureObj<'a, T> for PinMut<'a, F> - where F: Future + 'a -{ - fn into_raw(self) -> *mut () { - unsafe { PinMut::get_mut_unchecked(self) as *mut F as *mut () } - } - - unsafe fn poll(ptr: *mut (), cx: &mut Context) -> Poll { - PinMut::new_unchecked(&mut *(ptr as *mut F)).poll(cx) - } - - unsafe fn drop(_ptr: *mut ()) {} -} diff --git a/src/libcore/option.rs b/src/libcore/option.rs index f743fbfd0752b..3879abb0af973 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -147,7 +147,7 @@ use iter::{FromIterator, FusedIterator, TrustedLen}; use {hint, mem, ops::{self, Deref}}; -use mem::PinMut; +use pin::PinMut; // Note that this is not a lang item per se, but it has a hidden dependency on // `Iterator`, which is one. The compiler assumes that the `next` method of diff --git a/src/libcore/pin.rs b/src/libcore/pin.rs new file mode 100644 index 0000000000000..a41185e231bfa --- /dev/null +++ b/src/libcore/pin.rs @@ -0,0 +1,162 @@ +// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! Types which pin data to its location in memory + +#![unstable(feature = "pin", issue = "49150")] + +use fmt; +use future::{Future, UnsafeFutureObj}; +use marker::{Sized, Unpin, Unsize}; +use task::{Context, Poll}; +use ops::{Deref, DerefMut, CoerceUnsized}; + +/// A pinned reference. +/// +/// A pinned reference is a lot like a mutable reference, except that it is not +/// safe to move a value out of a pinned reference unless the type of that +/// value implements the `Unpin` trait. +#[unstable(feature = "pin", issue = "49150")] +#[fundamental] +pub struct PinMut<'a, T: ?Sized + 'a> { + inner: &'a mut T, +} + +#[unstable(feature = "pin", issue = "49150")] +impl<'a, T: ?Sized + Unpin> PinMut<'a, T> { + /// Construct a new `PinMut` around a reference to some data of a type that + /// implements `Unpin`. + #[unstable(feature = "pin", issue = "49150")] + pub fn new(reference: &'a mut T) -> PinMut<'a, T> { + PinMut { inner: reference } + } + + /// Get a mutable reference to the data inside of this `PinMut`. + #[unstable(feature = "pin", issue = "49150")] + pub fn get_mut(this: PinMut<'a, T>) -> &'a mut T { + this.inner + } +} + + +#[unstable(feature = "pin", issue = "49150")] +impl<'a, T: ?Sized> PinMut<'a, T> { + /// Construct a new `PinMut` around a reference to some data of a type that + /// may or may not implement `Unpin`. + /// + /// This constructor is unsafe because we do not know what will happen with + /// that data after the reference ends. If you cannot guarantee that the + /// data will never move again, calling this constructor is invalid. + #[unstable(feature = "pin", issue = "49150")] + pub unsafe fn new_unchecked(reference: &'a mut T) -> PinMut<'a, T> { + PinMut { inner: reference } + } + + /// Reborrow a `PinMut` for a shorter lifetime. + /// + /// For example, `PinMut::get_mut(x.reborrow())` (unsafely) returns a + /// short-lived mutable reference reborrowing from `x`. + #[unstable(feature = "pin", issue = "49150")] + pub fn reborrow<'b>(&'b mut self) -> PinMut<'b, T> { + PinMut { inner: self.inner } + } + + /// Get a mutable reference to the data inside of this `PinMut`. + /// + /// This function is unsafe. You must guarantee that you will never move + /// the data out of the mutable reference you receive when you call this + /// function. + #[unstable(feature = "pin", issue = "49150")] + pub unsafe fn get_mut_unchecked(this: PinMut<'a, T>) -> &'a mut T { + this.inner + } + + /// Construct a new pin by mapping the interior value. + /// + /// For example, if you wanted to get a `PinMut` of a field of something, + /// you could use this to get access to that field in one line of code. + /// + /// This function is unsafe. You must guarantee that the data you return + /// will not move so long as the argument value does not move (for example, + /// because it is one of the fields of that value), and also that you do + /// not move out of the argument you receive to the interior function. + #[unstable(feature = "pin", issue = "49150")] + pub unsafe fn map_unchecked(this: PinMut<'a, T>, f: F) -> PinMut<'a, U> where + F: FnOnce(&mut T) -> &mut U + { + PinMut { inner: f(this.inner) } + } + + /// Assign a new value to the memory behind the pinned reference. + #[unstable(feature = "pin", issue = "49150")] + pub fn set(this: PinMut<'a, T>, value: T) + where T: Sized, + { + *this.inner = value; + } +} + +#[unstable(feature = "pin", issue = "49150")] +impl<'a, T: ?Sized> Deref for PinMut<'a, T> { + type Target = T; + + fn deref(&self) -> &T { + &*self.inner + } +} + +#[unstable(feature = "pin", issue = "49150")] +impl<'a, T: ?Sized + Unpin> DerefMut for PinMut<'a, T> { + fn deref_mut(&mut self) -> &mut T { + self.inner + } +} + +#[unstable(feature = "pin", issue = "49150")] +impl<'a, T: fmt::Debug + ?Sized> fmt::Debug for PinMut<'a, T> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Debug::fmt(&**self, f) + } +} + +#[unstable(feature = "pin", issue = "49150")] +impl<'a, T: fmt::Display + ?Sized> fmt::Display for PinMut<'a, T> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Display::fmt(&**self, f) + } +} + +#[unstable(feature = "pin", issue = "49150")] +impl<'a, T: ?Sized> fmt::Pointer for PinMut<'a, T> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Pointer::fmt(&(&*self.inner as *const T), f) + } +} + +#[unstable(feature = "pin", issue = "49150")] +impl<'a, T: ?Sized + Unsize, U: ?Sized> CoerceUnsized> for PinMut<'a, T> {} + +#[unstable(feature = "pin", issue = "49150")] +impl<'a, T: ?Sized> Unpin for PinMut<'a, T> {} + +#[unstable(feature = "futures_api", issue = "50547")] +unsafe impl<'a, T, F> UnsafeFutureObj<'a, T> for PinMut<'a, F> + where F: Future + 'a +{ + fn into_raw(self) -> *mut () { + unsafe { PinMut::get_mut_unchecked(self) as *mut F as *mut () } + } + + unsafe fn poll(ptr: *mut (), cx: &mut Context) -> Poll { + PinMut::new_unchecked(&mut *(ptr as *mut F)).poll(cx) + } + + unsafe fn drop(_ptr: *mut ()) {} +} diff --git a/src/libstd/future.rs b/src/libstd/future.rs index cadb5c0ba5d0e..d9657f691c79f 100644 --- a/src/libstd/future.rs +++ b/src/libstd/future.rs @@ -12,7 +12,7 @@ use core::cell::Cell; use core::marker::Unpin; -use core::mem::PinMut; +use core::pin::PinMut; use core::option::Option; use core::ptr::NonNull; use core::task::{self, Poll}; diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index ade297219d221..ac65274d25463 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -466,6 +466,7 @@ pub mod num; pub mod os; pub mod panic; pub mod path; +pub mod pin; pub mod process; pub mod sync; pub mod time; diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs index f15494c5fd7f5..6945a41a5e73b 100644 --- a/src/libstd/macros.rs +++ b/src/libstd/macros.rs @@ -230,7 +230,7 @@ macro_rules! await { loop { if let $crate::task::Poll::Ready(x) = $crate::future::poll_in_task_cx(unsafe { - $crate::mem::PinMut::new_unchecked(&mut pinned) + $crate::pin::PinMut::new_unchecked(&mut pinned) }) { break x; diff --git a/src/libstd/panic.rs b/src/libstd/panic.rs index b8c1c4f9e68e7..47547aedcbdec 100644 --- a/src/libstd/panic.rs +++ b/src/libstd/panic.rs @@ -16,7 +16,7 @@ use any::Any; use cell::UnsafeCell; use fmt; use future::Future; -use mem::PinMut; +use pin::PinMut; use ops::{Deref, DerefMut}; use panicking; use ptr::{Unique, NonNull}; diff --git a/src/libstd/pin.rs b/src/libstd/pin.rs new file mode 100644 index 0000000000000..9d7a9d4404a78 --- /dev/null +++ b/src/libstd/pin.rs @@ -0,0 +1,15 @@ +// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! Types which pin data to its location in memory + +#![unstable(feature = "pin", issue = "49150")] + +pub use core::pin::*; diff --git a/src/test/run-pass/async-await.rs b/src/test/run-pass/async-await.rs index 99b8ad83bf6cc..7e79a210f1552 100644 --- a/src/test/run-pass/async-await.rs +++ b/src/test/run-pass/async-await.rs @@ -13,7 +13,7 @@ #![feature(arbitrary_self_types, async_await, await_macro, futures_api, pin)] use std::boxed::PinBox; -use std::mem::PinMut; +use std::pin::PinMut; use std::future::Future; use std::sync::{ Arc, diff --git a/src/test/run-pass/futures-api.rs b/src/test/run-pass/futures-api.rs index 476cb48c0d2ee..ff2facd3cd289 100644 --- a/src/test/run-pass/futures-api.rs +++ b/src/test/run-pass/futures-api.rs @@ -13,7 +13,7 @@ use std::boxed::PinBox; use std::future::Future; -use std::mem::PinMut; +use std::pin::PinMut; use std::rc::Rc; use std::sync::{ Arc, From 971d7ed24966e64c8ec8352ada433b672c25012f Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Thu, 9 Aug 2018 19:33:57 +0300 Subject: [PATCH 02/18] move PinBox into pin module and export through std --- src/liballoc/boxed.rs | 202 --------------------------- src/liballoc/lib.rs | 1 + src/liballoc/pin.rs | 225 ++++++++++++++++++++++++++++++ src/libstd/pin.rs | 2 + src/test/run-pass/async-await.rs | 2 +- src/test/run-pass/futures-api.rs | 2 +- src/test/rustdoc-js/pinbox-new.js | 4 +- src/test/rustdoc-js/vec-new.js | 2 +- 8 files changed, 233 insertions(+), 207 deletions(-) create mode 100644 src/liballoc/pin.rs diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index 94c7b87317951..b5c2fd7526da1 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -759,166 +759,6 @@ impl Generator for Box } } -/// A pinned, heap allocated reference. -#[unstable(feature = "pin", issue = "49150")] -#[fundamental] -#[repr(transparent)] -pub struct PinBox { - inner: Box, -} - -#[unstable(feature = "pin", issue = "49150")] -impl PinBox { - /// Allocate memory on the heap, move the data into it and pin it. - #[unstable(feature = "pin", issue = "49150")] - pub fn new(data: T) -> PinBox { - PinBox { inner: Box::new(data) } - } -} - -#[unstable(feature = "pin", issue = "49150")] -impl PinBox { - /// Get a pinned reference to the data in this PinBox. - #[inline] - pub fn as_pin_mut<'a>(&'a mut self) -> PinMut<'a, T> { - unsafe { PinMut::new_unchecked(&mut *self.inner) } - } - - /// Constructs a `PinBox` from a raw pointer. - /// - /// After calling this function, the raw pointer is owned by the - /// resulting `PinBox`. Specifically, the `PinBox` destructor will call - /// the destructor of `T` and free the allocated memory. Since the - /// way `PinBox` allocates and releases memory is unspecified, the - /// only valid pointer to pass to this function is the one taken - /// from another `PinBox` via the [`PinBox::into_raw`] function. - /// - /// This function is unsafe because improper use may lead to - /// memory problems. For example, a double-free may occur if the - /// function is called twice on the same raw pointer. - /// - /// [`PinBox::into_raw`]: struct.PinBox.html#method.into_raw - /// - /// # Examples - /// - /// ``` - /// #![feature(pin)] - /// use std::boxed::PinBox; - /// let x = PinBox::new(5); - /// let ptr = PinBox::into_raw(x); - /// let x = unsafe { PinBox::from_raw(ptr) }; - /// ``` - #[inline] - pub unsafe fn from_raw(raw: *mut T) -> Self { - PinBox { inner: Box::from_raw(raw) } - } - - /// Consumes the `PinBox`, returning the wrapped raw pointer. - /// - /// After calling this function, the caller is responsible for the - /// memory previously managed by the `PinBox`. In particular, the - /// caller should properly destroy `T` and release the memory. The - /// proper way to do so is to convert the raw pointer back into a - /// `PinBox` with the [`PinBox::from_raw`] function. - /// - /// Note: this is an associated function, which means that you have - /// to call it as `PinBox::into_raw(b)` instead of `b.into_raw()`. This - /// is so that there is no conflict with a method on the inner type. - /// - /// [`PinBox::from_raw`]: struct.PinBox.html#method.from_raw - /// - /// # Examples - /// - /// ``` - /// #![feature(pin)] - /// use std::boxed::PinBox; - /// let x = PinBox::new(5); - /// let ptr = PinBox::into_raw(x); - /// ``` - #[inline] - pub fn into_raw(b: PinBox) -> *mut T { - Box::into_raw(b.inner) - } - - /// Get a mutable reference to the data inside this PinBox. - /// - /// This function is unsafe. Users must guarantee that the data is never - /// moved out of this reference. - #[inline] - pub unsafe fn get_mut<'a>(this: &'a mut PinBox) -> &'a mut T { - &mut *this.inner - } - - /// Convert this PinBox into an unpinned Box. - /// - /// This function is unsafe. Users must guarantee that the data is never - /// moved out of the box. - #[inline] - pub unsafe fn unpin(this: PinBox) -> Box { - this.inner - } -} - -#[unstable(feature = "pin", issue = "49150")] -impl From> for PinBox { - fn from(boxed: Box) -> PinBox { - PinBox { inner: boxed } - } -} - -#[unstable(feature = "pin", issue = "49150")] -impl From> for Box { - fn from(pinned: PinBox) -> Box { - pinned.inner - } -} - -#[unstable(feature = "pin", issue = "49150")] -impl Deref for PinBox { - type Target = T; - - fn deref(&self) -> &T { - &*self.inner - } -} - -#[unstable(feature = "pin", issue = "49150")] -impl DerefMut for PinBox { - fn deref_mut(&mut self) -> &mut T { - &mut *self.inner - } -} - -#[unstable(feature = "pin", issue = "49150")] -impl fmt::Display for PinBox { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(&*self.inner, f) - } -} - -#[unstable(feature = "pin", issue = "49150")] -impl fmt::Debug for PinBox { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Debug::fmt(&*self.inner, f) - } -} - -#[unstable(feature = "pin", issue = "49150")] -impl fmt::Pointer for PinBox { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - // It's not possible to extract the inner Uniq directly from the Box, - // instead we cast it to a *const which aliases the Unique - let ptr: *const T = &*self.inner; - fmt::Pointer::fmt(&ptr, f) - } -} - -#[unstable(feature = "pin", issue = "49150")] -impl, U: ?Sized> CoerceUnsized> for PinBox {} - -#[unstable(feature = "pin", issue = "49150")] -impl Unpin for PinBox {} - #[unstable(feature = "futures_api", issue = "50547")] impl Future for Box { type Output = F::Output; @@ -928,15 +768,6 @@ impl Future for Box { } } -#[unstable(feature = "futures_api", issue = "50547")] -impl Future for PinBox { - type Output = F::Output; - - fn poll(mut self: PinMut, cx: &mut Context) -> Poll { - self.as_pin_mut().poll(cx) - } -} - #[unstable(feature = "futures_api", issue = "50547")] unsafe impl<'a, T, F> UnsafeFutureObj<'a, T> for Box where F: Future + 'a @@ -956,25 +787,6 @@ unsafe impl<'a, T, F> UnsafeFutureObj<'a, T> for Box } } -#[unstable(feature = "futures_api", issue = "50547")] -unsafe impl<'a, T, F> UnsafeFutureObj<'a, T> for PinBox - where F: Future + 'a -{ - fn into_raw(self) -> *mut () { - PinBox::into_raw(self) as *mut () - } - - unsafe fn poll(ptr: *mut (), cx: &mut Context) -> Poll { - let ptr = ptr as *mut F; - let pin: PinMut = PinMut::new_unchecked(&mut *ptr); - pin.poll(cx) - } - - unsafe fn drop(ptr: *mut ()) { - drop(PinBox::from_raw(ptr as *mut F)) - } -} - #[unstable(feature = "futures_api", issue = "50547")] impl Spawn for Box where Sp: Spawn + ?Sized @@ -991,13 +803,6 @@ impl Spawn for Box } } -#[unstable(feature = "futures_api", issue = "50547")] -impl<'a, F: Future + Send + 'a> From> for FutureObj<'a, ()> { - fn from(boxed: PinBox) -> Self { - FutureObj::new(boxed) - } -} - #[unstable(feature = "futures_api", issue = "50547")] impl<'a, F: Future + Send + 'a> From> for FutureObj<'a, ()> { fn from(boxed: Box) -> Self { @@ -1005,13 +810,6 @@ impl<'a, F: Future + Send + 'a> From> for FutureObj<'a, ()> } } -#[unstable(feature = "futures_api", issue = "50547")] -impl<'a, F: Future + 'a> From> for LocalFutureObj<'a, ()> { - fn from(boxed: PinBox) -> Self { - LocalFutureObj::new(boxed) - } -} - #[unstable(feature = "futures_api", issue = "50547")] impl<'a, F: Future + 'a> From> for LocalFutureObj<'a, ()> { fn from(boxed: Box) -> Self { diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs index bcdfd8c9aa5d5..99e8f8df0d9e6 100644 --- a/src/liballoc/lib.rs +++ b/src/liballoc/lib.rs @@ -159,6 +159,7 @@ pub mod collections; pub mod sync; pub mod rc; pub mod raw_vec; +pub mod pin; pub mod prelude; pub mod borrow; pub mod fmt; diff --git a/src/liballoc/pin.rs b/src/liballoc/pin.rs new file mode 100644 index 0000000000000..221a55472ab08 --- /dev/null +++ b/src/liballoc/pin.rs @@ -0,0 +1,225 @@ +// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! Types which pin data to its location in memory + +#![unstable(feature = "pin", issue = "49150")] + +use core::convert::From; +use core::fmt; +use core::future::{Future, FutureObj, LocalFutureObj, UnsafeFutureObj}; +use core::marker::{Unpin, Unsize}; +use core::pin::PinMut; +use core::ops::{CoerceUnsized, Deref, DerefMut}; +use core::task::{Context, Poll}; + +use boxed::Box; + +/// A pinned, heap allocated reference. +#[unstable(feature = "pin", issue = "49150")] +#[fundamental] +#[repr(transparent)] +pub struct PinBox { + inner: Box, +} + +#[unstable(feature = "pin", issue = "49150")] +impl PinBox { + /// Allocate memory on the heap, move the data into it and pin it. + #[unstable(feature = "pin", issue = "49150")] + pub fn new(data: T) -> PinBox { + PinBox { inner: Box::new(data) } + } +} + +#[unstable(feature = "pin", issue = "49150")] +impl PinBox { + /// Get a pinned reference to the data in this PinBox. + #[inline] + pub fn as_pin_mut<'a>(&'a mut self) -> PinMut<'a, T> { + unsafe { PinMut::new_unchecked(&mut *self.inner) } + } + + /// Constructs a `PinBox` from a raw pointer. + /// + /// After calling this function, the raw pointer is owned by the + /// resulting `PinBox`. Specifically, the `PinBox` destructor will call + /// the destructor of `T` and free the allocated memory. Since the + /// way `PinBox` allocates and releases memory is unspecified, the + /// only valid pointer to pass to this function is the one taken + /// from another `PinBox` via the [`PinBox::into_raw`] function. + /// + /// This function is unsafe because improper use may lead to + /// memory problems. For example, a double-free may occur if the + /// function is called twice on the same raw pointer. + /// + /// [`PinBox::into_raw`]: struct.PinBox.html#method.into_raw + /// + /// # Examples + /// + /// ``` + /// #![feature(pin)] + /// use std::pin::PinBox; + /// let x = PinBox::new(5); + /// let ptr = PinBox::into_raw(x); + /// let x = unsafe { PinBox::from_raw(ptr) }; + /// ``` + #[inline] + pub unsafe fn from_raw(raw: *mut T) -> Self { + PinBox { inner: Box::from_raw(raw) } + } + + /// Consumes the `PinBox`, returning the wrapped raw pointer. + /// + /// After calling this function, the caller is responsible for the + /// memory previously managed by the `PinBox`. In particular, the + /// caller should properly destroy `T` and release the memory. The + /// proper way to do so is to convert the raw pointer back into a + /// `PinBox` with the [`PinBox::from_raw`] function. + /// + /// Note: this is an associated function, which means that you have + /// to call it as `PinBox::into_raw(b)` instead of `b.into_raw()`. This + /// is so that there is no conflict with a method on the inner type. + /// + /// [`PinBox::from_raw`]: struct.PinBox.html#method.from_raw + /// + /// # Examples + /// + /// ``` + /// #![feature(pin)] + /// use std::pin::PinBox; + /// let x = PinBox::new(5); + /// let ptr = PinBox::into_raw(x); + /// ``` + #[inline] + pub fn into_raw(b: PinBox) -> *mut T { + Box::into_raw(b.inner) + } + + /// Get a mutable reference to the data inside this PinBox. + /// + /// This function is unsafe. Users must guarantee that the data is never + /// moved out of this reference. + #[inline] + pub unsafe fn get_mut<'a>(this: &'a mut PinBox) -> &'a mut T { + &mut *this.inner + } + + /// Convert this PinBox into an unpinned Box. + /// + /// This function is unsafe. Users must guarantee that the data is never + /// moved out of the box. + #[inline] + pub unsafe fn unpin(this: PinBox) -> Box { + this.inner + } +} + +#[unstable(feature = "pin", issue = "49150")] +impl From> for PinBox { + fn from(boxed: Box) -> PinBox { + PinBox { inner: boxed } + } +} + +#[unstable(feature = "pin", issue = "49150")] +impl From> for Box { + fn from(pinned: PinBox) -> Box { + pinned.inner + } +} + +#[unstable(feature = "pin", issue = "49150")] +impl Deref for PinBox { + type Target = T; + + fn deref(&self) -> &T { + &*self.inner + } +} + +#[unstable(feature = "pin", issue = "49150")] +impl DerefMut for PinBox { + fn deref_mut(&mut self) -> &mut T { + &mut *self.inner + } +} + +#[unstable(feature = "pin", issue = "49150")] +impl fmt::Display for PinBox { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Display::fmt(&*self.inner, f) + } +} + +#[unstable(feature = "pin", issue = "49150")] +impl fmt::Debug for PinBox { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Debug::fmt(&*self.inner, f) + } +} + +#[unstable(feature = "pin", issue = "49150")] +impl fmt::Pointer for PinBox { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + // It's not possible to extract the inner Uniq directly from the Box, + // instead we cast it to a *const which aliases the Unique + let ptr: *const T = &*self.inner; + fmt::Pointer::fmt(&ptr, f) + } +} + +#[unstable(feature = "pin", issue = "49150")] +impl, U: ?Sized> CoerceUnsized> for PinBox {} + +#[unstable(feature = "pin", issue = "49150")] +impl Unpin for PinBox {} + +#[unstable(feature = "futures_api", issue = "50547")] +impl Future for PinBox { + type Output = F::Output; + + fn poll(mut self: PinMut, cx: &mut Context) -> Poll { + self.as_pin_mut().poll(cx) + } +} + +#[unstable(feature = "futures_api", issue = "50547")] +unsafe impl<'a, T, F> UnsafeFutureObj<'a, T> for PinBox + where F: Future + 'a +{ + fn into_raw(self) -> *mut () { + PinBox::into_raw(self) as *mut () + } + + unsafe fn poll(ptr: *mut (), cx: &mut Context) -> Poll { + let ptr = ptr as *mut F; + let pin: PinMut = PinMut::new_unchecked(&mut *ptr); + pin.poll(cx) + } + + unsafe fn drop(ptr: *mut ()) { + drop(PinBox::from_raw(ptr as *mut F)) + } +} + +#[unstable(feature = "futures_api", issue = "50547")] +impl<'a, F: Future + Send + 'a> From> for FutureObj<'a, ()> { + fn from(boxed: PinBox) -> Self { + FutureObj::new(boxed) + } +} + +#[unstable(feature = "futures_api", issue = "50547")] +impl<'a, F: Future + 'a> From> for LocalFutureObj<'a, ()> { + fn from(boxed: PinBox) -> Self { + LocalFutureObj::new(boxed) + } +} diff --git a/src/libstd/pin.rs b/src/libstd/pin.rs index 9d7a9d4404a78..b3c5b5feb8c48 100644 --- a/src/libstd/pin.rs +++ b/src/libstd/pin.rs @@ -13,3 +13,5 @@ #![unstable(feature = "pin", issue = "49150")] pub use core::pin::*; + +pub use alloc_crate::pin::*; diff --git a/src/test/run-pass/async-await.rs b/src/test/run-pass/async-await.rs index 7e79a210f1552..46f228459079a 100644 --- a/src/test/run-pass/async-await.rs +++ b/src/test/run-pass/async-await.rs @@ -12,7 +12,7 @@ #![feature(arbitrary_self_types, async_await, await_macro, futures_api, pin)] -use std::boxed::PinBox; +use std::pin::PinBox; use std::pin::PinMut; use std::future::Future; use std::sync::{ diff --git a/src/test/run-pass/futures-api.rs b/src/test/run-pass/futures-api.rs index ff2facd3cd289..69a04437691dd 100644 --- a/src/test/run-pass/futures-api.rs +++ b/src/test/run-pass/futures-api.rs @@ -11,7 +11,7 @@ #![feature(arbitrary_self_types, futures_api, pin)] #![allow(unused)] -use std::boxed::PinBox; +use std::pin::PinBox; use std::future::Future; use std::pin::PinMut; use std::rc::Rc; diff --git a/src/test/rustdoc-js/pinbox-new.js b/src/test/rustdoc-js/pinbox-new.js index 061c7b30741d9..55842dc8e45e6 100644 --- a/src/test/rustdoc-js/pinbox-new.js +++ b/src/test/rustdoc-js/pinbox-new.js @@ -14,7 +14,7 @@ const QUERY = 'pinbox::new'; const EXPECTED = { 'others': [ - { 'path': 'std::boxed::PinBox', 'name': 'new' }, - { 'path': 'alloc::boxed::PinBox', 'name': 'new' }, + { 'path': 'std::pin::PinBox', 'name': 'new' }, + { 'path': 'alloc::pin::PinBox', 'name': 'new' }, ], }; diff --git a/src/test/rustdoc-js/vec-new.js b/src/test/rustdoc-js/vec-new.js index 702953e2e9dd1..4a654ccb13503 100644 --- a/src/test/rustdoc-js/vec-new.js +++ b/src/test/rustdoc-js/vec-new.js @@ -14,6 +14,6 @@ const EXPECTED = { 'others': [ { 'path': 'std::vec::Vec', 'name': 'new' }, { 'path': 'std::vec::Vec', 'name': 'ne' }, - { 'path': 'std::boxed::PinBox', 'name': 'new' }, + { 'path': 'std::pin::PinBox', 'name': 'new' }, ], }; From 30bb4af5d8191f016a82c75a0c2b4700b23bd724 Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Thu, 9 Aug 2018 20:10:30 +0300 Subject: [PATCH 03/18] add top-level documentation to the std pin module --- src/liballoc/pin.rs | 4 +++ src/libcore/pin.rs | 4 +++ src/libstd/pin.rs | 81 ++++++++++++++++++++++++++++++++++++++++++++- 3 files changed, 88 insertions(+), 1 deletion(-) diff --git a/src/liballoc/pin.rs b/src/liballoc/pin.rs index 221a55472ab08..1b6ccae456ad8 100644 --- a/src/liballoc/pin.rs +++ b/src/liballoc/pin.rs @@ -9,6 +9,10 @@ // except according to those terms. //! Types which pin data to its location in memory +//! +//! see the [standard library module] for more information +//! +//! [standard library module]: ../../std/pin/index.html #![unstable(feature = "pin", issue = "49150")] diff --git a/src/libcore/pin.rs b/src/libcore/pin.rs index a41185e231bfa..74fb02d2e1162 100644 --- a/src/libcore/pin.rs +++ b/src/libcore/pin.rs @@ -9,6 +9,10 @@ // except according to those terms. //! Types which pin data to its location in memory +//! +//! see the [standard library module] for more information +//! +//! [standard library module]: ../../std/pin/index.html #![unstable(feature = "pin", issue = "49150")] diff --git a/src/libstd/pin.rs b/src/libstd/pin.rs index b3c5b5feb8c48..0b78414e4bf0b 100644 --- a/src/libstd/pin.rs +++ b/src/libstd/pin.rs @@ -1,4 +1,4 @@ -// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT +// Copyright 2018 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // @@ -9,6 +9,85 @@ // except according to those terms. //! Types which pin data to its location in memory +//! +//! It is sometimes useful to have objects that are guaranteed to not move, +//! in the sense that their placement in memory in consistent, and can thus be relied upon. +//! +//! A prime example of such a scenario would be building self-referencial structs, +//! since moving an object with pointers to itself will invalidate them, +//! which could cause undefined behavior. +//! +//! In order to prevent objects from moving, they must be *pinned*, +//! by wrapping the data in special pointer types, such as [`PinMut`] and [`PinBox`]. +//! These restrict access to the underlying data to only be immutable by implementing [`Deref`], +//! unless the type implements the [`Unpin`] trait, +//! which indicates that it doesn't need these restrictions and can be safely mutated, +//! by implementing [`DerefMut`]. +//! +//! This is done because, while modifying an object can be done in-place, +//! it might also relocate a buffer when its at full capacity, +//! or it might replace one object with another without logically "moving" them with [`swap`]. +//! +//! [`PinMut`]: struct.PinMut.html +//! [`PinBox`]: struct.PinBox.html +//! [`Unpin`]: ../marker/trait.Unpin.html +//! [`DerefMut`]: ../ops/trait.DerefMut.html +//! [`Deref`]: ../ops/trait.Deref.html +//! [`swap`]: ../mem/fn.swap.html +//! +//! # Examples +//! +//! ```rust +//! #![feature(pin)] +//! +//! use std::pin::PinBox; +//! use std::marker::Pinned; +//! use std::ptr::NonNull; +//! +//! // This is a self referencial struct since the slice field points to the data field. +//! // We cannot inform the compiler about that with a normal reference, +//! // since this pattern cannot be described with the usual borrowing rules. +//! // Instead we use a raw pointer, though one which is known to not be null, +//! // since we know it's pointing at the string. +//! struct Unmovable { +//! data: String, +//! slice: NonNull, +//! _pin: Pinned, +//! } +//! +//! impl Unmovable { +//! // To ensure the data doesn't move when the function returns, +//! // we place it in the heap where it will stay for the lifetime of the object, +//! // and the only way to access it would be through a pointer to it. +//! fn new(data: String) -> PinBox { +//! let res = Unmovable { +//! data, +//! // we only create the pointer once the data is in place +//! // otherwise it will have already moved before we even started +//! slice: NonNull::dangling(), +//! _pin: Pinned, +//! }; +//! let mut boxed = PinBox::new(res); +//! +//! let slice = NonNull::from(&boxed.data); +//! // we know this is safe because modifying a field doesn't move the whole struct +//! unsafe { PinBox::get_mut(&mut boxed).slice = slice }; +//! boxed +//! } +//! } +//! +//! let unmoved = Unmovable::new("hello".to_string()); +//! // The pointer should point to the correct location, +//! // so long as the struct hasn't moved. +//! // Meanwhile, we are free to move the pointer around. +//! let mut still_unmoved = unmoved; +//! assert_eq!(still_unmoved.slice, NonNull::from(&still_unmoved.data)); +//! +//! // Now the only way to access to data (safely) is immutably, +//! // so this will fail to compile: +//! // still_unmoved.data.push_str(" world"); +//! +//! ``` #![unstable(feature = "pin", issue = "49150")] From c4ec0cd36927a4a010dc6789bdd88eaa503dadd6 Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Fri, 10 Aug 2018 10:10:35 +0300 Subject: [PATCH 04/18] attempt to work around Box not being recognized as local type --- src/liballoc/boxed.rs | 8 ++++++++ src/liballoc/pin.rs | 7 ------- 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index b5c2fd7526da1..c25f3eb8f1750 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -71,6 +71,7 @@ use core::ptr::{self, NonNull, Unique}; use core::task::{Context, Poll, Spawn, SpawnErrorKind, SpawnObjError}; use raw_vec::RawVec; +use pin::PinBox; use str::from_boxed_utf8_unchecked; /// A pointer type for heap allocation. @@ -816,3 +817,10 @@ impl<'a, F: Future + 'a> From> for LocalFutureObj<'a, ()> { LocalFutureObj::new(boxed) } } + +#[unstable(feature = "pin", issue = "49150")] +impl From> for Box { + fn from(pinned: PinBox) -> Box { + unsafe { PinBox::unpin(pinned) } + } +} diff --git a/src/liballoc/pin.rs b/src/liballoc/pin.rs index 1b6ccae456ad8..bacc13fa74ac4 100644 --- a/src/liballoc/pin.rs +++ b/src/liballoc/pin.rs @@ -133,13 +133,6 @@ impl From> for PinBox { } } -#[unstable(feature = "pin", issue = "49150")] -impl From> for Box { - fn from(pinned: PinBox) -> Box { - pinned.inner - } -} - #[unstable(feature = "pin", issue = "49150")] impl Deref for PinBox { type Target = T; From c1103885feb415f82ad36f04f54d229173077a84 Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Fri, 10 Aug 2018 14:00:50 +0300 Subject: [PATCH 05/18] fix link to PinMut --- src/libcore/marker.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs index b1dc84bb84cb8..8e674c0bb7f14 100644 --- a/src/libcore/marker.rs +++ b/src/libcore/marker.rs @@ -630,8 +630,8 @@ unsafe impl<'a, T: ?Sized> Freeze for &'a mut T {} /// /// This trait is automatically implemented for almost every type. /// -/// [`PinMut`]: ../mem/struct.PinMut.html /// [`replace`]: ../mem/fn.replace.html +/// [`PinMut`]: ../pin/struct.PinMut.html #[unstable(feature = "pin", issue = "49150")] pub auto trait Unpin {} From f9efd0578a890d9441da468cc5eed6b9f2ed87df Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Tue, 14 Aug 2018 19:06:51 +0300 Subject: [PATCH 06/18] move pin module to liballoc and reexport that --- src/liballoc/pin.rs | 82 ++++++++++++++++++++++++++++++++++++-- src/libstd/lib.rs | 3 +- src/libstd/pin.rs | 96 --------------------------------------------- 3 files changed, 81 insertions(+), 100 deletions(-) delete mode 100644 src/libstd/pin.rs diff --git a/src/liballoc/pin.rs b/src/liballoc/pin.rs index bacc13fa74ac4..0ecf4ac0a6948 100644 --- a/src/liballoc/pin.rs +++ b/src/liballoc/pin.rs @@ -10,17 +10,93 @@ //! Types which pin data to its location in memory //! -//! see the [standard library module] for more information +//! It is sometimes useful to have objects that are guaranteed to not move, +//! in the sense that their placement in memory in consistent, and can thus be relied upon. //! -//! [standard library module]: ../../std/pin/index.html +//! A prime example of such a scenario would be building self-referencial structs, +//! since moving an object with pointers to itself will invalidate them, +//! which could cause undefined behavior. +//! +//! In order to prevent objects from moving, they must be *pinned*, +//! by wrapping the data in special pointer types, such as [`PinMut`] and [`PinBox`]. +//! These restrict access to the underlying data to only be immutable by implementing [`Deref`], +//! unless the type implements the [`Unpin`] trait, +//! which indicates that it doesn't need these restrictions and can be safely mutated, +//! by implementing [`DerefMut`]. +//! +//! This is done because, while modifying an object can be done in-place, +//! it might also relocate a buffer when its at full capacity, +//! or it might replace one object with another without logically "moving" them with [`swap`]. +//! +//! [`PinMut`]: struct.PinMut.html +//! [`PinBox`]: struct.PinBox.html +//! [`Unpin`]: ../../core/marker/trait.Unpin.html +//! [`DerefMut`]: ../../core/ops/trait.DerefMut.html +//! [`Deref`]: ../../core/ops/trait.Deref.html +//! [`swap`]: ../../core/mem/fn.swap.html +//! +//! # Examples +//! +//! ```rust +//! #![feature(pin)] +//! +//! use std::pin::PinBox; +//! use std::marker::Pinned; +//! use std::ptr::NonNull; +//! +//! // This is a self referencial struct since the slice field points to the data field. +//! // We cannot inform the compiler about that with a normal reference, +//! // since this pattern cannot be described with the usual borrowing rules. +//! // Instead we use a raw pointer, though one which is known to not be null, +//! // since we know it's pointing at the string. +//! struct Unmovable { +//! data: String, +//! slice: NonNull, +//! _pin: Pinned, +//! } +//! +//! impl Unmovable { +//! // To ensure the data doesn't move when the function returns, +//! // we place it in the heap where it will stay for the lifetime of the object, +//! // and the only way to access it would be through a pointer to it. +//! fn new(data: String) -> PinBox { +//! let res = Unmovable { +//! data, +//! // we only create the pointer once the data is in place +//! // otherwise it will have already moved before we even started +//! slice: NonNull::dangling(), +//! _pin: Pinned, +//! }; +//! let mut boxed = PinBox::new(res); +//! +//! let slice = NonNull::from(&boxed.data); +//! // we know this is safe because modifying a field doesn't move the whole struct +//! unsafe { PinBox::get_mut(&mut boxed).slice = slice }; +//! boxed +//! } +//! } +//! +//! let unmoved = Unmovable::new("hello".to_string()); +//! // The pointer should point to the correct location, +//! // so long as the struct hasn't moved. +//! // Meanwhile, we are free to move the pointer around. +//! let mut still_unmoved = unmoved; +//! assert_eq!(still_unmoved.slice, NonNull::from(&still_unmoved.data)); +//! +//! // Now the only way to access to data (safely) is immutably, +//! // so this will fail to compile: +//! // still_unmoved.data.push_str(" world"); +//! +//! ``` #![unstable(feature = "pin", issue = "49150")] +pub use core::pin::*; + use core::convert::From; use core::fmt; use core::future::{Future, FutureObj, LocalFutureObj, UnsafeFutureObj}; use core::marker::{Unpin, Unsize}; -use core::pin::PinMut; use core::ops::{CoerceUnsized, Deref, DerefMut}; use core::task::{Context, Poll}; diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index ac65274d25463..c60ebafd46c17 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -434,6 +434,8 @@ pub use alloc_crate::borrow; pub use alloc_crate::fmt; #[stable(feature = "rust1", since = "1.0.0")] pub use alloc_crate::format; +#[unstable(feature = "pin", issue = "49150")] +pub use alloc_crate::pin; #[stable(feature = "rust1", since = "1.0.0")] pub use alloc_crate::slice; #[stable(feature = "rust1", since = "1.0.0")] @@ -466,7 +468,6 @@ pub mod num; pub mod os; pub mod panic; pub mod path; -pub mod pin; pub mod process; pub mod sync; pub mod time; diff --git a/src/libstd/pin.rs b/src/libstd/pin.rs deleted file mode 100644 index 0b78414e4bf0b..0000000000000 --- a/src/libstd/pin.rs +++ /dev/null @@ -1,96 +0,0 @@ -// Copyright 2018 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! Types which pin data to its location in memory -//! -//! It is sometimes useful to have objects that are guaranteed to not move, -//! in the sense that their placement in memory in consistent, and can thus be relied upon. -//! -//! A prime example of such a scenario would be building self-referencial structs, -//! since moving an object with pointers to itself will invalidate them, -//! which could cause undefined behavior. -//! -//! In order to prevent objects from moving, they must be *pinned*, -//! by wrapping the data in special pointer types, such as [`PinMut`] and [`PinBox`]. -//! These restrict access to the underlying data to only be immutable by implementing [`Deref`], -//! unless the type implements the [`Unpin`] trait, -//! which indicates that it doesn't need these restrictions and can be safely mutated, -//! by implementing [`DerefMut`]. -//! -//! This is done because, while modifying an object can be done in-place, -//! it might also relocate a buffer when its at full capacity, -//! or it might replace one object with another without logically "moving" them with [`swap`]. -//! -//! [`PinMut`]: struct.PinMut.html -//! [`PinBox`]: struct.PinBox.html -//! [`Unpin`]: ../marker/trait.Unpin.html -//! [`DerefMut`]: ../ops/trait.DerefMut.html -//! [`Deref`]: ../ops/trait.Deref.html -//! [`swap`]: ../mem/fn.swap.html -//! -//! # Examples -//! -//! ```rust -//! #![feature(pin)] -//! -//! use std::pin::PinBox; -//! use std::marker::Pinned; -//! use std::ptr::NonNull; -//! -//! // This is a self referencial struct since the slice field points to the data field. -//! // We cannot inform the compiler about that with a normal reference, -//! // since this pattern cannot be described with the usual borrowing rules. -//! // Instead we use a raw pointer, though one which is known to not be null, -//! // since we know it's pointing at the string. -//! struct Unmovable { -//! data: String, -//! slice: NonNull, -//! _pin: Pinned, -//! } -//! -//! impl Unmovable { -//! // To ensure the data doesn't move when the function returns, -//! // we place it in the heap where it will stay for the lifetime of the object, -//! // and the only way to access it would be through a pointer to it. -//! fn new(data: String) -> PinBox { -//! let res = Unmovable { -//! data, -//! // we only create the pointer once the data is in place -//! // otherwise it will have already moved before we even started -//! slice: NonNull::dangling(), -//! _pin: Pinned, -//! }; -//! let mut boxed = PinBox::new(res); -//! -//! let slice = NonNull::from(&boxed.data); -//! // we know this is safe because modifying a field doesn't move the whole struct -//! unsafe { PinBox::get_mut(&mut boxed).slice = slice }; -//! boxed -//! } -//! } -//! -//! let unmoved = Unmovable::new("hello".to_string()); -//! // The pointer should point to the correct location, -//! // so long as the struct hasn't moved. -//! // Meanwhile, we are free to move the pointer around. -//! let mut still_unmoved = unmoved; -//! assert_eq!(still_unmoved.slice, NonNull::from(&still_unmoved.data)); -//! -//! // Now the only way to access to data (safely) is immutably, -//! // so this will fail to compile: -//! // still_unmoved.data.push_str(" world"); -//! -//! ``` - -#![unstable(feature = "pin", issue = "49150")] - -pub use core::pin::*; - -pub use alloc_crate::pin::*; From 1bb05797c26b77f9541b03ac1c44c723b01959f5 Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Tue, 14 Aug 2018 19:25:08 +0300 Subject: [PATCH 07/18] expand the documentation on PinBox --- src/liballoc/pin.rs | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/liballoc/pin.rs b/src/liballoc/pin.rs index 0ecf4ac0a6948..92414f5555ee5 100644 --- a/src/liballoc/pin.rs +++ b/src/liballoc/pin.rs @@ -103,6 +103,15 @@ use core::task::{Context, Poll}; use boxed::Box; /// A pinned, heap allocated reference. +/// +/// This type is similar to [`Box`], except that it pins its value, +/// which prevents it from moving out of the reference, unless it implements [`Unpin`]. +/// +/// See the [module documentation] for furthur explaination on pinning. +/// +/// [`Box`]: ../boxed/struct.Box.html +/// [`Unpin`]: ../../core/marker/trait.Unpin.html +/// [module documentation]: index.html #[unstable(feature = "pin", issue = "49150")] #[fundamental] #[repr(transparent)] From 2f501a1bc46e5d589f3ee98d573206ef195890d3 Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Tue, 14 Aug 2018 19:45:39 +0300 Subject: [PATCH 08/18] fix PinMut documentation --- src/libcore/pin.rs | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/src/libcore/pin.rs b/src/libcore/pin.rs index 74fb02d2e1162..c40e0d805c51b 100644 --- a/src/libcore/pin.rs +++ b/src/libcore/pin.rs @@ -24,9 +24,13 @@ use ops::{Deref, DerefMut, CoerceUnsized}; /// A pinned reference. /// -/// A pinned reference is a lot like a mutable reference, except that it is not -/// safe to move a value out of a pinned reference unless the type of that -/// value implements the `Unpin` trait. +/// This type is similar to a mutable reference, except that it pins its value, +/// which prevents it from moving out of the reference, unless it implements [`Unpin`]. +/// +/// See the [`pin` module] documentation for furthur explanation on pinning. +/// +/// [`Unpin`]: ../marker/trait.Unpin.html +/// [`pin` module]: ../../alloc/pin/index.html #[unstable(feature = "pin", issue = "49150")] #[fundamental] pub struct PinMut<'a, T: ?Sized + 'a> { @@ -56,7 +60,7 @@ impl<'a, T: ?Sized> PinMut<'a, T> { /// may or may not implement `Unpin`. /// /// This constructor is unsafe because we do not know what will happen with - /// that data after the reference ends. If you cannot guarantee that the + /// that data after the lifetime of the reference ends. If you cannot guarantee that the /// data will never move again, calling this constructor is invalid. #[unstable(feature = "pin", issue = "49150")] pub unsafe fn new_unchecked(reference: &'a mut T) -> PinMut<'a, T> { From 8e9aad268ef0994a2edfb77b33cffc4d5a220970 Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Tue, 14 Aug 2018 21:04:39 +0300 Subject: [PATCH 09/18] deemphasize immutability and improve swap explanation in pin module --- src/liballoc/pin.rs | 22 +++++++++------------- 1 file changed, 9 insertions(+), 13 deletions(-) diff --git a/src/liballoc/pin.rs b/src/liballoc/pin.rs index 92414f5555ee5..8cb57ade8651a 100644 --- a/src/liballoc/pin.rs +++ b/src/liballoc/pin.rs @@ -11,7 +11,7 @@ //! Types which pin data to its location in memory //! //! It is sometimes useful to have objects that are guaranteed to not move, -//! in the sense that their placement in memory in consistent, and can thus be relied upon. +//! in the sense that their placement in memory does not change, and can thus be relied upon. //! //! A prime example of such a scenario would be building self-referencial structs, //! since moving an object with pointers to itself will invalidate them, @@ -19,20 +19,17 @@ //! //! In order to prevent objects from moving, they must be *pinned*, //! by wrapping the data in special pointer types, such as [`PinMut`] and [`PinBox`]. -//! These restrict access to the underlying data to only be immutable by implementing [`Deref`], +//! On top of ensuring the data cannot be taked by value by being pointers, +//! these types restrict access to the underlying data such that it cannot be moved out of them, //! unless the type implements the [`Unpin`] trait, -//! which indicates that it doesn't need these restrictions and can be safely mutated, -//! by implementing [`DerefMut`]. +//! which indicates that it can be used safely without these restrictions. //! -//! This is done because, while modifying an object can be done in-place, -//! it might also relocate a buffer when its at full capacity, -//! or it might replace one object with another without logically "moving" them with [`swap`]. +//! A type may be moved out of a reference to it using a function like [`swap`], +//! which replaces the contents of the references, and thus changes their place in memory. //! //! [`PinMut`]: struct.PinMut.html //! [`PinBox`]: struct.PinBox.html //! [`Unpin`]: ../../core/marker/trait.Unpin.html -//! [`DerefMut`]: ../../core/ops/trait.DerefMut.html -//! [`Deref`]: ../../core/ops/trait.Deref.html //! [`swap`]: ../../core/mem/fn.swap.html //! //! # Examples @@ -83,10 +80,9 @@ //! let mut still_unmoved = unmoved; //! assert_eq!(still_unmoved.slice, NonNull::from(&still_unmoved.data)); //! -//! // Now the only way to access to data (safely) is immutably, -//! // so this will fail to compile: -//! // still_unmoved.data.push_str(" world"); -//! +//! // Since our type doesn't implement Unpin, this will fail to compile: +//! // let new_unmoved = Unmovable::new("world".to_string()); +//! // std::mem::swap(&mut *still_unmoved, &mut *new_unmoved); //! ``` #![unstable(feature = "pin", issue = "49150")] From 6b47a6105c69c018792f07ae9d472b478a45bed9 Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Sat, 18 Aug 2018 12:52:38 +0300 Subject: [PATCH 10/18] allow unused mut for pinning explanation --- src/liballoc/pin.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/liballoc/pin.rs b/src/liballoc/pin.rs index 8cb57ade8651a..f7c804b2abad0 100644 --- a/src/liballoc/pin.rs +++ b/src/liballoc/pin.rs @@ -77,6 +77,7 @@ //! // The pointer should point to the correct location, //! // so long as the struct hasn't moved. //! // Meanwhile, we are free to move the pointer around. +//! # #[allow(unused_mut)] //! let mut still_unmoved = unmoved; //! assert_eq!(still_unmoved.slice, NonNull::from(&still_unmoved.data)); //! From 1c26be39294921743ea821ed776996ab7d64f05c Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Sat, 18 Aug 2018 14:25:59 +0300 Subject: [PATCH 11/18] fix broken link to Unpin due to reexport --- src/libcore/pin.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libcore/pin.rs b/src/libcore/pin.rs index c40e0d805c51b..e5784ca213f87 100644 --- a/src/libcore/pin.rs +++ b/src/libcore/pin.rs @@ -29,7 +29,7 @@ use ops::{Deref, DerefMut, CoerceUnsized}; /// /// See the [`pin` module] documentation for furthur explanation on pinning. /// -/// [`Unpin`]: ../marker/trait.Unpin.html +/// [`Unpin`]: ../../core/marker/trait.Unpin.html /// [`pin` module]: ../../alloc/pin/index.html #[unstable(feature = "pin", issue = "49150")] #[fundamental] From 1304cee86244a8cad0d7547a56fcad50a2b73916 Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Tue, 21 Aug 2018 15:19:18 +0300 Subject: [PATCH 12/18] add more info on Unpin and connect paragraphs better --- src/liballoc/pin.rs | 21 ++++++++++++++------- 1 file changed, 14 insertions(+), 7 deletions(-) diff --git a/src/liballoc/pin.rs b/src/liballoc/pin.rs index f7c804b2abad0..a1abaf74b2611 100644 --- a/src/liballoc/pin.rs +++ b/src/liballoc/pin.rs @@ -18,19 +18,26 @@ //! which could cause undefined behavior. //! //! In order to prevent objects from moving, they must be *pinned*, -//! by wrapping the data in special pointer types, such as [`PinMut`] and [`PinBox`]. -//! On top of ensuring the data cannot be taked by value by being pointers, -//! these types restrict access to the underlying data such that it cannot be moved out of them, -//! unless the type implements the [`Unpin`] trait, -//! which indicates that it can be used safely without these restrictions. +//! by wrapping the data in pinning pointer types, such as [`PinMut`] and [`PinBox`], +//! which are otherwise equivalent to `& mut` and [`Box`], respectively. //! -//! A type may be moved out of a reference to it using a function like [`swap`], -//! which replaces the contents of the references, and thus changes their place in memory. +//! First of all, these are pointer types because pinned data mustn't be passed around by value +//! (that would change its location in memory). +//! Secondly, since data can be moved out of `&mut` and [`Box`] with functions such as [`swap`], +//! which causes their contents to swap places in memory, +//! we need dedicated types that prohibit such operations. +//! +//! However, these restrictions are usually not necessary, +//! so most types implement the [`Unpin`] auto-trait, +//! which indicates that the type can be moved out safely. +//! Doing so removes the limitations of pinning types, +//! making them the same as their non-pinning counterparts. //! //! [`PinMut`]: struct.PinMut.html //! [`PinBox`]: struct.PinBox.html //! [`Unpin`]: ../../core/marker/trait.Unpin.html //! [`swap`]: ../../core/mem/fn.swap.html +//! [`Box`]: ../boxed/struct.Box.html //! //! # Examples //! From 871e89b3519ae794cc3e7bd9429e1d867eb541fb Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Tue, 21 Aug 2018 15:21:58 +0300 Subject: [PATCH 13/18] capitalize and punctuate libcore pin module --- src/libcore/pin.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libcore/pin.rs b/src/libcore/pin.rs index e5784ca213f87..380330d2eb1b3 100644 --- a/src/libcore/pin.rs +++ b/src/libcore/pin.rs @@ -10,7 +10,7 @@ //! Types which pin data to its location in memory //! -//! see the [standard library module] for more information +//! See the [standard library module] for more information. //! //! [standard library module]: ../../std/pin/index.html From bfed149020cc48260056c8621d93a7931fba6bde Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Tue, 21 Aug 2018 15:24:14 +0300 Subject: [PATCH 14/18] reexport Unpin into pin module --- src/liballoc/pin.rs | 3 ++- src/libcore/marker.rs | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/liballoc/pin.rs b/src/liballoc/pin.rs index a1abaf74b2611..a5bc4c75bd551 100644 --- a/src/liballoc/pin.rs +++ b/src/liballoc/pin.rs @@ -96,11 +96,12 @@ #![unstable(feature = "pin", issue = "49150")] pub use core::pin::*; +pub use core::marker::Unpin; use core::convert::From; use core::fmt; use core::future::{Future, FutureObj, LocalFutureObj, UnsafeFutureObj}; -use core::marker::{Unpin, Unsize}; +use core::marker::Unsize; use core::ops::{CoerceUnsized, Deref, DerefMut}; use core::task::{Context, Poll}; diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs index 8e674c0bb7f14..11f4821a92572 100644 --- a/src/libcore/marker.rs +++ b/src/libcore/marker.rs @@ -630,7 +630,7 @@ unsafe impl<'a, T: ?Sized> Freeze for &'a mut T {} /// /// This trait is automatically implemented for almost every type. /// -/// [`replace`]: ../mem/fn.replace.html +/// [`replace`]: ../../core/mem/fn.replace.html /// [`PinMut`]: ../pin/struct.PinMut.html #[unstable(feature = "pin", issue = "49150")] pub auto trait Unpin {} From c3fd65ba23ab6bc7e99897bd65b069144424f48a Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Tue, 21 Aug 2018 22:53:50 +0300 Subject: [PATCH 15/18] link Unpin to pin module documentation --- src/libcore/marker.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs index 11f4821a92572..419170ca5ab6e 100644 --- a/src/libcore/marker.rs +++ b/src/libcore/marker.rs @@ -611,6 +611,7 @@ unsafe impl<'a, T: ?Sized> Freeze for &'a mut T {} /// Instead it can be used to prevent moves through the type system, /// by controlling the behavior of special pointer types like [`PinMut`], /// which "pin" the type in place by not allowing it to be moved out of them. +/// See the [`pin module`] documentation for more information on pinning. /// /// Implementing this trait lifts the restrictions of pinning off a type, /// which then allows it to move out with functions such as [`replace`]. @@ -632,6 +633,7 @@ unsafe impl<'a, T: ?Sized> Freeze for &'a mut T {} /// /// [`replace`]: ../../core/mem/fn.replace.html /// [`PinMut`]: ../pin/struct.PinMut.html +/// [`pin module`]: ../../alloc/pin/index.html #[unstable(feature = "pin", issue = "49150")] pub auto trait Unpin {} From 3683bf279d5f27ff1bdeb6e0359f9140679526ba Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Thu, 23 Aug 2018 01:02:29 +0300 Subject: [PATCH 16/18] adjust PinMut import in Unpin docs --- src/libcore/marker.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs index 419170ca5ab6e..191634a9930b3 100644 --- a/src/libcore/marker.rs +++ b/src/libcore/marker.rs @@ -620,7 +620,8 @@ unsafe impl<'a, T: ?Sized> Freeze for &'a mut T {} /// /// ```rust /// #![feature(pin)] -/// use std::mem::{PinMut, replace}; +/// use std::mem::replace; +/// use std::pin::PinMut; /// /// let mut string = "this".to_string(); /// let mut pinned_string = PinMut::new(&mut string); From b26cce5ec045391d5d38e46c32aae30439b4560f Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Thu, 23 Aug 2018 01:16:35 +0300 Subject: [PATCH 17/18] link to items in pin module to std docs --- src/liballoc/pin.rs | 6 +++--- src/libcore/marker.rs | 4 ++-- src/libcore/pin.rs | 4 ++-- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/liballoc/pin.rs b/src/liballoc/pin.rs index a5bc4c75bd551..625c42a649073 100644 --- a/src/liballoc/pin.rs +++ b/src/liballoc/pin.rs @@ -35,8 +35,8 @@ //! //! [`PinMut`]: struct.PinMut.html //! [`PinBox`]: struct.PinBox.html -//! [`Unpin`]: ../../core/marker/trait.Unpin.html -//! [`swap`]: ../../core/mem/fn.swap.html +//! [`Unpin`]: trait.Unpin.html +//! [`swap`]: ../../std/mem/fn.swap.html //! [`Box`]: ../boxed/struct.Box.html //! //! # Examples @@ -115,7 +115,7 @@ use boxed::Box; /// See the [module documentation] for furthur explaination on pinning. /// /// [`Box`]: ../boxed/struct.Box.html -/// [`Unpin`]: ../../core/marker/trait.Unpin.html +/// [`Unpin`]: ../../std/marker/trait.Unpin.html /// [module documentation]: index.html #[unstable(feature = "pin", issue = "49150")] #[fundamental] diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs index 191634a9930b3..dd57d2dd00910 100644 --- a/src/libcore/marker.rs +++ b/src/libcore/marker.rs @@ -632,9 +632,9 @@ unsafe impl<'a, T: ?Sized> Freeze for &'a mut T {} /// /// This trait is automatically implemented for almost every type. /// -/// [`replace`]: ../../core/mem/fn.replace.html +/// [`replace`]: ../../std/mem/fn.replace.html /// [`PinMut`]: ../pin/struct.PinMut.html -/// [`pin module`]: ../../alloc/pin/index.html +/// [`pin module`]: ../../std/pin/index.html #[unstable(feature = "pin", issue = "49150")] pub auto trait Unpin {} diff --git a/src/libcore/pin.rs b/src/libcore/pin.rs index 380330d2eb1b3..65057dfdaceeb 100644 --- a/src/libcore/pin.rs +++ b/src/libcore/pin.rs @@ -29,8 +29,8 @@ use ops::{Deref, DerefMut, CoerceUnsized}; /// /// See the [`pin` module] documentation for furthur explanation on pinning. /// -/// [`Unpin`]: ../../core/marker/trait.Unpin.html -/// [`pin` module]: ../../alloc/pin/index.html +/// [`Unpin`]: ../../std/marker/trait.Unpin.html +/// [`pin` module]: ../../std/pin/index.html #[unstable(feature = "pin", issue = "49150")] #[fundamental] pub struct PinMut<'a, T: ?Sized + 'a> { From 83ca347343f5783779b908c264c9470634d3758c Mon Sep 17 00:00:00 2001 From: Niv Kaminer Date: Sat, 25 Aug 2018 00:07:00 +0300 Subject: [PATCH 18/18] remove copyright headers now that they are not madatory --- src/liballoc/pin.rs | 10 ---------- src/libcore/pin.rs | 10 ---------- 2 files changed, 20 deletions(-) diff --git a/src/liballoc/pin.rs b/src/liballoc/pin.rs index 625c42a649073..17bbc9882d976 100644 --- a/src/liballoc/pin.rs +++ b/src/liballoc/pin.rs @@ -1,13 +1,3 @@ -// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - //! Types which pin data to its location in memory //! //! It is sometimes useful to have objects that are guaranteed to not move, diff --git a/src/libcore/pin.rs b/src/libcore/pin.rs index 65057dfdaceeb..e9001f86b3526 100644 --- a/src/libcore/pin.rs +++ b/src/libcore/pin.rs @@ -1,13 +1,3 @@ -// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - //! Types which pin data to its location in memory //! //! See the [standard library module] for more information.