From ee51a3c10aa26b6e6c4e86622181d4a3d396fb34 Mon Sep 17 00:00:00 2001 From: Taylor Cramer Date: Fri, 22 Jun 2018 11:36:01 -0700 Subject: Review nits and updates Move future_from_generator out of raw Update await to use $crate Renumber errors --- src/libstd/future.rs | 106 +++++++++++++++++++++++++++++++++++++++++++++++++ src/libstd/lib.rs | 35 ++++++++-------- src/libstd/macros.rs | 10 ++--- src/libstd/raw.rs | 110 --------------------------------------------------- 4 files changed, 129 insertions(+), 132 deletions(-) create mode 100644 src/libstd/future.rs delete mode 100644 src/libstd/raw.rs (limited to 'src/libstd') diff --git a/src/libstd/future.rs b/src/libstd/future.rs new file mode 100644 index 00000000000..abacb862656 --- /dev/null +++ b/src/libstd/future.rs @@ -0,0 +1,106 @@ +// 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. + +//! Asynchronous values. + +use core::cell::Cell; +use core::marker::Unpin; +use core::mem::PinMut; +use core::option::Option; +use core::ptr::NonNull; +use core::task::{self, Poll}; +use core::ops::{Drop, Generator, GeneratorState}; + +#[doc(inline)] +pub use core::future::*; + +/// Wrap a future in a generator. +/// +/// This function returns a `GenFuture` underneath, but hides it in `impl Trait` to give +/// better error messages (`impl Future` rather than `GenFuture<[closure.....]>`). +#[unstable(feature = "gen_future", issue = "50547")] +pub fn future_from_generator>(x: T) -> impl Future { + GenFuture(x) +} + +/// A wrapper around generators used to implement `Future` for `async`/`await` code. +#[unstable(feature = "gen_future", issue = "50547")] +#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] +struct GenFuture>(T); + +// We rely on the fact that async/await futures are immovable in order to create +// self-referential borrows in the underlying generator. +impl> !Unpin for GenFuture {} + +#[unstable(feature = "gen_future", issue = "50547")] +impl> Future for GenFuture { + type Output = T::Return; + fn poll(self: PinMut, cx: &mut task::Context) -> Poll { + set_task_cx(cx, || match unsafe { PinMut::get_mut(self).0.resume() } { + GeneratorState::Yielded(()) => Poll::Pending, + GeneratorState::Complete(x) => Poll::Ready(x), + }) + } +} + +thread_local! { + static TLS_CX: Cell>>> = Cell::new(None); +} + +struct SetOnDrop(Option>>); + +impl Drop for SetOnDrop { + fn drop(&mut self) { + TLS_CX.with(|tls_cx| { + tls_cx.set(self.0.take()); + }); + } +} + +#[unstable(feature = "gen_future", issue = "50547")] +/// Sets the thread-local task context used by async/await futures. +pub fn set_task_cx(cx: &mut task::Context, f: F) -> R +where + F: FnOnce() -> R +{ + let old_cx = TLS_CX.with(|tls_cx| { + let old_cx = tls_cx.get(); + tls_cx.set(NonNull::new( + cx as *mut task::Context as *mut () as *mut task::Context<'static>)); + old_cx + }); + let _reset_cx = SetOnDrop(old_cx); + let res = f(); + res +} + +#[unstable(feature = "gen_future", issue = "50547")] +/// Retrieves the thread-local task context used by async/await futures. +/// +/// Panics if no task has been set or if the task context has already been +/// retrived by a surrounding call to get_task_cx. +pub fn get_task_cx(f: F) -> R +where + F: FnOnce(&mut task::Context) -> R +{ + let cx_ptr = TLS_CX.with(|tls_cx| { + let cx_ptr = tls_cx.get(); + // Clear the entry so that nested `with_get_cx` calls + // will fail or set their own value. + tls_cx.set(None); + cx_ptr + }); + let _reset_cx = SetOnDrop(cx_ptr); + + let mut cx_ptr = cx_ptr.expect( + "TLS task::Context not set. This is a rustc bug. \ + Please file an issue on https://github.com/rust-lang/rust."); + unsafe { f(cx_ptr.as_mut()) } +} diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index c74cd3feca3..caad924ea5b 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -411,6 +411,8 @@ pub use core::ops; #[stable(feature = "rust1", since = "1.0.0")] pub use core::ptr; #[stable(feature = "rust1", since = "1.0.0")] +pub use core::raw; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::result; #[stable(feature = "rust1", since = "1.0.0")] pub use core::option; @@ -461,22 +463,6 @@ pub use core::u128; #[stable(feature = "core_hint", since = "1.27.0")] pub use core::hint; -#[unstable(feature = "futures_api", - reason = "futures in libcore are unstable", - issue = "50547")] -pub mod task { - //! Types and Traits for working with asynchronous tasks. - #[doc(inline)] - pub use core::task::*; - #[doc(inline)] - pub use alloc_crate::task::*; -} - -#[unstable(feature = "futures_api", - reason = "futures in libcore are unstable", - issue = "50547")] -pub use core::future; - pub mod f32; pub mod f64; @@ -495,10 +481,25 @@ pub mod os; pub mod panic; pub mod path; pub mod process; -pub mod raw; pub mod sync; pub mod time; +#[unstable(feature = "futures_api", + reason = "futures in libcore are unstable", + issue = "50547")] +pub mod task { + //! Types and Traits for working with asynchronous tasks. + #[doc(inline)] + pub use core::task::*; + #[doc(inline)] + pub use alloc_crate::task::*; +} + +#[unstable(feature = "futures_api", + reason = "futures in libcore are unstable", + issue = "50547")] +pub mod future; + // Platform-abstraction modules #[macro_use] mod sys_common; diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs index 1f2a6e2bfea..1e9da42d40d 100644 --- a/src/libstd/macros.rs +++ b/src/libstd/macros.rs @@ -220,15 +220,15 @@ macro_rules! eprintln { macro_rules! await { ($e:expr) => { { let mut pinned = $e; - let mut pinned = unsafe { ::core::mem::PinMut::new_unchecked(&mut pinned) }; + let mut pinned = unsafe { $crate::mem::PinMut::new_unchecked(&mut pinned) }; loop { - match ::std::raw::with_get_cx(|cx| - ::core::future::Future::poll(pinned.reborrow(), cx)) + match $crate::future::get_task_cx(|cx| + $crate::future::Future::poll(pinned.reborrow(), cx)) { // FIXME(cramertj) prior to stabilizing await, we have to ensure that this // can't be used to create a generator on stable via `|| await!()`. - ::core::task::Poll::Pending => yield, - ::core::task::Poll::Ready(x) => break x, + $crate::task::Poll::Pending => yield, + $crate::task::Poll::Ready(x) => break x, } } } } diff --git a/src/libstd/raw.rs b/src/libstd/raw.rs deleted file mode 100644 index 62fd42c4de7..00000000000 --- a/src/libstd/raw.rs +++ /dev/null @@ -1,110 +0,0 @@ -// Copyright 2013 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. - -#![allow(missing_docs)] -#![unstable(feature = "raw", issue = "27751")] - -//! Contains struct definitions for the layout of compiler built-in types. -//! -//! They can be used as targets of transmutes in unsafe code for manipulating -//! the raw representations directly. -//! -//! Their definition should always match the ABI defined in `rustc::back::abi`. - -use core::cell::Cell; -use core::future::Future; -use core::marker::Unpin; -use core::mem::PinMut; -use core::option::Option; -use core::ptr::NonNull; -use core::task::{self, Poll}; -use core::ops::{Drop, Generator, GeneratorState}; - -#[stable(feature = "rust1", since = "1.0.0")] -pub use core::raw::*; - -/// Wrap a future in a generator. -/// -/// This function returns a `GenFuture` underneath, but hides it in `impl Trait` to give -/// better error messages (`impl Future` rather than `GenFuture<[closure.....]>`). -#[unstable(feature = "gen_future", issue = "50547")] -pub fn future_from_generator>(x: T) -> impl Future { - GenFuture(x) -} - -/// A wrapper around generators used to implement `Future` for `async`/`await` code. -#[unstable(feature = "gen_future", issue = "50547")] -#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] -struct GenFuture>(T); - -// We rely on the fact that async/await futures are immovable in order to create -// self-referential borrows in the underlying generator. -impl> !Unpin for GenFuture {} - -#[unstable(feature = "gen_future", issue = "50547")] -impl> Future for GenFuture { - type Output = T::Return; - fn poll(self: PinMut, cx: &mut task::Context) -> Poll { - with_set_cx(cx, || match unsafe { PinMut::get_mut(self).0.resume() } { - GeneratorState::Yielded(()) => Poll::Pending, - GeneratorState::Complete(x) => Poll::Ready(x), - }) - } -} - -thread_local! { - static TLS_CX: Cell>>> = Cell::new(None); -} - -struct SetOnDrop(Option>>); - -impl Drop for SetOnDrop { - fn drop(&mut self) { - TLS_CX.with(|tls_cx| { - tls_cx.set(self.0.take()); - }); - } -} - -#[unstable(feature = "gen_future", issue = "50547")] -pub fn with_set_cx(cx: &mut task::Context, f: F) -> R -where - F: FnOnce() -> R -{ - let old_cx = TLS_CX.with(|tls_cx| { - let old_cx = tls_cx.get(); - tls_cx.set(NonNull::new( - cx as *mut task::Context as *mut () as *mut task::Context<'static>)); - old_cx - }); - let _reset_cx = SetOnDrop(old_cx); - let res = f(); - res -} - -#[unstable(feature = "gen_future", issue = "50547")] -pub fn with_get_cx(f: F) -> R -where - F: FnOnce(&mut task::Context) -> R -{ - let cx_ptr = TLS_CX.with(|tls_cx| { - let cx_ptr = tls_cx.get(); - // Clear the entry so that nested `with_get_cx` calls - // will fail or set their own value. - tls_cx.set(None); - cx_ptr - }); - let _reset_cx = SetOnDrop(cx_ptr); - - let mut cx_ptr = cx_ptr.expect( - "TLS task::Context not set. This is a rustc bug. \ - Please file an issue on https://github.com/rust-lang/rust."); - unsafe { f(cx_ptr.as_mut()) } -} -- cgit 1.4.1-3-g733a5