fix futures-preview on latest nightly

futures-channel/Cargo.toml

@@ -25,4 +25,4 @@ futures-core-preview = { path = "../futures-core", version = "0.3.0-alpha.3", de
 
 [dev-dependencies]
 futures-preview = { path = "../futures", version = "0.3.0-alpha.3", default-features = true }
-pin-utils = "0.1.0-alpha.1"
+pin-utils = "0.1.0-alpha.2"

futures-channel/benches/sync_mpsc.rs

@@ -6,7 +6,7 @@ use futures::executor::LocalPool;
 use futures::stream::{Stream, StreamExt};
 use futures::sink::Sink;
 use futures::task::{self, Poll, Wake, LocalWaker};
-use std::mem::PinMut;
+use std::pin::PinMut;
 use std::sync::Arc;
 use test::Bencher;
 

futures-channel/src/mpsc/mod.rs

@@ -84,7 +84,7 @@ use std::any::Any;
 use std::error::Error;
 use std::fmt;
 use std::marker::Unpin;
-use std::mem::PinMut;
+use std::pin::PinMut;
 use std::sync::{Arc, Mutex};
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering::SeqCst;

futures-channel/src/oneshot.rs

@@ -3,7 +3,7 @@
 use futures_core::future::Future;
 use futures_core::task::{self, Poll, Waker};
 use std::marker::Unpin;
-use std::mem::PinMut;
+use std::pin::PinMut;
 use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::Ordering::SeqCst;

futures-channel/tests/oneshot.rs

@@ -4,7 +4,7 @@ use futures::channel::oneshot::{self, Sender};
 use futures::executor::block_on;
 use futures::future::{Future, FutureExt, poll_fn};
 use futures::task::{self, Poll};
-use std::mem::PinMut;
+use std::pin::PinMut;
 use std::sync::mpsc;
 use std::thread;
 

futures-core/src/future.rs

@@ -1,7 +1,7 @@
 //! Futures.
 
 use crate::task::{self, Poll};
-use core::mem::PinMut;
+use core::pin::PinMut;
 
 pub use core::future::{Future, FutureObj, LocalFutureObj, UnsafeFutureObj};
 

futures-core/src/stream/mod.rs

@@ -2,7 +2,7 @@
 
 use crate::task::{self, Poll};
 use core::marker::Unpin;
-use core::mem::PinMut;
+use core::pin::PinMut;
 
 #[cfg(feature = "either")]
 use either::Either;
@@ -128,7 +128,8 @@ impl<S, T, E> TryStream for S
 }
 
 if_std! {
-    use std::boxed::{Box, PinBox};
+    use std::boxed::Box;
+    use std::pin::PinBox;
 
     impl<S: ?Sized + Stream + Unpin> Stream for Box<S> {
         type Item = S::Item;

futures-core/src/stream/stream_obj.rs

@@ -2,7 +2,7 @@ use super::Stream;
 use crate::task::{self, Poll};
 use core::fmt;
 use core::marker::{PhantomData, Unpin};
-use core::mem::PinMut;
+use core::pin::PinMut;
 
 /// A custom trait object for polling streams, roughly akin to
 /// `Box<dyn Stream<Item = T> + 'a>`.
@@ -193,7 +193,8 @@ where
 }
 
 if_std! {
-    use std::boxed::{Box, PinBox};
+    use std::boxed::Box;
+    use std::pin::PinBox;
 
     unsafe impl<'a, T, F> UnsafeStreamObj<'a, T> for Box<F>
         where F: Stream<Item = T> + 'a

futures-executor/Cargo.toml

@@ -26,7 +26,7 @@ futures-util-preview = { path = "../futures-util", version = "0.3.0-alpha.3", de
 futures-channel-preview = { path = "../futures-channel", version = "0.3.0-alpha.3", default-features = false}
 num_cpus = { version = "1.8.0", optional = true }
 lazy_static = { version = "1.1.0", optional = true }
-pin-utils = "0.1.0-alpha.1"
+pin-utils = "0.1.0-alpha.2"
 
 [dev-dependencies]
 futures-preview = { path = "../futures", version = "0.3.0-alpha.3" }

futures-executor/benches/poll.rs

@@ -4,7 +4,7 @@ use futures::executor::LocalPool;
 use futures::future::{Future, FutureExt};
 use futures::task::{self, Poll, Waker, LocalWaker, Wake};
 use std::marker::Unpin;
-use std::mem::PinMut;
+use std::pin::PinMut;
 use std::sync::Arc;
 use test::Bencher;
 

futures-executor/benches/thread_notify.rs

@@ -4,7 +4,7 @@ use futures::executor::block_on;
 use futures::future::Future;
 use futures::task::{self, Poll, Waker};
 use std::marker::Unpin;
-use std::mem::PinMut;
+use std::pin::PinMut;
 use test::Bencher;
 
 #[bench]

futures-executor/tests/local_pool.rs

@@ -4,9 +4,8 @@ use futures::channel::oneshot;
 use futures::executor::LocalPool;
 use futures::future::{Future, lazy};
 use futures::task::{self, Poll, Spawn};
-use std::boxed::PinBox;
 use std::cell::{Cell, RefCell};
-use std::mem::PinMut;
+use std::pin::{PinBox, PinMut};
 use std::rc::Rc;
 
 struct Pending(Rc<()>);

futures-sink/src/channel_impls.rs

@@ -1,7 +1,7 @@
 use crate::{Sink, Poll};
 use futures_core::task;
 use futures_channel::mpsc::{Sender, SendError, UnboundedSender};
-use std::mem::PinMut;
+use std::pin::PinMut;
 
 impl<T> Sink for Sender<T> {
     type SinkItem = T;

futures-sink/src/lib.rs

@@ -18,7 +18,7 @@ macro_rules! if_std {
 
 use futures_core::task::{self, Poll};
 use core::marker::Unpin;
-use core::mem::PinMut;
+use core::pin::PinMut;
 
 /// A `Sink` is a value into which other values can be sent, asynchronously.
 ///

futures-test/Cargo.toml

@@ -20,7 +20,7 @@ name = "futures_test"
 futures-core-preview = { version = "0.3.0-alpha.2", path = "../futures-core", default-features = false }
 futures-util-preview = { version = "0.3.0-alpha.2", path = "../futures-util", default-features = false }
 futures-executor-preview = { version = "0.3.0-alpha.2", path = "../futures-executor", default-features = false }
-pin-utils = { version = "0.1.0-alpha.1", default-features = false }
+pin-utils = { version = "0.1.0-alpha.2", default-features = false }
 
 [dev-dependencies]
 futures-preview = { version = "0.3.0-alpha.2", path = "../futures", default-features = false, features = ["std"] }

futures-test/src/assert.rs

@@ -30,7 +30,7 @@ macro_rules! assert_stream_pending {
     ($stream:expr) => {{
         let mut stream = &mut $stream;
         $crate::assert::assert_is_unpin_stream(stream);
-        let stream = $crate::std_reexport::mem::PinMut::new(stream);
+        let stream = $crate::std_reexport::pin::PinMut::new(stream);
         let cx = &mut $crate::task::no_spawn_context();
         let poll = $crate::futures_core_reexport::stream::Stream::poll_next(
             stream, cx,
@@ -67,7 +67,7 @@ macro_rules! assert_stream_next {
     ($stream:expr, $item:expr) => {{
         let mut stream = &mut $stream;
         $crate::assert::assert_is_unpin_stream(stream);
-        let stream = $crate::std_reexport::mem::PinMut::new(stream);
+        let stream = $crate::std_reexport::pin::PinMut::new(stream);
         let cx = &mut $crate::task::no_spawn_context();
         match $crate::futures_core_reexport::stream::Stream::poll_next(stream, cx) {
             $crate::futures_core_reexport::task::Poll::Ready(Some(x)) => {
@@ -110,7 +110,7 @@ macro_rules! assert_stream_done {
     ($stream:expr) => {{
         let mut stream = &mut $stream;
         $crate::assert::assert_is_unpin_stream(stream);
-        let stream = $crate::std_reexport::mem::PinMut::new(stream);
+        let stream = $crate::std_reexport::pin::PinMut::new(stream);
         let cx = &mut $crate::task::no_spawn_context();
         match $crate::futures_core_reexport::stream::Stream::poll_next(stream, cx) {
             $crate::futures_core_reexport::task::Poll::Ready(Some(_)) => {

futures-test/src/future/assert_unmoved.rs

@@ -2,7 +2,7 @@ use futures_core::future::Future;
 use futures_core::task::{self, Poll};
 use pin_utils::{unsafe_pinned, unsafe_unpinned};
 use std::marker::Pinned;
-use std::mem::PinMut;
+use std::pin::PinMut;
 use std::ptr;
 
 /// Combinator for the

futures-test/src/future/pending_once.rs

@@ -1,6 +1,6 @@
 use futures_core::future::Future;
 use futures_core::task::{self, Poll};
-use std::mem::PinMut;
+use std::pin::PinMut;
 use pin_utils::{unsafe_pinned, unsafe_unpinned};
 
 /// Combinator that guarantees one [`Poll::Pending`] before polling its inner

futures-util/Cargo.toml

@@ -33,7 +33,7 @@ either = { version = "1.4", default-features = false }
 slab = { version = "0.4", optional = true }
 futures01 = { package = "futures", version = "0.1", optional = true }
 tokio-executor = { version = "0.1.2", optional = true }
-pin-utils = "0.1.0-alpha.1"
+pin-utils = "0.1.0-alpha.2"
 
 [dev-dependencies]
 futures-preview = { path = "../futures", version = "0.3.0-alpha.3", features = ["tokio-compat"] }

futures-util/src/async_await/join.rs

@@ -33,14 +33,14 @@ macro_rules! join {
             let mut all_done = true;
             $(
                 if $crate::core_reexport::future::Future::poll(
-                    unsafe { $crate::core_reexport::mem::PinMut::new_unchecked(&mut $fut) }, cx).is_pending()
+                    unsafe { $crate::core_reexport::pin::PinMut::new_unchecked(&mut $fut) }, cx).is_pending()
                 {
                     all_done = false;
                 }
             )*
             if all_done {
                 $crate::core_reexport::task::Poll::Ready(($(
-                    unsafe { $crate::core_reexport::mem::PinMut::new_unchecked(&mut $fut) }.take_output().unwrap(),
+                    unsafe { $crate::core_reexport::pin::PinMut::new_unchecked(&mut $fut) }.take_output().unwrap(),
                 )*))
             } else {
                 $crate::core_reexport::task::Poll::Pending
@@ -101,15 +101,15 @@ macro_rules! try_join {
             let mut all_done = true;
             $(
                 if $crate::core_reexport::future::Future::poll(
-                    unsafe { $crate::core_reexport::mem::PinMut::new_unchecked(&mut $fut) }, cx).is_pending()
+                    unsafe { $crate::core_reexport::pin::PinMut::new_unchecked(&mut $fut) }, cx).is_pending()
                 {
                     all_done = false;
-                } else if unsafe { $crate::core_reexport::mem::PinMut::new_unchecked(&mut $fut) }.output_mut().unwrap().is_err() {
+                } else if unsafe { $crate::core_reexport::pin::PinMut::new_unchecked(&mut $fut) }.output_mut().unwrap().is_err() {
                     // `.err().unwrap()` rather than `.unwrap_err()` so that we don't introduce
                     // a `T: Debug` bound.
                     return $crate::core_reexport::task::Poll::Ready(
                         $crate::core_reexport::result::Result::Err(
-                            unsafe { $crate::core_reexport::mem::PinMut::new_unchecked(&mut $fut) }.take_output().unwrap().err().unwrap()
+                            unsafe { $crate::core_reexport::pin::PinMut::new_unchecked(&mut $fut) }.take_output().unwrap().err().unwrap()
                         )
                     );
                 }
@@ -119,7 +119,7 @@ macro_rules! try_join {
                     $crate::core_reexport::result::Result::Ok(($(
                         // `.ok().unwrap()` rather than `.unwrap()` so that we don't introduce
                         // an `E: Debug` bound.
-                        unsafe { $crate::core_reexport::mem::PinMut::new_unchecked(&mut $fut) }.take_output().unwrap().ok().unwrap(),
+                        unsafe { $crate::core_reexport::pin::PinMut::new_unchecked(&mut $fut) }.take_output().unwrap().ok().unwrap(),
                     )*))
                 )
             } else {

futures-util/src/async_await/pending.rs

@@ -1,4 +1,4 @@
-use core::mem::PinMut;
+use core::pin::PinMut;
 use futures_core::future::Future;
 use futures_core::task::{self, Poll};
 

futures-util/src/async_await/poll.rs

@@ -1,5 +1,5 @@
 use core::marker::Unpin;
-use core::mem::PinMut;
+use core::pin::PinMut;
 use futures_core::future::Future;
 use futures_core::task::{self, Poll};
 

futures-util/src/async_await/select.rs

@@ -50,7 +50,7 @@ macro_rules! select {
         let __priv_res = await!($crate::future::poll_fn(|cx| {
             $(
                 match $crate::core_reexport::future::Future::poll(
-                    $crate::core_reexport::mem::PinMut::new(&mut $name), cx)
+                    $crate::core_reexport::pin::PinMut::new(&mut $name), cx)
                 {
                     $crate::core_reexport::task::Poll::Ready(x) =>
                         return $crate::core_reexport::task::Poll::Ready(__PrivResult::$name(x)),

futures-util/src/compat/compat01to03.rs

@@ -5,7 +5,7 @@ use futures01::executor::{
 };
 use futures01::{Async as Async01, Future as Future01, Stream as Stream01};
 use futures_core::{task as task03, Future as Future03, Stream as Stream03};
-use std::mem::PinMut;
+use std::pin::PinMut;
 
 impl<Fut: Future01> Future03 for Compat<Fut, ()> {
     type Output = Result<Fut::Item, Fut::Error>;

futures-util/src/compat/compat03to01.rs

@@ -8,7 +8,7 @@ use futures_core::{
     task as task03, TryFuture as TryFuture03, TryStream as TryStream03,
 };
 use futures_sink::Sink as Sink03;
-use std::{marker::Unpin, mem::PinMut, sync::Arc};
+use std::{marker::Unpin, pin::PinMut, sync::Arc};
 
 impl<Fut, Sp> Future01 for Compat<Fut, Sp>
 where

futures-util/src/future/abortable.rs

@@ -3,7 +3,7 @@ use futures_core::future::Future;
 use futures_core::task::{self, Poll};
 use pin_utils::unsafe_pinned;
 use std::marker::Unpin;
-use std::mem::PinMut;
+use std::pin::PinMut;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 

futures-util/src/future/catch_unwind.rs

@@ -2,7 +2,7 @@ use futures_core::future::Future;
 use futures_core::task::{self, Poll};
 use pin_utils::unsafe_pinned;
 use std::any::Any;
-use std::mem::PinMut;
+use std::pin::PinMut;
 use std::panic::{catch_unwind, UnwindSafe, AssertUnwindSafe};
 use std::prelude::v1::*;
 

futures-util/src/future/chain.rs

@@ -1,4 +1,4 @@
-use core::mem::PinMut;
+use core::pin::PinMut;
 use futures_core::future::Future;
 use futures_core::task::{self, Poll};
 

futures-util/src/future/empty.rs

@@ -1,5 +1,5 @@
 use core::marker;
-use core::mem::PinMut;
+use core::pin::PinMut;
 use futures_core::future::Future;
 use futures_core::task::{self, Poll};
 

futures-util/src/future/flatten.rs

@@ -1,6 +1,6 @@
 use super::chain::Chain;
 use core::fmt;
-use core::mem::PinMut;
+use core::pin::PinMut;
 use futures_core::future::Future;
 use futures_core::task::{self, Poll};
 use pin_utils::unsafe_pinned;

futures-util/src/future/flatten_stream.rs

@@ -1,5 +1,5 @@
 use core::fmt;
-use core::mem::PinMut;
+use core::pin::PinMut;
 use futures_core::future::Future;
 use futures_core::stream::Stream;
 use futures_core::task::{self, Poll};

futures-util/src/future/fuse.rs

@@ -1,4 +1,4 @@
-use core::mem::PinMut;
+use core::pin::PinMut;
 use futures_core::future::Future;
 use futures_core::task::{self, Poll};
 use pin_utils::unsafe_pinned;

futures-util/src/future/inspect.rs

@@ -1,5 +1,5 @@
 use core::marker::Unpin;
-use core::mem::PinMut;
+use core::pin::PinMut;
 use futures_core::future::Future;
 use futures_core::task::{self, Poll};
 use pin_utils::{unsafe_pinned, unsafe_unpinned};

futures-util/src/future/into_stream.rs

@@ -1,4 +1,4 @@
-use core::mem::PinMut;
+use core::pin::PinMut;
 use futures_core::future::Future;
 use futures_core::stream::Stream;
 use futures_core::task::{self, Poll};

futures-util/src/future/join.rs

@@ -2,7 +2,7 @@
 
 use crate::future::{MaybeDone, maybe_done};
 use core::fmt;
-use core::mem::PinMut;
+use core::pin::PinMut;
 use futures_core::future::Future;
 use futures_core::task::{self, Poll};
 use pin_utils::unsafe_pinned;

futures-util/src/future/lazy.rs

@@ -1,5 +1,5 @@
 use core::marker::Unpin;
-use core::mem::PinMut;
+use core::pin::PinMut;
 use futures_core::future::Future;
 use futures_core::task::{self, Poll};
 

futures-util/src/future/map.rs

@@ -1,5 +1,5 @@
 use core::marker::Unpin;
-use core::mem::PinMut;
+use core::pin::PinMut;
 use futures_core::future::Future;
 use futures_core::task::{self, Poll};
 use pin_utils::{unsafe_pinned, unsafe_unpinned};

futures-util/src/future/maybe_done.rs

@@ -1,7 +1,8 @@
 //! Definition of the MaybeDone combinator
 
 use core::marker::Unpin;
-use core::mem::{self, PinMut};
+use core::mem;
+use core::pin::PinMut;
 use futures_core::future::Future;
 use futures_core::task::{self, Poll};