diff --git a/Cargo.toml b/Cargo.toml
index 430205d8ca..7a6eeee576 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,3 +10,6 @@ members = [
   "futures-util",
   "futures-test",
 ]
+
+[patch.crates-io]
+pin-project = { git = "https://github.com/taiki-e/pin-project", branch = "pin_project" }
diff --git a/futures-util/Cargo.toml b/futures-util/Cargo.toml
index a28bc5c718..2cf1cbf635 100644
--- a/futures-util/Cargo.toml
+++ b/futures-util/Cargo.toml
@@ -42,6 +42,7 @@ slab = { version = "0.4", optional = true }
 memchr = { version = "2.2", optional = true }
 futures_01 = { version = "0.1.25", optional = true, package = "futures" }
 tokio-io = { version = "0.1.9", optional = true }
+pin-project = "0.3.2"
 pin-utils = "0.1.0-alpha.4"
 
 [dev-dependencies]
diff --git a/futures-util/src/future/catch_unwind.rs b/futures-util/src/future/catch_unwind.rs
index 2fb2d04e42..98a689240d 100644
--- a/futures-util/src/future/catch_unwind.rs
+++ b/futures-util/src/future/catch_unwind.rs
@@ -1,20 +1,20 @@
 use futures_core::future::Future;
 use futures_core::task::{Context, Poll};
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 use std::any::Any;
-use std::pin::Pin;
 use std::panic::{catch_unwind, UnwindSafe, AssertUnwindSafe};
+use std::pin::Pin;
 
 /// Future for the [`catch_unwind`](super::FutureExt::catch_unwind) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct CatchUnwind<Fut> where Fut: Future {
+    #[pin]
     future: Fut,
 }
 
 impl<Fut> CatchUnwind<Fut> where Fut: Future + UnwindSafe {
-    unsafe_pinned!(future: Fut);
-
     pub(super) fn new(future: Fut) -> CatchUnwind<Fut> {
         CatchUnwind { future }
     }
@@ -25,7 +25,8 @@ impl<Fut> Future for CatchUnwind<Fut>
 {
     type Output = Result<Fut::Output, Box<dyn Any + Send>>;
 
+    #[pin_project(self)]
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        catch_unwind(AssertUnwindSafe(|| self.future().poll(cx)))?.map(Ok)
+        catch_unwind(AssertUnwindSafe(|| self.future.poll(cx)))?.map(Ok)
     }
 }
diff --git a/futures-util/src/future/flatten.rs b/futures-util/src/future/flatten.rs
index 202164204e..ed5553aa22 100644
--- a/futures-util/src/future/flatten.rs
+++ b/futures-util/src/future/flatten.rs
@@ -3,14 +3,16 @@ use core::fmt;
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future};
 use futures_core::task::{Context, Poll};
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`flatten`](super::FutureExt::flatten) method.
+#[unsafe_project]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct Flatten<Fut>
     where Fut: Future,
           Fut::Output: Future,
 {
+    #[pin]
     state: Chain<Fut, Fut::Output, ()>,
 }
 
@@ -18,8 +20,6 @@ impl<Fut> Flatten<Fut>
     where Fut: Future,
           Fut::Output: Future,
 {
-    unsafe_pinned!(state: Chain<Fut, Fut::Output, ()>);
-
     pub(super) fn new(future: Fut) -> Flatten<Fut> {
         Flatten {
             state: Chain::new(future, ()),
@@ -51,7 +51,8 @@ impl<Fut> Future for Flatten<Fut>
 {
     type Output = <Fut::Output as Future>::Output;
 
+    #[pin_project(self)]
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        self.state().poll(cx, |a, ()| a)
+        self.state.poll(cx, |a, ()| a)
     }
 }
diff --git a/futures-util/src/future/fuse.rs b/futures-util/src/future/fuse.rs
index 0c7fdc84db..4813356c44 100644
--- a/futures-util/src/future/fuse.rs
+++ b/futures-util/src/future/fuse.rs
@@ -1,18 +1,18 @@
 use core::pin::Pin;
 use futures_core::future::{Future, FusedFuture};
 use futures_core::task::{Context, Poll};
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`fuse`](super::FutureExt::fuse) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct Fuse<Fut: Future> {
+    #[pin]
     future: Option<Fut>,
 }
 
 impl<Fut: Future> Fuse<Fut> {
-    unsafe_pinned!(future: Option<Fut>);
-
     pub(super) fn new(f: Fut) -> Fuse<Fut> {
         Fuse {
             future: Some(f),
@@ -79,13 +79,14 @@ impl<Fut: Future> FusedFuture for Fuse<Fut> {
 impl<Fut: Future> Future for Fuse<Fut> {
     type Output = Fut::Output;
 
+    #[pin_project(self)]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Fut::Output> {
-        let v = match self.as_mut().future().as_pin_mut() {
+        let v = match self.future.as_mut().as_pin_mut() {
             Some(fut) => ready!(fut.poll(cx)),
             None => return Poll::Pending,
         };
 
-        self.as_mut().future().set(None);
+        self.future.set(None);
         Poll::Ready(v)
     }
 }
diff --git a/futures-util/src/future/inspect.rs b/futures-util/src/future/inspect.rs
index f9e1fc57cc..ff594363cc 100644
--- a/futures-util/src/future/inspect.rs
+++ b/futures-util/src/future/inspect.rs
@@ -1,20 +1,19 @@
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future};
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`inspect`](super::FutureExt::inspect) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct Inspect<Fut, F> where Fut: Future {
+    #[pin]
     future: Fut,
     f: Option<F>,
 }
 
 impl<Fut: Future, F: FnOnce(&Fut::Output)> Inspect<Fut, F> {
-    unsafe_pinned!(future: Fut);
-    unsafe_unpinned!(f: Option<F>);
-
     pub(super) fn new(future: Fut, f: F) -> Inspect<Fut, F> {
         Inspect {
             future,
@@ -23,8 +22,6 @@ impl<Fut: Future, F: FnOnce(&Fut::Output)> Inspect<Fut, F> {
     }
 }
 
-impl<Fut: Future + Unpin, F> Unpin for Inspect<Fut, F> {}
-
 impl<Fut: Future + FusedFuture, F> FusedFuture for Inspect<Fut, F> {
     fn is_terminated(&self) -> bool { self.future.is_terminated() }
 }
@@ -35,9 +32,10 @@ impl<Fut, F> Future for Inspect<Fut, F>
 {
     type Output = Fut::Output;
 
+    #[pin_project(self)]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Fut::Output> {
-        let e = ready!(self.as_mut().future().poll(cx));
-        let f = self.as_mut().f().take().expect("cannot poll Inspect twice");
+        let e = ready!(self.future.as_mut().poll(cx));
+        let f = self.f.take().expect("cannot poll Inspect twice");
         f(&e);
         Poll::Ready(e)
     }
diff --git a/futures-util/src/future/into_stream.rs b/futures-util/src/future/into_stream.rs
index adc987e6a4..37ad5d678a 100644
--- a/futures-util/src/future/into_stream.rs
+++ b/futures-util/src/future/into_stream.rs
@@ -2,18 +2,18 @@ use core::pin::Pin;
 use futures_core::future::Future;
 use futures_core::stream::Stream;
 use futures_core::task::{Context, Poll};
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`into_stream`](super::FutureExt::into_stream) method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 #[derive(Debug)]
 pub struct IntoStream<Fut: Future> {
+    #[pin]
     future: Option<Fut>
 }
 
 impl<Fut: Future> IntoStream<Fut> {
-    unsafe_pinned!(future: Option<Fut>);
-
     pub(super) fn new(future: Fut) -> IntoStream<Fut> {
         IntoStream {
             future: Some(future)
@@ -24,13 +24,14 @@ impl<Fut: Future> IntoStream<Fut> {
 impl<Fut: Future> Stream for IntoStream<Fut> {
     type Item = Fut::Output;
 
+    #[pin_project(self)]
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let v = match self.as_mut().future().as_pin_mut() {
+        let v = match self.future.as_mut().as_pin_mut() {
             Some(fut) => ready!(fut.poll(cx)),
             None => return Poll::Ready(None),
         };
 
-        self.as_mut().future().set(None);
+        self.future.set(None);
         Poll::Ready(Some(v))
     }
 }
diff --git a/futures-util/src/future/map.rs b/futures-util/src/future/map.rs
index 787890ee3d..928b6dde01 100644
--- a/futures-util/src/future/map.rs
+++ b/futures-util/src/future/map.rs
@@ -1,28 +1,24 @@
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future};
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`map`](super::FutureExt::map) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct Map<Fut, F> {
+    #[pin]
     future: Fut,
     f: Option<F>,
 }
 
 impl<Fut, F> Map<Fut, F> {
-    unsafe_pinned!(future: Fut);
-    unsafe_unpinned!(f: Option<F>);
-
-    /// Creates a new Map.
     pub(super) fn new(future: Fut, f: F) -> Map<Fut, F> {
         Map { future, f: Some(f) }
     }
 }
 
-impl<Fut: Unpin, F> Unpin for Map<Fut, F> {}
-
 impl<Fut, F> FusedFuture for Map<Fut, F> {
     fn is_terminated(&self) -> bool { self.f.is_none() }
 }
@@ -33,12 +29,13 @@ impl<Fut, F, T> Future for Map<Fut, F>
 {
     type Output = T;
 
+    #[pin_project(self)]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
-        self.as_mut()
-            .future()
+        self.future
+            .as_mut()
             .poll(cx)
             .map(|output| {
-                let f = self.f().take()
+                let f = self.f.take()
                     .expect("Map must not be polled after it returned `Poll::Ready`");
                 f(output)
             })
diff --git a/futures-util/src/future/never_error.rs b/futures-util/src/future/never_error.rs
index 6e8094c118..6cf6c8af85 100644
--- a/futures-util/src/future/never_error.rs
+++ b/futures-util/src/future/never_error.rs
@@ -2,25 +2,23 @@ use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future};
 use futures_core::task::{self, Poll};
 use futures_core::never::Never;
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`never_error`](super::FutureExt::never_error) combinator.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct NeverError<Fut> {
+    #[pin]
     future: Fut,
 }
 
 impl<Fut> NeverError<Fut> {
-    unsafe_pinned!(future: Fut);
-
     pub(super) fn new(future: Fut) -> NeverError<Fut> {
         NeverError { future }
     }
 }
 
-impl<Fut: Unpin> Unpin for NeverError<Fut> {}
-
 impl<Fut: FusedFuture> FusedFuture for NeverError<Fut> {
     fn is_terminated(&self) -> bool { self.future.is_terminated() }
 }
@@ -30,7 +28,8 @@ impl<Fut, T> Future for NeverError<Fut>
 {
     type Output = Result<T, Never>;
 
+    #[pin_project(self)]
     fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
-        self.future().poll(cx).map(Ok)
+        self.future.poll(cx).map(Ok)
     }
 }
diff --git a/futures-util/src/future/option.rs b/futures-util/src/future/option.rs
index 53e9a1e92b..48edc3ca57 100644
--- a/futures-util/src/future/option.rs
+++ b/futures-util/src/future/option.rs
@@ -3,7 +3,7 @@
 use core::pin::Pin;
 use futures_core::future::Future;
 use futures_core::task::{Context, Poll};
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// A future representing a value which may or may not be present.
 ///
@@ -23,24 +23,23 @@ use pin_utils::unsafe_pinned;
 /// assert_eq!(a.await, None);
 /// # });
 /// ```
+#[unsafe_project(Unpin)]
 #[derive(Debug, Clone)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct OptionFuture<F> {
+    #[pin]
     option: Option<F>,
 }
 
-impl<F> OptionFuture<F> {
-    unsafe_pinned!(option: Option<F>);
-}
-
 impl<F: Future> Future for OptionFuture<F> {
     type Output = Option<F::Output>;
 
+    #[pin_project(self)]
     fn poll(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Self::Output> {
-        match self.option().as_pin_mut() {
+        match self.option.as_pin_mut() {
             Some(x) => x.poll(cx).map(Some),
             None => Poll::Ready(None),
         }
diff --git a/futures-util/src/future/remote_handle.rs b/futures-util/src/future/remote_handle.rs
index e3223c6c24..4f6645de9d 100644
--- a/futures-util/src/future/remote_handle.rs
+++ b/futures-util/src/future/remote_handle.rs
@@ -5,7 +5,7 @@ use {
         future::Future,
         task::{Context, Poll},
     },
-    pin_utils::{unsafe_pinned, unsafe_unpinned},
+    pin_project::{pin_project, unsafe_project},
     std::{
         any::Any,
         fmt,
@@ -54,10 +54,12 @@ type SendMsg<Fut> = Result<<Fut as Future>::Output, Box<(dyn Any + Send + 'stati
 
 /// A future which sends its output to the corresponding `RemoteHandle`.
 /// Created by [`remote_handle`](crate::future::FutureExt::remote_handle).
+#[unsafe_project(Unpin)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct Remote<Fut: Future> {
     tx: Option<Sender<SendMsg<Fut>>>,
     keep_running: Arc<AtomicBool>,
+    #[pin]
     future: CatchUnwind<AssertUnwindSafe<Fut>>,
 }
 
@@ -69,29 +71,23 @@ impl<Fut: Future + fmt::Debug> fmt::Debug for Remote<Fut> {
     }
 }
 
-impl<Fut: Future + Unpin> Unpin for Remote<Fut> {}
-
-impl<Fut: Future> Remote<Fut> {
-    unsafe_pinned!(future: CatchUnwind<AssertUnwindSafe<Fut>>);
-    unsafe_unpinned!(tx: Option<Sender<SendMsg<Fut>>>);
-}
-
 impl<Fut: Future> Future for Remote<Fut> {
     type Output = ();
 
+    #[pin_project(self)]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
-        if let Poll::Ready(_) = self.as_mut().tx().as_mut().unwrap().poll_cancel(cx) {
+        if let Poll::Ready(_) = self.tx.as_mut().unwrap().poll_cancel(cx) {
             if !self.keep_running.load(Ordering::SeqCst) {
                 // Cancelled, bail out
                 return Poll::Ready(())
             }
         }
 
-        let output = ready!(self.as_mut().future().poll(cx));
+        let output = ready!(self.future.as_mut().poll(cx));
 
         // if the receiving end has gone away then that's ok, we just ignore the
         // send error here.
-        drop(self.as_mut().tx().take().unwrap().send(output));
+        drop(self.tx.take().unwrap().send(output));
         Poll::Ready(())
     }
 }
diff --git a/futures-util/src/future/then.rs b/futures-util/src/future/then.rs
index e03683f2d3..c5eb2adc7f 100644
--- a/futures-util/src/future/then.rs
+++ b/futures-util/src/future/then.rs
@@ -2,12 +2,14 @@ use super::Chain;
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future};
 use futures_core::task::{Context, Poll};
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`then`](super::FutureExt::then) method.
+#[unsafe_project]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct Then<Fut1, Fut2, F> {
+    #[pin]
     chain: Chain<Fut1, Fut2, F>,
 }
 
@@ -15,9 +17,6 @@ impl<Fut1, Fut2, F> Then<Fut1, Fut2, F>
     where Fut1: Future,
           Fut2: Future,
 {
-    unsafe_pinned!(chain: Chain<Fut1, Fut2, F>);
-
-    /// Creates a new `Then`.
     pub(super) fn new(future: Fut1, f: F) -> Then<Fut1, Fut2, F> {
         Then {
             chain: Chain::new(future, f),
@@ -36,7 +35,8 @@ impl<Fut1, Fut2, F> Future for Then<Fut1, Fut2, F>
 {
     type Output = Fut2::Output;
 
+    #[pin_project(self)]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Fut2::Output> {
-        self.as_mut().chain().poll(cx, |output, f| f(output))
+        self.chain.poll(cx, |output, f| f(output))
     }
 }
diff --git a/futures-util/src/future/unit_error.rs b/futures-util/src/future/unit_error.rs
index 679e988b16..2925eedee3 100644
--- a/futures-util/src/future/unit_error.rs
+++ b/futures-util/src/future/unit_error.rs
@@ -1,25 +1,23 @@
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future};
 use futures_core::task::{Context, Poll};
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`unit_error`](super::FutureExt::unit_error) combinator.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct UnitError<Fut> {
+    #[pin]
     future: Fut,
 }
 
 impl<Fut> UnitError<Fut> {
-    unsafe_pinned!(future: Fut);
-
     pub(super) fn new(future: Fut) -> UnitError<Fut> {
         UnitError { future }
     }
 }
 
-impl<Fut: Unpin> Unpin for UnitError<Fut> {}
-
 impl<Fut: FusedFuture> FusedFuture for UnitError<Fut> {
     fn is_terminated(&self) -> bool { self.future.is_terminated() }
 }
@@ -29,7 +27,8 @@ impl<Fut, T> Future for UnitError<Fut>
 {
     type Output = Result<T, ()>;
 
+    #[pin_project(self)]
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<T, ()>> {
-        self.future().poll(cx).map(Ok)
+        self.future.poll(cx).map(Ok)
     }
 }
diff --git a/futures-util/src/lib.rs b/futures-util/src/lib.rs
index 82d6a44763..0751cf2b31 100644
--- a/futures-util/src/lib.rs
+++ b/futures-util/src/lib.rs
@@ -65,28 +65,28 @@ macro_rules! delegate_sink {
             self: Pin<&mut Self>,
             cx: &mut $crate::core_reexport::task::Context<'_>,
         ) -> $crate::core_reexport::task::Poll<Result<(), Self::Error>> {
-            self.$field().poll_ready(cx)
+            self.project().$field.poll_ready(cx)
         }
 
         fn start_send(
             self: Pin<&mut Self>,
             item: $item,
         ) -> Result<(), Self::Error> {
-            self.$field().start_send(item)
+            self.project().$field.start_send(item)
         }
 
         fn poll_flush(
             self: Pin<&mut Self>,
             cx: &mut $crate::core_reexport::task::Context<'_>,
         ) -> $crate::core_reexport::task::Poll<Result<(), Self::Error>> {
-            self.$field().poll_flush(cx)
+            self.project().$field.poll_flush(cx)
         }
 
         fn poll_close(
             self: Pin<&mut Self>,
             cx: &mut $crate::core_reexport::task::Context<'_>,
         ) -> $crate::core_reexport::task::Poll<Result<(), Self::Error>> {
-            self.$field().poll_close(cx)
+            self.project().$field.poll_close(cx)
         }
     }
 }
diff --git a/futures-util/src/sink/buffer.rs b/futures-util/src/sink/buffer.rs
index c2e7ca6d6e..9e11974c00 100644
--- a/futures-util/src/sink/buffer.rs
+++ b/futures-util/src/sink/buffer.rs
@@ -1,14 +1,16 @@
+use alloc::collections::VecDeque;
+use core::pin::Pin;
 use futures_core::stream::Stream;
 use futures_core::task::{Context, Poll};
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
-use core::pin::Pin;
-use alloc::collections::VecDeque;
+use pin_project::{pin_project, unsafe_project};
 
 /// Sink for the [`buffer`](super::SinkExt::buffer) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "sinks do nothing unless polled"]
 pub struct Buffer<Si: Sink<Item>, Item> {
+    #[pin]
     sink: Si,
     buf: VecDeque<Item>,
 
@@ -16,13 +18,7 @@ pub struct Buffer<Si: Sink<Item>, Item> {
     capacity: usize,
 }
 
-impl<Si: Sink<Item> + Unpin, Item> Unpin for Buffer<Si, Item> {}
-
 impl<Si: Sink<Item>, Item> Buffer<Si, Item> {
-    unsafe_pinned!(sink: Si);
-    unsafe_unpinned!(buf: VecDeque<Item>);
-    unsafe_unpinned!(capacity: usize);
-
     pub(super) fn new(sink: Si, capacity: usize) -> Self {
         Buffer {
             sink,
@@ -42,8 +38,9 @@ impl<Si: Sink<Item>, Item> Buffer<Si, Item> {
     }
 
     /// Get a pinned mutable reference to the inner sink.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut Si> {
-        self.sink()
+        self.sink
     }
 
     /// Consumes this combinator, returning the underlying sink.
@@ -54,77 +51,84 @@ impl<Si: Sink<Item>, Item> Buffer<Si, Item> {
         self.sink
     }
 
-    fn try_empty_buffer(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Result<(), Si::Error>> {
-        ready!(self.as_mut().sink().poll_ready(cx))?;
-        while let Some(item) = self.as_mut().buf().pop_front() {
-            self.as_mut().sink().start_send(item)?;
-            if !self.buf.is_empty() {
-                ready!(self.as_mut().sink().poll_ready(cx))?;
-            }
+}
+
+fn try_empty_buffer<Si: Sink<Item>, Item>(
+    mut sink: Pin<&mut Si>,
+    buf: &mut VecDeque<Item>,
+    cx: &mut Context<'_>,
+) -> Poll<Result<(), Si::Error>> {
+    ready!(sink.as_mut().poll_ready(cx))?;
+    while let Some(item) = buf.pop_front() {
+        sink.as_mut().start_send(item)?;
+        if !buf.is_empty() {
+            ready!(sink.as_mut().poll_ready(cx))?;
         }
-        Poll::Ready(Ok(()))
     }
+    Poll::Ready(Ok(()))
 }
 
 // Forwarding impl of Stream from the underlying sink
 impl<S, Item> Stream for Buffer<S, Item> where S: Sink<Item> + Stream {
     type Item = S::Item;
 
+    #[pin_project(self)]
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<S::Item>> {
-        self.sink().poll_next(cx)
+        self.sink.poll_next(cx)
     }
 }
 
 impl<Si: Sink<Item>, Item> Sink<Item> for Buffer<Si, Item> {
     type Error = Si::Error;
 
+    #[pin_project(self)]
     fn poll_ready(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Result<(), Self::Error>> {
-        if self.capacity == 0 {
-            return self.as_mut().sink().poll_ready(cx);
+        if *self.capacity == 0 {
+            return self.sink.as_mut().poll_ready(cx);
         }
 
-        let _ = self.as_mut().try_empty_buffer(cx)?;
+        let _ = try_empty_buffer(self.sink.as_mut(), self.buf, cx)?;
 
-        if self.buf.len() >= self.capacity {
+        if self.buf.len() >= *self.capacity {
             Poll::Pending
         } else {
             Poll::Ready(Ok(()))
         }
     }
 
+    #[pin_project(self)]
     fn start_send(
         mut self: Pin<&mut Self>,
         item: Item,
     ) -> Result<(), Self::Error> {
-        if self.capacity == 0 {
-            self.as_mut().sink().start_send(item)
+        if *self.capacity == 0 {
+            self.sink.start_send(item)
         } else {
-            self.as_mut().buf().push_back(item);
+            self.buf.push_back(item);
             Ok(())
         }
     }
 
+    #[pin_project(self)]
     fn poll_flush(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Result<(), Self::Error>> {
-        ready!(self.as_mut().try_empty_buffer(cx))?;
-        debug_assert!(self.as_mut().buf().is_empty());
-        self.as_mut().sink().poll_flush(cx)
+        ready!(try_empty_buffer(self.sink.as_mut(), self.buf, cx))?;
+        debug_assert!(self.buf.is_empty());
+        self.sink.poll_flush(cx)
     }
 
+    #[pin_project(self)]
     fn poll_close(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Result<(), Self::Error>> {
-        ready!(self.as_mut().try_empty_buffer(cx))?;
-        debug_assert!(self.as_mut().buf().is_empty());
-        self.as_mut().sink().poll_close(cx)
+        ready!(try_empty_buffer(self.sink.as_mut(), self.buf, cx))?;
+        debug_assert!(self.buf.is_empty());
+        self.sink.poll_close(cx)
     }
 }
diff --git a/futures-util/src/sink/err_into.rs b/futures-util/src/sink/err_into.rs
index 2118c409f0..140d030389 100644
--- a/futures-util/src/sink/err_into.rs
+++ b/futures-util/src/sink/err_into.rs
@@ -3,12 +3,14 @@ use core::pin::Pin;
 use futures_core::stream::Stream;
 use futures_core::task::{Context, Poll};
 use futures_sink::{Sink};
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// Sink for the [`sink_err_into`](super::SinkExt::sink_err_into) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "sinks do nothing unless polled"]
 pub struct SinkErrInto<Si: Sink<Item>, Item, E> {
+    #[pin]
     sink: SinkMapErr<Si, fn(Si::Error) -> E>,
 }
 
@@ -16,8 +18,6 @@ impl<Si, E, Item> SinkErrInto<Si, Item, E>
     where Si: Sink<Item>,
           Si::Error: Into<E>,
 {
-    unsafe_pinned!(sink: SinkMapErr<Si, fn(Si::Error) -> E>);
-
     pub(super) fn new(sink: Si) -> Self {
         SinkErrInto {
             sink: SinkExt::sink_map_err(sink, Into::into),
@@ -35,8 +35,9 @@ impl<Si, E, Item> SinkErrInto<Si, Item, E>
     }
 
     /// Get a pinned mutable reference to the inner sink.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut Si> {
-        self.sink().get_pin_mut()
+        self.sink.get_pin_mut()
     }
 
     /// Consumes this combinator, returning the underlying sink.
@@ -63,10 +64,11 @@ impl<S, Item, E> Stream for SinkErrInto<S, Item, E>
 {
     type Item = S::Item;
 
+    #[pin_project(self)]
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<S::Item>> {
-        self.sink().poll_next(cx)
+        self.sink.poll_next(cx)
     }
 }
diff --git a/futures-util/src/sink/fanout.rs b/futures-util/src/sink/fanout.rs
index 8ecf4a68c7..8bfe5836a2 100644
--- a/futures-util/src/sink/fanout.rs
+++ b/futures-util/src/sink/fanout.rs
@@ -2,22 +2,22 @@ use core::fmt::{Debug, Formatter, Result as FmtResult};
 use core::pin::Pin;
 use futures_core::task::{Context, Poll};
 use futures_sink::Sink;
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// Sink that clones incoming items and forwards them to two sinks at the same time.
 ///
 /// Backpressure from any downstream sink propagates up, which means that this sink
 /// can only process items as fast as its _slowest_ downstream sink.
+#[unsafe_project(Unpin)]
 #[must_use = "sinks do nothing unless polled"]
 pub struct Fanout<Si1, Si2> {
+    #[pin]
     sink1: Si1,
+    #[pin]
     sink2: Si2
 }
 
 impl<Si1, Si2> Fanout<Si1, Si2> {
-    unsafe_pinned!(sink1: Si1);
-    unsafe_pinned!(sink2: Si2);
-
     pub(super) fn new(sink1: Si1, sink2: Si2) -> Fanout<Si1, Si2> {
         Fanout { sink1, sink2 }
     }
@@ -65,41 +65,45 @@ impl<Si1, Si2, Item> Sink<Item> for Fanout<Si1, Si2>
 {
     type Error = Si1::Error;
 
+    #[pin_project(self)]
     fn poll_ready(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Result<(), Self::Error>> {
-        let sink1_ready = self.as_mut().sink1().poll_ready(cx)?.is_ready();
-        let sink2_ready = self.as_mut().sink2().poll_ready(cx)?.is_ready();
+        let sink1_ready = self.sink1.as_mut().poll_ready(cx)?.is_ready();
+        let sink2_ready = self.sink2.as_mut().poll_ready(cx)?.is_ready();
         let ready = sink1_ready && sink2_ready;
         if ready { Poll::Ready(Ok(())) } else { Poll::Pending }
     }
 
+    #[pin_project(self)]
     fn start_send(
         mut self: Pin<&mut Self>,
         item: Item,
     ) -> Result<(), Self::Error> {
-        self.as_mut().sink1().start_send(item.clone())?;
-        self.as_mut().sink2().start_send(item)?;
+        self.sink1.as_mut().start_send(item.clone())?;
+        self.sink2.as_mut().start_send(item)?;
         Ok(())
     }
 
+    #[pin_project(self)]
     fn poll_flush(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Result<(), Self::Error>> {
-        let sink1_ready = self.as_mut().sink1().poll_flush(cx)?.is_ready();
-        let sink2_ready = self.as_mut().sink2().poll_flush(cx)?.is_ready();
+        let sink1_ready = self.sink1.as_mut().poll_flush(cx)?.is_ready();
+        let sink2_ready = self.sink2.as_mut().poll_flush(cx)?.is_ready();
         let ready = sink1_ready && sink2_ready;
         if ready { Poll::Ready(Ok(())) } else { Poll::Pending }
     }
 
+    #[pin_project(self)]
     fn poll_close(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Result<(), Self::Error>> {
-        let sink1_ready = self.as_mut().sink1().poll_close(cx)?.is_ready();
-        let sink2_ready = self.as_mut().sink2().poll_close(cx)?.is_ready();
+        let sink1_ready = self.sink1.as_mut().poll_close(cx)?.is_ready();
+        let sink2_ready = self.sink2.as_mut().poll_close(cx)?.is_ready();
         let ready = sink1_ready && sink2_ready;
         if ready { Poll::Ready(Ok(())) } else { Poll::Pending }
     }
diff --git a/futures-util/src/stream/buffer_unordered.rs b/futures-util/src/stream/buffer_unordered.rs
index 479a1093ef..6754147c9f 100644
--- a/futures-util/src/stream/buffer_unordered.rs
+++ b/futures-util/src/stream/buffer_unordered.rs
@@ -1,32 +1,28 @@
 use crate::stream::{Fuse, FuturesUnordered, StreamExt};
+use core::fmt;
+use core::pin::Pin;
 use futures_core::future::Future;
 use futures_core::stream::{Stream, FusedStream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
-use core::fmt;
-use core::pin::Pin;
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`buffer_unordered`](super::StreamExt::buffer_unordered)
 /// method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct BufferUnordered<St>
 where
     St: Stream,
     St::Item: Future,
 {
+    #[pin]
     stream: Fuse<St>,
     in_progress_queue: FuturesUnordered<St::Item>,
     max: usize,
 }
 
-impl<St> Unpin for BufferUnordered<St>
-where
-    St: Stream + Unpin,
-    St::Item: Future,
-{}
-
 impl<St> fmt::Debug for BufferUnordered<St>
 where
     St: Stream + fmt::Debug,
@@ -46,9 +42,6 @@ where
     St: Stream,
     St::Item: Future,
 {
-    unsafe_pinned!(stream: Fuse<St>);
-    unsafe_unpinned!(in_progress_queue: FuturesUnordered<St::Item>);
-
     pub(super) fn new(stream: St, n: usize) -> BufferUnordered<St>
     where
         St: Stream,
@@ -81,8 +74,9 @@ where
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream().get_pin_mut()
+        self.stream.get_pin_mut()
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -101,21 +95,22 @@ where
 {
     type Item = <St::Item as Future>::Output;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
         // First up, try to spawn off as many futures as possible by filling up
         // our queue of futures.
-        while self.in_progress_queue.len() < self.max {
-            match self.as_mut().stream().poll_next(cx) {
-                Poll::Ready(Some(fut)) => self.as_mut().in_progress_queue().push(fut),
+        while self.in_progress_queue.len() < *self.max {
+            match self.stream.as_mut().poll_next(cx) {
+                Poll::Ready(Some(fut)) => self.in_progress_queue.push(fut),
                 Poll::Ready(None) | Poll::Pending => break,
             }
         }
 
         // Attempt to pull the next value from the in_progress_queue
-        match self.as_mut().in_progress_queue().poll_next_unpin(cx) {
+        match self.in_progress_queue.poll_next_unpin(cx) {
             x @ Poll::Pending | x @ Poll::Ready(Some(_)) => return x,
             Poll::Ready(None) => {}
         }
diff --git a/futures-util/src/stream/buffered.rs b/futures-util/src/stream/buffered.rs
index d63c479a6b..49a1bd0f8d 100644
--- a/futures-util/src/stream/buffered.rs
+++ b/futures-util/src/stream/buffered.rs
@@ -1,31 +1,27 @@
 use crate::stream::{Fuse, FuturesOrdered, StreamExt};
+use core::fmt;
+use core::pin::Pin;
 use futures_core::future::Future;
 use futures_core::stream::Stream;
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
-use core::fmt;
-use core::pin::Pin;
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`buffered`](super::StreamExt::buffered) method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct Buffered<St: Stream>
 where
     St: Stream,
     St::Item: Future,
 {
+    #[pin]
     stream: Fuse<St>,
     in_progress_queue: FuturesOrdered<St::Item>,
     max: usize,
 }
 
-impl<St> Unpin for Buffered<St>
-where
-    St: Stream + Unpin,
-    St::Item: Future,
-{}
-
 impl<St> fmt::Debug for Buffered<St>
 where
     St: Stream + fmt::Debug,
@@ -45,9 +41,6 @@ where
     St: Stream,
     St::Item: Future,
 {
-    unsafe_pinned!(stream: Fuse<St>);
-    unsafe_unpinned!(in_progress_queue: FuturesOrdered<St::Item>);
-
     pub(super) fn new(stream: St, n: usize) -> Buffered<St> {
         Buffered {
             stream: super::Fuse::new(stream),
@@ -76,8 +69,9 @@ where
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream().get_pin_mut()
+        self.stream.get_pin_mut()
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -96,21 +90,22 @@ where
 {
     type Item = <St::Item as Future>::Output;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
         // Try to spawn off as many futures as possible by filling up
         // our in_progress_queue of futures.
-        while self.in_progress_queue.len() < self.max {
-            match self.as_mut().stream().poll_next(cx) {
-                Poll::Ready(Some(fut)) => self.as_mut().in_progress_queue().push(fut),
+        while self.in_progress_queue.len() < *self.max {
+            match self.stream.as_mut().poll_next(cx) {
+                Poll::Ready(Some(fut)) => self.in_progress_queue.push(fut),
                 Poll::Ready(None) | Poll::Pending => break,
             }
         }
 
         // Attempt to pull the next value from the in_progress_queue
-        let res = self.as_mut().in_progress_queue().poll_next_unpin(cx);
+        let res = self.in_progress_queue.poll_next_unpin(cx);
         if let Some(val) = ready!(res) {
             return Poll::Ready(Some(val))
         }
diff --git a/futures-util/src/stream/catch_unwind.rs b/futures-util/src/stream/catch_unwind.rs
index 696698841b..a724841a94 100644
--- a/futures-util/src/stream/catch_unwind.rs
+++ b/futures-util/src/stream/catch_unwind.rs
@@ -1,22 +1,21 @@
 use futures_core::stream::Stream;
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 use std::any::Any;
-use std::pin::Pin;
 use std::panic::{catch_unwind, UnwindSafe, AssertUnwindSafe};
+use std::pin::Pin;
 
 /// Stream for the [`catch_unwind`](super::StreamExt::catch_unwind) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "streams do nothing unless polled"]
 pub struct CatchUnwind<St: Stream> {
+    #[pin]
     stream: St,
     caught_unwind: bool,
 }
 
 impl<St: Stream + UnwindSafe> CatchUnwind<St> {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(caught_unwind: bool);
-
     pub(super) fn new(stream: St) -> CatchUnwind<St> {
         CatchUnwind { stream, caught_unwind: false }
     }
@@ -26,21 +25,22 @@ impl<St: Stream + UnwindSafe> Stream for CatchUnwind<St>
 {
     type Item = Result<St::Item, Box<dyn Any + Send>>;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        if self.caught_unwind {
+        if *self.caught_unwind {
             Poll::Ready(None)
         } else {
             let res = catch_unwind(AssertUnwindSafe(|| {
-                self.as_mut().stream().poll_next(cx)
+                self.stream.as_mut().poll_next(cx)
             }));
 
             match res {
                 Ok(poll) => poll.map(|opt| opt.map(Ok)),
                 Err(e) => {
-                    *self.as_mut().caught_unwind() = true;
+                    *self.caught_unwind = true;
                     Poll::Ready(Some(Err(e)))
                 },
             }
diff --git a/futures-util/src/stream/chain.rs b/futures-util/src/stream/chain.rs
index 084cd5a62b..620d4ccd53 100644
--- a/futures-util/src/stream/chain.rs
+++ b/futures-util/src/stream/chain.rs
@@ -1,13 +1,16 @@
 use core::pin::Pin;
 use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Context, Poll};
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`chain`](super::StreamExt::chain) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "streams do nothing unless polled"]
 pub struct Chain<St1, St2> {
+    #[pin]
     first: Option<St1>,
+    #[pin]
     second: St2,
 }
 
@@ -16,9 +19,6 @@ impl<St1, St2> Chain<St1, St2>
 where St1: Stream,
       St2: Stream<Item = St1::Item>,
 {
-    unsafe_pinned!(first: Option<St1>);
-    unsafe_pinned!(second: St2);
-
     pub(super) fn new(stream1: St1, stream2: St2) -> Chain<St1, St2> {
         Chain {
             first: Some(stream1),
@@ -39,16 +39,17 @@ where St1: Stream,
 {
     type Item = St1::Item;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        if let Some(first) = self.as_mut().first().as_pin_mut() {
+        if let Some(first) = self.first.as_mut().as_pin_mut() {
             if let Some(item) = ready!(first.poll_next(cx)) {
                 return Poll::Ready(Some(item))
             }
         }
-        self.as_mut().first().set(None);
-        self.as_mut().second().poll_next(cx)
+        self.first.set(None);
+        self.second.poll_next(cx)
     }
 }
diff --git a/futures-util/src/stream/chunks.rs b/futures-util/src/stream/chunks.rs
index ff9a6a56d8..3cd61d176c 100644
--- a/futures-util/src/stream/chunks.rs
+++ b/futures-util/src/stream/chunks.rs
@@ -3,26 +3,23 @@ use futures_core::stream::Stream;
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 use core::mem;
 use core::pin::Pin;
 use alloc::vec::Vec;
 
 /// Stream for the [`chunks`](super::StreamExt::chunks) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "streams do nothing unless polled"]
 pub struct Chunks<St: Stream> {
+    #[pin]
     stream: Fuse<St>,
     items: Vec<St::Item>,
     cap: usize, // https://github.com/rust-lang-nursery/futures-rs/issues/1475
 }
 
-impl<St: Unpin + Stream> Unpin for Chunks<St> {}
-
 impl<St: Stream> Chunks<St> where St: Stream {
-    unsafe_unpinned!(items:  Vec<St::Item>);
-    unsafe_pinned!(stream: Fuse<St>);
-
     pub(super) fn new(stream: St, capacity: usize) -> Chunks<St> {
         assert!(capacity > 0);
 
@@ -33,11 +30,6 @@ impl<St: Stream> Chunks<St> where St: Stream {
         }
     }
 
-    fn take(mut self: Pin<&mut Self>) -> Vec<St::Item> {
-        let cap = self.cap;
-        mem::replace(self.as_mut().items(), Vec::with_capacity(cap))
-    }
-
     /// Acquires a reference to the underlying stream that this combinator is
     /// pulling from.
     pub fn get_ref(&self) -> &St {
@@ -58,8 +50,9 @@ impl<St: Stream> Chunks<St> where St: Stream {
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream().get_pin_mut()
+        self.stream.get_pin_mut()
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -74,19 +67,21 @@ impl<St: Stream> Chunks<St> where St: Stream {
 impl<St: Stream> Stream for Chunks<St> {
     type Item = Vec<St::Item>;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
         loop {
-            match ready!(self.as_mut().stream().poll_next(cx)) {
+            match ready!(self.stream.as_mut().poll_next(cx)) {
                 // Push the item into the buffer and check whether it is full.
                 // If so, replace our buffer with a new and empty one and return
                 // the full one.
                 Some(item) => {
-                    self.as_mut().items().push(item);
-                    if self.items.len() >= self.cap {
-                        return Poll::Ready(Some(self.as_mut().take()))
+                    self.items.push(item);
+                    if self.items.len() >= *self.cap {
+                        let cap = *self.cap;
+                        return Poll::Ready(Some(mem::replace(self.items, Vec::with_capacity(cap))));
                     }
                 }
 
@@ -96,7 +91,7 @@ impl<St: Stream> Stream for Chunks<St> {
                     let last = if self.items.is_empty() {
                         None
                     } else {
-                        let full_buf = mem::replace(self.as_mut().items(), Vec::new());
+                        let full_buf = mem::replace(self.items, Vec::new());
                         Some(full_buf)
                     };
 
diff --git a/futures-util/src/stream/collect.rs b/futures-util/src/stream/collect.rs
index 0952cb261b..52fd177c72 100644
--- a/futures-util/src/stream/collect.rs
+++ b/futures-util/src/stream/collect.rs
@@ -3,26 +3,19 @@ use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future};
 use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`collect`](super::StreamExt::collect) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct Collect<St, C> {
+    #[pin]
     stream: St,
     collection: C,
 }
 
-impl<St: Unpin + Stream, C> Unpin for Collect<St, C> {}
-
 impl<St: Stream, C: Default> Collect<St, C> {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(collection: C);
-
-    fn finish(mut self: Pin<&mut Self>) -> C {
-        mem::replace(self.as_mut().collection(), Default::default())
-    }
-
     pub(super) fn new(stream: St) -> Collect<St, C> {
         Collect {
             stream,
@@ -43,11 +36,12 @@ where St: Stream,
 {
     type Output = C;
 
+    #[pin_project(self)]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<C> {
         loop {
-            match ready!(self.as_mut().stream().poll_next(cx)) {
-                Some(e) => self.as_mut().collection().extend(Some(e)),
-                None => return Poll::Ready(self.as_mut().finish()),
+            match ready!(self.stream.as_mut().poll_next(cx)) {
+                Some(e) => self.collection.extend(Some(e)),
+                None => return Poll::Ready(mem::replace(self.collection, Default::default())),
             }
         }
     }
diff --git a/futures-util/src/stream/concat.rs b/futures-util/src/stream/concat.rs
index 0aa04dbb23..eb42cfd5a9 100644
--- a/futures-util/src/stream/concat.rs
+++ b/futures-util/src/stream/concat.rs
@@ -2,26 +2,23 @@ use core::pin::Pin;
 use futures_core::future::Future;
 use futures_core::stream::Stream;
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`concat`](super::StreamExt::concat) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct Concat<St: Stream> {
+    #[pin]
     stream: St,
     accum: Option<St::Item>,
 }
 
-impl<St: Stream + Unpin> Unpin for Concat<St> {}
-
 impl<St> Concat<St>
 where St: Stream,
       St::Item: Extend<<St::Item as IntoIterator>::Item> +
                 IntoIterator + Default,
 {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(accum: Option<St::Item>);
-
     pub(super) fn new(stream: St) -> Concat<St> {
         Concat {
             stream,
@@ -37,20 +34,18 @@ where St: Stream,
 {
     type Output = St::Item;
 
-    fn poll(
-        mut self: Pin<&mut Self>, cx: &mut Context<'_>
-    ) -> Poll<Self::Output> {
+    #[pin_project(self)]
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         loop {
-            match ready!(self.as_mut().stream().poll_next(cx)) {
+            match ready!(self.stream.as_mut().poll_next(cx)) {
                 None => {
-                    return Poll::Ready(self.as_mut().accum().take().unwrap_or_default())
+                    return Poll::Ready(self.accum.take().unwrap_or_default())
                 }
                 Some(e) => {
-                    let accum = self.as_mut().accum();
-                    if let Some(a) = accum {
+                    if let Some(a) = self.accum {
                         a.extend(e)
                     } else {
-                        *accum = Some(e)
+                        *self.accum = Some(e)
                     }
                 }
             }
diff --git a/futures-util/src/stream/enumerate.rs b/futures-util/src/stream/enumerate.rs
index 774dfbe1f9..5af1915fb9 100644
--- a/futures-util/src/stream/enumerate.rs
+++ b/futures-util/src/stream/enumerate.rs
@@ -3,22 +3,19 @@ use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`enumerate`](super::StreamExt::enumerate) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "streams do nothing unless polled"]
 pub struct Enumerate<St: Stream> {
+    #[pin]
     stream: St,
     count: usize,
 }
 
-impl<St: Stream + Unpin> Unpin for Enumerate<St> {}
-
 impl<St: Stream> Enumerate<St> {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(count: usize);
-
     pub(super) fn new(stream: St) -> Enumerate<St> {
         Enumerate {
             stream,
@@ -46,8 +43,9 @@ impl<St: Stream> Enumerate<St> {
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -68,14 +66,15 @@ impl<St: Stream + FusedStream> FusedStream for Enumerate<St> {
 impl<St: Stream> Stream for Enumerate<St> {
     type Item = (usize, St::Item);
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        match ready!(self.as_mut().stream().poll_next(cx)) {
+        match ready!(self.stream.as_mut().poll_next(cx)) {
             Some(item) => {
-                let count = self.count;
-                *self.as_mut().count() += 1;
+                let count = *self.count;
+                *self.count += 1;
                 Poll::Ready(Some((count, item)))
             }
             None => Poll::Ready(None),
diff --git a/futures-util/src/stream/filter.rs b/futures-util/src/stream/filter.rs
index 471105a5a3..561bb960bf 100644
--- a/futures-util/src/stream/filter.rs
+++ b/futures-util/src/stream/filter.rs
@@ -5,25 +5,22 @@ use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`filter`](super::StreamExt::filter) method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct Filter<St, Fut, F>
     where St: Stream,
 {
+    #[pin]
     stream: St,
     f: F,
+    #[pin]
     pending_fut: Option<Fut>,
     pending_item: Option<St::Item>,
 }
 
-impl<St, Fut, F> Unpin for Filter<St, Fut, F>
-where
-    St: Stream + Unpin,
-    Fut: Unpin,
-{}
-
 impl<St, Fut, F> fmt::Debug for Filter<St, Fut, F>
 where
     St: Stream + fmt::Debug,
@@ -44,11 +41,6 @@ where St: Stream,
       F: FnMut(&St::Item) -> Fut,
       Fut: Future<Output = bool>,
 {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(f: F);
-    unsafe_pinned!(pending_fut: Option<Fut>);
-    unsafe_unpinned!(pending_item: Option<St::Item>);
-
     pub(super) fn new(stream: St, f: F) -> Filter<St, Fut, F> {
         Filter {
             stream,
@@ -78,8 +70,9 @@ where St: Stream,
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -108,24 +101,25 @@ impl<St, Fut, F> Stream for Filter<St, Fut, F>
 {
     type Item = St::Item;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<St::Item>> {
         loop {
             if self.pending_fut.is_none() {
-                let item = match ready!(self.as_mut().stream().poll_next(cx)) {
+                let item = match ready!(self.stream.as_mut().poll_next(cx)) {
                     Some(e) => e,
                     None => return Poll::Ready(None),
                 };
-                let fut = (self.as_mut().f())(&item);
-                self.as_mut().pending_fut().set(Some(fut));
-                *self.as_mut().pending_item() = Some(item);
+                let fut = (self.f)(&item);
+                self.pending_fut.set(Some(fut));
+                *self.pending_item = Some(item);
             }
 
-            let yield_item = ready!(self.as_mut().pending_fut().as_pin_mut().unwrap().poll(cx));
-            self.as_mut().pending_fut().set(None);
-            let item = self.as_mut().pending_item().take().unwrap();
+            let yield_item = ready!(self.pending_fut.as_mut().as_pin_mut().unwrap().poll(cx));
+            self.pending_fut.set(None);
+            let item = self.pending_item.take().unwrap();
 
             if yield_item {
                 return Poll::Ready(Some(item));
diff --git a/futures-util/src/stream/filter_map.rs b/futures-util/src/stream/filter_map.rs
index 9ffcb93d76..fa01454626 100644
--- a/futures-util/src/stream/filter_map.rs
+++ b/futures-util/src/stream/filter_map.rs
@@ -5,22 +5,19 @@ use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`filter_map`](super::StreamExt::filter_map) method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct FilterMap<St, Fut, F> {
+    #[pin]
     stream: St,
     f: F,
+    #[pin]
     pending: Option<Fut>,
 }
 
-impl<St, Fut, F> Unpin for FilterMap<St, Fut, F>
-where
-    St: Unpin,
-    Fut: Unpin,
-{}
-
 impl<St, Fut, F> fmt::Debug for FilterMap<St, Fut, F>
 where
     St: fmt::Debug,
@@ -39,10 +36,6 @@ impl<St, Fut, F> FilterMap<St, Fut, F>
           F: FnMut(St::Item) -> Fut,
           Fut: Future,
 {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(f: F);
-    unsafe_pinned!(pending: Option<Fut>);
-
     pub(super) fn new(stream: St, f: F) -> FilterMap<St, Fut, F> {
         FilterMap { stream, f, pending: None }
     }
@@ -67,8 +60,9 @@ impl<St, Fut, F> FilterMap<St, Fut, F>
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -97,22 +91,23 @@ impl<St, Fut, F, T> Stream for FilterMap<St, Fut, F>
 {
     type Item = T;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<T>> {
         loop {
             if self.pending.is_none() {
-                let item = match ready!(self.as_mut().stream().poll_next(cx)) {
+                let item = match ready!(self.stream.as_mut().poll_next(cx)) {
                     Some(e) => e,
                     None => return Poll::Ready(None),
                 };
-                let fut = (self.as_mut().f())(item);
-                self.as_mut().pending().set(Some(fut));
+                let fut = (self.f)(item);
+                self.pending.set(Some(fut));
             }
 
-            let item = ready!(self.as_mut().pending().as_pin_mut().unwrap().poll(cx));
-            self.as_mut().pending().set(None);
+            let item = ready!(self.pending.as_mut().as_pin_mut().unwrap().poll(cx));
+            self.pending.set(None);
             if item.is_some() {
                 return Poll::Ready(item);
             }
diff --git a/futures-util/src/stream/flatten.rs b/futures-util/src/stream/flatten.rs
index df43f7e1ee..ee671a1436 100644
--- a/futures-util/src/stream/flatten.rs
+++ b/futures-util/src/stream/flatten.rs
@@ -3,30 +3,25 @@ use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`flatten`](super::StreamExt::flatten) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "streams do nothing unless polled"]
 pub struct Flatten<St>
     where St: Stream,
 {
+    #[pin]
     stream: St,
+    #[pin]
     next: Option<St::Item>,
 }
 
-impl<St: Stream> Unpin for Flatten<St>
-where St: Stream + Unpin,
-      St::Item: Stream + Unpin,
-{}
-
 impl<St: Stream> Flatten<St>
 where St: Stream,
       St::Item: Stream,
 {
-    unsafe_pinned!(stream: St);
-    unsafe_pinned!(next: Option<St::Item>);
-
     pub(super) fn new(stream: St) -> Flatten<St>{
         Flatten { stream, next: None, }
     }
@@ -51,8 +46,9 @@ where St: Stream,
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -76,22 +72,23 @@ impl<St> Stream for Flatten<St>
 {
     type Item = <St::Item as Stream>::Item;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
         loop {
             if self.next.is_none() {
-                match ready!(self.as_mut().stream().poll_next(cx)) {
-                    Some(e) => self.as_mut().next().set(Some(e)),
+                match ready!(self.stream.as_mut().poll_next(cx)) {
+                    Some(e) => self.next.set(Some(e)),
                     None => return Poll::Ready(None),
                 }
             }
-            let item = ready!(self.as_mut().next().as_pin_mut().unwrap().poll_next(cx));
+            let item = ready!(self.next.as_mut().as_pin_mut().unwrap().poll_next(cx));
             if item.is_some() {
                 return Poll::Ready(item);
             } else {
-                self.as_mut().next().set(None);
+                self.next.set(None);
             }
         }
     }
diff --git a/futures-util/src/stream/fold.rs b/futures-util/src/stream/fold.rs
index 0e7e007585..6fd74de43f 100644
--- a/futures-util/src/stream/fold.rs
+++ b/futures-util/src/stream/fold.rs
@@ -3,19 +3,20 @@ use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future};
 use futures_core::stream::Stream;
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`fold`](super::StreamExt::fold) method.
+#[unsafe_project(Unpin)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct Fold<St, Fut, T, F> {
+    #[pin]
     stream: St,
     f: F,
     accum: Option<T>,
+    #[pin]
     future: Option<Fut>,
 }
 
-impl<St: Unpin, Fut: Unpin, T, F> Unpin for Fold<St, Fut, T, F> {}
-
 impl<St, Fut, T, F> fmt::Debug for Fold<St, Fut, T, F>
 where
     St: fmt::Debug,
@@ -36,11 +37,6 @@ where St: Stream,
       F: FnMut(T, St::Item) -> Fut,
       Fut: Future<Output = T>,
 {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(f: F);
-    unsafe_unpinned!(accum: Option<T>);
-    unsafe_pinned!(future: Option<Fut>);
-
     pub(super) fn new(stream: St, f: F, t: T) -> Fold<St, Fut, T, F> {
         Fold {
             stream,
@@ -64,22 +60,22 @@ impl<St, Fut, T, F> Future for Fold<St, Fut, T, F>
 {
     type Output = T;
 
+    #[pin_project(self)]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
         loop {
             // we're currently processing a future to produce a new accum value
             if self.accum.is_none() {
-                let accum = ready!(self.as_mut().future().as_pin_mut().unwrap().poll(cx));
-                *self.as_mut().accum() = Some(accum);
-                self.as_mut().future().set(None);
+                let accum = ready!(self.future.as_mut().as_pin_mut().unwrap().poll(cx));
+                *self.accum = Some(accum);
+                self.future.set(None);
             }
 
-            let item = ready!(self.as_mut().stream().poll_next(cx));
-            let accum = self.as_mut().accum().take()
-                .expect("Fold polled after completion");
+            let item = ready!(self.stream.as_mut().poll_next(cx));
+            let accum = self.accum.take().expect("Fold polled after completion");
 
             if let Some(e) = item {
-                let future = (self.as_mut().f())(accum, e);
-                self.as_mut().future().set(Some(future));
+                let future = (self.f)(accum, e);
+                self.future.set(Some(future));
             } else {
                 return Poll::Ready(accum)
             }
diff --git a/futures-util/src/stream/for_each.rs b/futures-util/src/stream/for_each.rs
index 8ff6a25e39..02b84a2cba 100644
--- a/futures-util/src/stream/for_each.rs
+++ b/futures-util/src/stream/for_each.rs
@@ -3,22 +3,19 @@ use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future};
 use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`for_each`](super::StreamExt::for_each) method.
+#[unsafe_project(Unpin)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct ForEach<St, Fut, F> {
+    #[pin]
     stream: St,
     f: F,
+    #[pin]
     future: Option<Fut>,
 }
 
-impl<St, Fut, F> Unpin for ForEach<St, Fut, F>
-where
-    St: Unpin,
-    Fut: Unpin,
-{}
-
 impl<St, Fut, F> fmt::Debug for ForEach<St, Fut, F>
 where
     St: fmt::Debug,
@@ -37,10 +34,6 @@ where St: Stream,
       F: FnMut(St::Item) -> Fut,
       Fut: Future<Output = ()>,
 {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(f: F);
-    unsafe_pinned!(future: Option<Fut>);
-
     pub(super) fn new(stream: St, f: F) -> ForEach<St, Fut, F> {
         ForEach {
             stream,
@@ -63,17 +56,18 @@ impl<St, Fut, F> Future for ForEach<St, Fut, F>
 {
     type Output = ();
 
+    #[pin_project(self)]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
         loop {
-            if let Some(future) = self.as_mut().future().as_pin_mut() {
+            if let Some(future) = self.future.as_mut().as_pin_mut() {
                 ready!(future.poll(cx));
             }
-            self.as_mut().future().set(None);
+            self.future.set(None);
 
-            match ready!(self.as_mut().stream().poll_next(cx)) {
+            match ready!(self.stream.as_mut().poll_next(cx)) {
                 Some(e) => {
-                    let future = (self.as_mut().f())(e);
-                    self.as_mut().future().set(Some(future));
+                    let future = (self.f)(e);
+                    self.future.set(Some(future));
                 }
                 None => {
                     return Poll::Ready(());
diff --git a/futures-util/src/stream/for_each_concurrent.rs b/futures-util/src/stream/for_each_concurrent.rs
index d6460ed926..6b7a03ef65 100644
--- a/futures-util/src/stream/for_each_concurrent.rs
+++ b/futures-util/src/stream/for_each_concurrent.rs
@@ -5,23 +5,20 @@ use core::num::NonZeroUsize;
 use futures_core::future::{FusedFuture, Future};
 use futures_core::stream::Stream;
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`for_each_concurrent`](super::StreamExt::for_each_concurrent)
 /// method.
+#[unsafe_project(Unpin)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct ForEachConcurrent<St, Fut, F> {
+    #[pin]
     stream: Option<St>,
     f: F,
     futures: FuturesUnordered<Fut>,
     limit: Option<NonZeroUsize>,
 }
 
-impl<St, Fut, F> Unpin for ForEachConcurrent<St, Fut, F>
-where St: Unpin,
-      Fut: Unpin,
-{}
-
 impl<St, Fut, F> fmt::Debug for ForEachConcurrent<St, Fut, F>
 where
     St: fmt::Debug,
@@ -41,11 +38,6 @@ where St: Stream,
       F: FnMut(St::Item) -> Fut,
       Fut: Future<Output = ()>,
 {
-    unsafe_pinned!(stream: Option<St>);
-    unsafe_unpinned!(f: F);
-    unsafe_unpinned!(futures: FuturesUnordered<Fut>);
-    unsafe_unpinned!(limit: Option<NonZeroUsize>);
-
     pub(super) fn new(stream: St, limit: Option<usize>, f: F) -> ForEachConcurrent<St, Fut, F> {
         ForEachConcurrent {
             stream: Some(stream),
@@ -70,6 +62,7 @@ impl<St, Fut, F> Future for ForEachConcurrent<St, Fut, F>
 {
     type Output = ();
 
+    #[pin_project(self)]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
         loop {
             let mut made_progress_this_iter = false;
@@ -79,7 +72,7 @@ impl<St, Fut, F> Future for ForEachConcurrent<St, Fut, F>
             // Check if we've already created a number of futures greater than `limit`
             if self.limit.map(|limit| limit.get() > current_len).unwrap_or(true) {
                 let mut stream_completed = false;
-                let elem = if let Some(stream) = self.as_mut().stream().as_pin_mut() {
+                let elem = if let Some(stream) = self.stream.as_mut().as_pin_mut() {
                     match stream.poll_next(cx) {
                         Poll::Ready(Some(elem)) => {
                             made_progress_this_iter = true;
@@ -95,15 +88,15 @@ impl<St, Fut, F> Future for ForEachConcurrent<St, Fut, F>
                     None
                 };
                 if stream_completed {
-                    self.as_mut().stream().set(None);
+                    self.stream.set(None);
                 }
                 if let Some(elem) = elem {
-                    let next_future = (self.as_mut().f())(elem);
-                    self.as_mut().futures().push(next_future);
+                    let next_future = (self.f)(elem);
+                    self.futures.push(next_future);
                 }
             }
 
-            match self.as_mut().futures().poll_next_unpin(cx) {
+            match self.futures.poll_next_unpin(cx) {
                 Poll::Ready(Some(())) => made_progress_this_iter = true,
                 Poll::Ready(None) => {
                     if self.stream.is_none() {
diff --git a/futures-util/src/stream/fuse.rs b/futures-util/src/stream/fuse.rs
index 5ef42208fa..03e8ee062e 100644
--- a/futures-util/src/stream/fuse.rs
+++ b/futures-util/src/stream/fuse.rs
@@ -3,22 +3,19 @@ use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`fuse`](super::StreamExt::fuse) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "streams do nothing unless polled"]
 pub struct Fuse<St> {
+    #[pin]
     stream: St,
     done: bool,
 }
 
-impl<St: Unpin> Unpin for Fuse<St> {}
-
 impl<St> Fuse<St> {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(done: bool);
-
     pub(super) fn new(stream: St) -> Fuse<St> {
         Fuse { stream, done: false }
     }
@@ -52,8 +49,9 @@ impl<St> Fuse<St> {
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -74,17 +72,18 @@ impl<S> FusedStream for Fuse<S> {
 impl<S: Stream> Stream for Fuse<S> {
     type Item = S::Item;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<S::Item>> {
-        if self.done {
+        if *self.done {
             return Poll::Ready(None);
         }
 
-        let item = ready!(self.as_mut().stream().poll_next(cx));
+        let item = ready!(self.stream.as_mut().poll_next(cx));
         if item.is_none() {
-            *self.as_mut().done() = true;
+            *self.done = true;
         }
         Poll::Ready(item)
     }
diff --git a/futures-util/src/stream/inspect.rs b/futures-util/src/stream/inspect.rs
index 90876df216..df1c45c208 100644
--- a/futures-util/src/stream/inspect.rs
+++ b/futures-util/src/stream/inspect.rs
@@ -4,17 +4,17 @@ use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`inspect`](super::StreamExt::inspect) method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct Inspect<St, F> {
+    #[pin]
     stream: St,
     f: F,
 }
 
-impl<St: Unpin, F> Unpin for Inspect<St, F> {}
-
 impl<St, F> fmt::Debug for Inspect<St, F>
 where
     St: fmt::Debug,
@@ -30,9 +30,6 @@ impl<St, F> Inspect<St, F>
     where St: Stream,
           F: FnMut(&St::Item),
 {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(f: F);
-
     pub(super) fn new(stream: St, f: F) -> Inspect<St, F> {
         Inspect { stream, f }
     }
@@ -57,8 +54,9 @@ impl<St, F> Inspect<St, F>
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -89,14 +87,15 @@ impl<St, F> Stream for Inspect<St, F>
 {
     type Item = St::Item;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<St::Item>> {
-        self.as_mut()
-            .stream()
+        self.stream
+            .as_mut()
             .poll_next(cx)
-            .map(|opt| opt.map(|e| inspect(e, self.as_mut().f())))
+            .map(|opt| opt.map(|e| inspect(e, self.f)))
     }
 }
 
diff --git a/futures-util/src/stream/map.rs b/futures-util/src/stream/map.rs
index 1132a6ad25..087a36f021 100644
--- a/futures-util/src/stream/map.rs
+++ b/futures-util/src/stream/map.rs
@@ -4,17 +4,17 @@ use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`map`](super::StreamExt::map) method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct Map<St, F> {
+    #[pin]
     stream: St,
     f: F,
 }
 
-impl<St: Unpin, F> Unpin for Map<St, F> {}
-
 impl<St, F> fmt::Debug for Map<St, F>
 where
     St: fmt::Debug,
@@ -30,9 +30,6 @@ impl<St, T, F> Map<St, F>
     where St: Stream,
           F: FnMut(St::Item) -> T,
 {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(f: F);
-
     pub(super) fn new(stream: St, f: F) -> Map<St, F> {
         Map { stream, f }
     }
@@ -57,8 +54,9 @@ impl<St, T, F> Map<St, F>
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -82,14 +80,15 @@ impl<St, F, T> Stream for Map<St, F>
 {
     type Item = T;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<T>> {
-        self.as_mut()
-            .stream()
+        self.stream
+            .as_mut()
             .poll_next(cx)
-            .map(|opt| opt.map(|x| self.as_mut().f()(x)))
+            .map(|opt| opt.map(|x| (self.f)(x)))
     }
 }
 
diff --git a/futures-util/src/stream/once.rs b/futures-util/src/stream/once.rs
index a530bb1624..6d2c279800 100644
--- a/futures-util/src/stream/once.rs
+++ b/futures-util/src/stream/once.rs
@@ -2,7 +2,7 @@ use core::pin::Pin;
 use futures_core::future::Future;
 use futures_core::stream::Stream;
 use futures_core::task::{Context, Poll};
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// Creates a stream of a single element.
 ///
@@ -24,31 +24,28 @@ pub fn once<Fut: Future>(future: Fut) -> Once<Fut> {
 /// A stream which emits single element and then EOF.
 ///
 /// This stream will never block and is always ready.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "streams do nothing unless polled"]
 pub struct Once<Fut> {
+    #[pin]
     future: Option<Fut>
 }
 
-impl<Fut: Unpin> Unpin for Once<Fut> {}
-
-impl<Fut> Once<Fut> {
-    unsafe_pinned!(future: Option<Fut>);
-}
-
 impl<Fut: Future> Stream for Once<Fut> {
     type Item = Fut::Output;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Fut::Output>> {
-        let val = if let Some(f) = self.as_mut().future().as_pin_mut() {
+        let val = if let Some(f) = self.future.as_mut().as_pin_mut() {
             ready!(f.poll(cx))
         } else {
             return Poll::Ready(None)
         };
-        self.future().set(None);
+        self.future.set(None);
         Poll::Ready(Some(val))
     }
 }
diff --git a/futures-util/src/stream/peek.rs b/futures-util/src/stream/peek.rs
index abdf2be9f6..fd529be0c4 100644
--- a/futures-util/src/stream/peek.rs
+++ b/futures-util/src/stream/peek.rs
@@ -4,26 +4,23 @@ use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// A `Stream` that implements a `peek` method.
 ///
 /// The `peek` method can be used to retrieve a reference
 /// to the next `Stream::Item` if available. A subsequent
 /// call to `poll` will return the owned item.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "streams do nothing unless polled"]
 pub struct Peekable<St: Stream> {
+    #[pin]
     stream: Fuse<St>,
     peeked: Option<St::Item>,
 }
 
-impl<St: Stream + Unpin> Unpin for Peekable<St> {}
-
 impl<St: Stream> Peekable<St> {
-    unsafe_pinned!(stream: Fuse<St>);
-    unsafe_unpinned!(peeked: Option<St::Item>);
-
     pub(super) fn new(stream: St) -> Peekable<St> {
         Peekable {
             stream: stream.fuse(),
@@ -51,8 +48,9 @@ impl<St: Stream> Peekable<St> {
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream().get_pin_mut()
+        self.stream.get_pin_mut()
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -67,20 +65,19 @@ impl<St: Stream> Peekable<St> {
     ///
     /// This method polls the underlying stream and return either a reference
     /// to the next item if the stream is ready or passes through any errors.
+    #[pin_project(self)]
     pub fn peek<'a>(
         mut self: Pin<&'a mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<&'a St::Item>> {
         if self.peeked.is_some() {
-            let this: &Self = self.into_ref().get_ref();
-            return Poll::Ready(this.peeked.as_ref())
+            return Poll::Ready(self.peeked.as_ref())
         }
-        match ready!(self.as_mut().stream().poll_next(cx)) {
+        match ready!(self.stream.as_mut().poll_next(cx)) {
             None => Poll::Ready(None),
             Some(item) => {
-                *self.as_mut().peeked() = Some(item);
-                let this: &Self = self.into_ref().get_ref();
-                Poll::Ready(this.peeked.as_ref())
+                *self.peeked = Some(item);
+                Poll::Ready(self.peeked.as_ref())
             }
         }
     }
@@ -95,14 +92,15 @@ impl<St: Stream> FusedStream for Peekable<St> {
 impl<S: Stream> Stream for Peekable<S> {
     type Item = S::Item;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        if let Some(item) = self.as_mut().peeked().take() {
+        if let Some(item) = self.peeked.take() {
             return Poll::Ready(Some(item))
         }
-        self.as_mut().stream().poll_next(cx)
+        self.stream.poll_next(cx)
     }
 }
 
diff --git a/futures-util/src/stream/skip.rs b/futures-util/src/stream/skip.rs
index 0c12f87b35..aa264b9e24 100644
--- a/futures-util/src/stream/skip.rs
+++ b/futures-util/src/stream/skip.rs
@@ -3,22 +3,19 @@ use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`skip`](super::StreamExt::skip) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "streams do nothing unless polled"]
 pub struct Skip<St> {
+    #[pin]
     stream: St,
     remaining: u64,
 }
 
-impl<St: Unpin> Unpin for Skip<St> {}
-
 impl<St: Stream> Skip<St> {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(remaining: u64);
-
     pub(super) fn new(stream: St, n: u64) -> Skip<St> {
         Skip {
             stream,
@@ -46,8 +43,9 @@ impl<St: Stream> Skip<St> {
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -68,18 +66,19 @@ impl<St: FusedStream> FusedStream for Skip<St> {
 impl<St: Stream> Stream for Skip<St> {
     type Item = St::Item;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<St::Item>> {
-        while self.remaining > 0 {
-            match ready!(self.as_mut().stream().poll_next(cx)) {
-                Some(_) => *self.as_mut().remaining() -= 1,
+        while *self.remaining > 0 {
+            match ready!(self.stream.as_mut().poll_next(cx)) {
+                Some(_) => *self.remaining -= 1,
                 None => return Poll::Ready(None),
             }
         }
 
-        self.as_mut().stream().poll_next(cx)
+        self.stream.poll_next(cx)
     }
 }
 
diff --git a/futures-util/src/stream/skip_while.rs b/futures-util/src/stream/skip_while.rs
index 5b125df1f0..a1ffaa4600 100644
--- a/futures-util/src/stream/skip_while.rs
+++ b/futures-util/src/stream/skip_while.rs
@@ -5,20 +5,21 @@ use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`skip_while`](super::StreamExt::skip_while) method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct SkipWhile<St, Fut, F> where St: Stream {
+    #[pin]
     stream: St,
     f: F,
+    #[pin]
     pending_fut: Option<Fut>,
     pending_item: Option<St::Item>,
     done_skipping: bool,
 }
 
-impl<St: Unpin + Stream, Fut: Unpin, F> Unpin for SkipWhile<St, Fut, F> {}
-
 impl<St, Fut, F> fmt::Debug for SkipWhile<St, Fut, F>
 where
     St: Stream + fmt::Debug,
@@ -40,12 +41,6 @@ impl<St, Fut, F> SkipWhile<St, Fut, F>
           F: FnMut(&St::Item) -> Fut,
           Fut: Future<Output = bool>,
 {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(f: F);
-    unsafe_pinned!(pending_fut: Option<Fut>);
-    unsafe_unpinned!(pending_item: Option<St::Item>);
-    unsafe_unpinned!(done_skipping: bool);
-
     pub(super) fn new(stream: St, f: F) -> SkipWhile<St, Fut, F> {
         SkipWhile {
             stream,
@@ -76,8 +71,9 @@ impl<St, Fut, F> SkipWhile<St, Fut, F>
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -102,31 +98,32 @@ impl<St, Fut, F> Stream for SkipWhile<St, Fut, F>
 {
     type Item = St::Item;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<St::Item>> {
-        if self.done_skipping {
-            return self.as_mut().stream().poll_next(cx);
+        if *self.done_skipping {
+            return self.stream.poll_next(cx);
         }
 
         loop {
             if self.pending_item.is_none() {
-                let item = match ready!(self.as_mut().stream().poll_next(cx)) {
+                let item = match ready!(self.stream.as_mut().poll_next(cx)) {
                     Some(e) => e,
                     None => return Poll::Ready(None),
                 };
-                let fut = (self.as_mut().f())(&item);
-                self.as_mut().pending_fut().set(Some(fut));
-                *self.as_mut().pending_item() = Some(item);
+                let fut = (self.f)(&item);
+                self.pending_fut.set(Some(fut));
+                *self.pending_item = Some(item);
             }
 
-            let skipped = ready!(self.as_mut().pending_fut().as_pin_mut().unwrap().poll(cx));
-            let item = self.as_mut().pending_item().take().unwrap();
-            self.as_mut().pending_fut().set(None);
+            let skipped = ready!(self.pending_fut.as_mut().as_pin_mut().unwrap().poll(cx));
+            let item = self.pending_item.take().unwrap();
+            self.pending_fut.set(None);
 
             if !skipped {
-                *self.as_mut().done_skipping() = true;
+                *self.done_skipping = true;
                 return Poll::Ready(Some(item))
             }
         }
diff --git a/futures-util/src/stream/take.rs b/futures-util/src/stream/take.rs
index a99975e77f..4a8b465f28 100644
--- a/futures-util/src/stream/take.rs
+++ b/futures-util/src/stream/take.rs
@@ -3,22 +3,19 @@ use futures_core::stream::Stream;
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`take`](super::StreamExt::take) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "streams do nothing unless polled"]
 pub struct Take<St> {
+    #[pin]
     stream: St,
     remaining: u64,
 }
 
-impl<St: Unpin> Unpin for Take<St> {}
-
 impl<St: Stream> Take<St> {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(remaining: u64);
-
     pub(super) fn new(stream: St, n: u64) -> Take<St> {
         Take {
             stream,
@@ -46,8 +43,9 @@ impl<St: Stream> Take<St> {
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -64,17 +62,18 @@ impl<St> Stream for Take<St>
 {
     type Item = St::Item;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<St::Item>> {
-        if self.remaining == 0 {
+        if *self.remaining == 0 {
             Poll::Ready(None)
         } else {
-            let next = ready!(self.as_mut().stream().poll_next(cx));
+            let next = ready!(self.stream.as_mut().poll_next(cx));
             match next {
-                Some(_) => *self.as_mut().remaining() -= 1,
-                None => *self.as_mut().remaining() = 0,
+                Some(_) => *self.remaining -= 1,
+                None => *self.remaining = 0,
             }
             Poll::Ready(next)
         }
diff --git a/futures-util/src/stream/take_while.rs b/futures-util/src/stream/take_while.rs
index ac1dbe4429..8767f62b9d 100644
--- a/futures-util/src/stream/take_while.rs
+++ b/futures-util/src/stream/take_while.rs
@@ -5,20 +5,21 @@ use futures_core::stream::Stream;
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`take_while`](super::StreamExt::take_while) method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct TakeWhile<St: Stream , Fut, F> {
+    #[pin]
     stream: St,
     f: F,
+    #[pin]
     pending_fut: Option<Fut>,
     pending_item: Option<St::Item>,
     done_taking: bool,
 }
 
-impl<St: Unpin + Stream, Fut: Unpin, F> Unpin for TakeWhile<St, Fut, F> {}
-
 impl<St, Fut, F> fmt::Debug for TakeWhile<St, Fut, F>
 where
     St: Stream + fmt::Debug,
@@ -35,14 +36,6 @@ where
     }
 }
 
-impl<St: Stream, Fut, F> TakeWhile<St, Fut, F> {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(f: F);
-    unsafe_pinned!(pending_fut: Option<Fut>);
-    unsafe_unpinned!(pending_item: Option<St::Item>);
-    unsafe_unpinned!(done_taking: bool);
-}
-
 impl<St, Fut, F> TakeWhile<St, Fut, F>
     where St: Stream,
           F: FnMut(&St::Item) -> Fut,
@@ -78,8 +71,9 @@ impl<St, Fut, F> TakeWhile<St, Fut, F>
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -98,32 +92,33 @@ impl<St, Fut, F> Stream for TakeWhile<St, Fut, F>
 {
     type Item = St::Item;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<St::Item>> {
-        if self.done_taking {
+        if *self.done_taking {
             return Poll::Ready(None);
         }
 
         if self.pending_item.is_none() {
-            let item = match ready!(self.as_mut().stream().poll_next(cx)) {
+            let item = match ready!(self.stream.as_mut().poll_next(cx)) {
                 Some(e) => e,
                 None => return Poll::Ready(None),
             };
-            let fut = (self.as_mut().f())(&item);
-            self.as_mut().pending_fut().set(Some(fut));
-            *self.as_mut().pending_item() = Some(item);
+            let fut = (self.f)(&item);
+            self.pending_fut.set(Some(fut));
+            *self.pending_item = Some(item);
         }
 
-        let take = ready!(self.as_mut().pending_fut().as_pin_mut().unwrap().poll(cx));
-        self.as_mut().pending_fut().set(None);
-        let item = self.as_mut().pending_item().take().unwrap();
+        let take = ready!(self.pending_fut.as_mut().as_pin_mut().unwrap().poll(cx));
+        self.pending_fut.set(None);
+        let item = self.pending_item.take().unwrap();
 
         if take {
             Poll::Ready(Some(item))
         } else {
-            *self.as_mut().done_taking() = true;
+            *self.done_taking = true;
             Poll::Ready(None)
         }
     }
diff --git a/futures-util/src/stream/then.rs b/futures-util/src/stream/then.rs
index 47a70e55f4..5d8ed79fd0 100644
--- a/futures-util/src/stream/then.rs
+++ b/futures-util/src/stream/then.rs
@@ -5,18 +5,19 @@ use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`then`](super::StreamExt::then) method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct Then<St, Fut, F> {
+    #[pin]
     stream: St,
+    #[pin]
     future: Option<Fut>,
     f: F,
 }
 
-impl<St: Unpin, Fut: Unpin, F> Unpin for Then<St, Fut, F> {}
-
 impl<St, Fut, F> fmt::Debug for Then<St, Fut, F>
 where
     St: fmt::Debug,
@@ -30,12 +31,6 @@ where
     }
 }
 
-impl<St, Fut, F> Then<St, Fut, F> {
-    unsafe_pinned!(stream: St);
-    unsafe_pinned!(future: Option<Fut>);
-    unsafe_unpinned!(f: F);
-}
-
 impl<St, Fut, F> Then<St, Fut, F>
     where St: Stream,
           F: FnMut(St::Item) -> Fut,
@@ -68,8 +63,9 @@ impl<St, Fut, F> Then<St, Fut, F>
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -94,21 +90,22 @@ impl<St, Fut, F> Stream for Then<St, Fut, F>
 {
     type Item = Fut::Output;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Fut::Output>> {
         if self.future.is_none() {
-            let item = match ready!(self.as_mut().stream().poll_next(cx)) {
+            let item = match ready!(self.stream.as_mut().poll_next(cx)) {
                 None => return Poll::Ready(None),
                 Some(e) => e,
             };
-            let fut = (self.as_mut().f())(item);
-            self.as_mut().future().set(Some(fut));
+            let fut = (self.f)(item);
+            self.future.set(Some(fut));
         }
 
-        let e = ready!(self.as_mut().future().as_pin_mut().unwrap().poll(cx));
-        self.as_mut().future().set(None);
+        let e = ready!(self.future.as_mut().as_pin_mut().unwrap().poll(cx));
+        self.future.set(None);
         Poll::Ready(Some(e))
     }
 }
diff --git a/futures-util/src/stream/unfold.rs b/futures-util/src/stream/unfold.rs
index d986011f5e..159de2ba4b 100644
--- a/futures-util/src/stream/unfold.rs
+++ b/futures-util/src/stream/unfold.rs
@@ -3,7 +3,7 @@ use core::pin::Pin;
 use futures_core::future::Future;
 use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Creates a `Stream` from a seed and a closure returning a `Future`.
 ///
@@ -62,15 +62,15 @@ pub fn unfold<T, F, Fut, It>(init: T, f: F) -> Unfold<T, F, Fut>
 }
 
 /// Stream for the [`unfold`] function.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct Unfold<T, F, Fut> {
     f: F,
     state: Option<T>,
+    #[pin]
     fut: Option<Fut>,
 }
 
-impl<T, F, Fut: Unpin> Unpin for Unfold<T, F, Fut> {}
-
 impl<T, F, Fut> fmt::Debug for Unfold<T, F, Fut>
 where
     T: fmt::Debug,
@@ -84,12 +84,6 @@ where
     }
 }
 
-impl<T, F, Fut> Unfold<T, F, Fut> {
-    unsafe_unpinned!(f: F);
-    unsafe_unpinned!(state: Option<T>);
-    unsafe_pinned!(fut: Option<Fut>);
-}
-
 impl<T, F, Fut> FusedStream for Unfold<T, F, Fut> {
     fn is_terminated(&self) -> bool {
         self.state.is_none() && self.fut.is_none()
@@ -102,20 +96,21 @@ impl<T, F, Fut, It> Stream for Unfold<T, F, Fut>
 {
     type Item = It;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<It>> {
-        if let Some(state) = self.as_mut().state().take() {
-            let fut = (self.as_mut().f())(state);
-            self.as_mut().fut().set(Some(fut));
+        if let Some(state) = self.state.take() {
+            let fut = (self.f)(state);
+            self.fut.set(Some(fut));
         }
 
-        let step = ready!(self.as_mut().fut().as_pin_mut().unwrap().poll(cx));
-        self.as_mut().fut().set(None);
+        let step = ready!(self.fut.as_mut().as_pin_mut().unwrap().poll(cx));
+        self.fut.set(None);
 
         if let Some((item, next_state)) = step {
-            *self.as_mut().state() = Some(next_state);
+            *self.state = Some(next_state);
             Poll::Ready(Some(item))
         } else {
             Poll::Ready(None)
diff --git a/futures-util/src/stream/zip.rs b/futures-util/src/stream/zip.rs
index e72fec00ce..38593ce980 100644
--- a/futures-util/src/stream/zip.rs
+++ b/futures-util/src/stream/zip.rs
@@ -2,32 +2,22 @@ use crate::stream::{StreamExt, Fuse};
 use core::pin::Pin;
 use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`zip`](super::StreamExt::zip) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "streams do nothing unless polled"]
 pub struct Zip<St1: Stream, St2: Stream> {
+    #[pin]
     stream1: Fuse<St1>,
+    #[pin]
     stream2: Fuse<St2>,
     queued1: Option<St1::Item>,
     queued2: Option<St2::Item>,
 }
 
-impl<St1, St2> Unpin for Zip<St1, St2>
-where
-    St1: Stream,
-    Fuse<St1>: Unpin,
-    St2: Stream,
-    Fuse<St2>: Unpin,
-{}
-
 impl<St1: Stream, St2: Stream> Zip<St1, St2> {
-    unsafe_pinned!(stream1: Fuse<St1>);
-    unsafe_pinned!(stream2: Fuse<St2>);
-    unsafe_unpinned!(queued1: Option<St1::Item>);
-    unsafe_unpinned!(queued2: Option<St2::Item>);
-
     pub(super) fn new(stream1: St1, stream2: St2) -> Zip<St1, St2> {
         Zip {
             stream1: stream1.fuse(),
@@ -86,26 +76,27 @@ impl<St1, St2> Stream for Zip<St1, St2>
 {
     type Item = (St1::Item, St2::Item);
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
         if self.queued1.is_none() {
-            match self.as_mut().stream1().poll_next(cx) {
-                Poll::Ready(Some(item1)) => *self.as_mut().queued1() = Some(item1),
+            match self.stream1.as_mut().poll_next(cx) {
+                Poll::Ready(Some(item1)) => *self.queued1 = Some(item1),
                 Poll::Ready(None) | Poll::Pending => {}
             }
         }
         if self.queued2.is_none() {
-            match self.as_mut().stream2().poll_next(cx) {
-                Poll::Ready(Some(item2)) => *self.as_mut().queued2() = Some(item2),
+            match self.stream2.as_mut().poll_next(cx) {
+                Poll::Ready(Some(item2)) => *self.queued2 = Some(item2),
                 Poll::Ready(None) | Poll::Pending => {}
             }
         }
 
         if self.queued1.is_some() && self.queued2.is_some() {
-            let pair = (self.as_mut().queued1().take().unwrap(),
-                        self.as_mut().queued2().take().unwrap());
+            let pair = (self.queued1.take().unwrap(),
+                        self.queued2.take().unwrap());
             Poll::Ready(Some(pair))
         } else if self.stream1.is_done() || self.stream2.is_done() {
             Poll::Ready(None)
diff --git a/futures-util/src/try_future/and_then.rs b/futures-util/src/try_future/and_then.rs
index 37333e0503..eb702e4c29 100644
--- a/futures-util/src/try_future/and_then.rs
+++ b/futures-util/src/try_future/and_then.rs
@@ -2,12 +2,14 @@ use super::{TryChain, TryChainAction};
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future, TryFuture};
 use futures_core::task::{Context, Poll};
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`and_then`](super::TryFutureExt::and_then) method.
+#[unsafe_project]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct AndThen<Fut1, Fut2, F> {
+    #[pin]
     try_chain: TryChain<Fut1, Fut2, F>,
 }
 
@@ -15,9 +17,6 @@ impl<Fut1, Fut2, F> AndThen<Fut1, Fut2, F>
     where Fut1: TryFuture,
           Fut2: TryFuture,
 {
-    unsafe_pinned!(try_chain: TryChain<Fut1, Fut2, F>);
-
-    /// Creates a new `Then`.
     pub(super) fn new(future: Fut1, f: F) -> AndThen<Fut1, Fut2, F> {
         AndThen {
             try_chain: TryChain::new(future, f),
@@ -42,8 +41,9 @@ impl<Fut1, Fut2, F> Future for AndThen<Fut1, Fut2, F>
 {
     type Output = Result<Fut2::Ok, Fut2::Error>;
 
+    #[pin_project(self)]
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        self.try_chain().poll(cx, |result, async_op| {
+        self.try_chain.poll(cx, |result, async_op| {
             match result {
                 Ok(ok) => TryChainAction::Future(async_op(ok)),
                 Err(err) => TryChainAction::Output(Err(err)),
diff --git a/futures-util/src/try_future/err_into.rs b/futures-util/src/try_future/err_into.rs
index 2f669fc54f..026fca86de 100644
--- a/futures-util/src/try_future/err_into.rs
+++ b/futures-util/src/try_future/err_into.rs
@@ -2,21 +2,19 @@ use core::marker::PhantomData;
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future, TryFuture};
 use futures_core::task::{Context, Poll};
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`err_into`](super::TryFutureExt::err_into) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct ErrInto<Fut, E> {
+    #[pin]
     future: Fut,
     _marker: PhantomData<E>,
 }
 
-impl<Fut: Unpin, E> Unpin for ErrInto<Fut, E> {}
-
 impl<Fut, E> ErrInto<Fut, E> {
-    unsafe_pinned!(future: Fut);
-
     pub(super) fn new(future: Fut) -> ErrInto<Fut, E> {
         ErrInto {
             future,
@@ -35,11 +33,12 @@ impl<Fut, E> Future for ErrInto<Fut, E>
 {
     type Output = Result<Fut::Ok, E>;
 
+    #[pin_project(self)]
     fn poll(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Self::Output> {
-        self.future().try_poll(cx)
+        self.future.try_poll(cx)
             .map(|res| res.map_err(Into::into))
     }
 }
diff --git a/futures-util/src/try_future/inspect_err.rs b/futures-util/src/try_future/inspect_err.rs
index 9580a11cc8..cf73214b0c 100644
--- a/futures-util/src/try_future/inspect_err.rs
+++ b/futures-util/src/try_future/inspect_err.rs
@@ -1,26 +1,23 @@
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future, TryFuture};
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`inspect_err`](super::TryFutureExt::inspect_err) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct InspectErr<Fut, F> {
+    #[pin]
     future: Fut,
     f: Option<F>,
 }
 
-impl<Fut: Unpin, F> Unpin for InspectErr<Fut, F> {}
-
 impl<Fut, F> InspectErr<Fut, F>
 where
     Fut: TryFuture,
     F: FnOnce(&Fut::Error),
 {
-    unsafe_pinned!(future: Fut);
-    unsafe_unpinned!(f: Option<F>);
-
     pub(super) fn new(future: Fut, f: F) -> Self {
         Self { future, f: Some(f) }
     }
@@ -39,10 +36,11 @@ where
 {
     type Output = Result<Fut::Ok, Fut::Error>;
 
+    #[pin_project(self)]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let e = ready!(self.as_mut().future().try_poll(cx));
+        let e = ready!(self.future.as_mut().try_poll(cx));
         if let Err(e) = &e {
-            self.as_mut().f().take().expect("cannot poll InspectErr twice")(e);
+            self.f.take().expect("cannot poll InspectErr twice")(e);
         }
         Poll::Ready(e)
     }
diff --git a/futures-util/src/try_future/inspect_ok.rs b/futures-util/src/try_future/inspect_ok.rs
index 0f11b32d1a..9e01cb22fc 100644
--- a/futures-util/src/try_future/inspect_ok.rs
+++ b/futures-util/src/try_future/inspect_ok.rs
@@ -1,26 +1,23 @@
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future, TryFuture};
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`inspect_ok`](super::TryFutureExt::inspect_ok) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct InspectOk<Fut, F> {
+    #[pin]
     future: Fut,
     f: Option<F>,
 }
 
-impl<Fut: Unpin, F> Unpin for InspectOk<Fut, F> {}
-
 impl<Fut, F> InspectOk<Fut, F>
 where
     Fut: TryFuture,
     F: FnOnce(&Fut::Ok),
 {
-    unsafe_pinned!(future: Fut);
-    unsafe_unpinned!(f: Option<F>);
-
     pub(super) fn new(future: Fut, f: F) -> Self {
         Self { future, f: Some(f) }
     }
@@ -39,10 +36,11 @@ where
 {
     type Output = Result<Fut::Ok, Fut::Error>;
 
+    #[pin_project(self)]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let e = ready!(self.as_mut().future().try_poll(cx));
+        let e = ready!(self.future.as_mut().try_poll(cx));
         if let Ok(e) = &e {
-            self.as_mut().f().take().expect("cannot poll InspectOk twice")(e);
+            self.f.take().expect("cannot poll InspectOk twice")(e);
         }
         Poll::Ready(e)
     }
diff --git a/futures-util/src/try_future/into_future.rs b/futures-util/src/try_future/into_future.rs
index 2e998206ed..7dd7aa86ad 100644
--- a/futures-util/src/try_future/into_future.rs
+++ b/futures-util/src/try_future/into_future.rs
@@ -1,18 +1,18 @@
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future, TryFuture};
 use futures_core::task::{Context, Poll};
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`into_future`](super::TryFutureExt::into_future) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct IntoFuture<Fut> {
+    #[pin]
     future: Fut,
 }
 
 impl<Fut> IntoFuture<Fut> {
-    unsafe_pinned!(future: Fut);
-
     #[inline]
     pub(super) fn new(future: Fut) -> IntoFuture<Fut> {
         IntoFuture { future }
@@ -26,11 +26,12 @@ impl<Fut: FusedFuture> FusedFuture for IntoFuture<Fut> {
 impl<Fut: TryFuture> Future for IntoFuture<Fut> {
     type Output = Result<Fut::Ok, Fut::Error>;
 
+    #[pin_project(self)]
     #[inline]
     fn poll(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Self::Output> {
-        self.future().try_poll(cx)
+        self.future.try_poll(cx)
     }
 }
diff --git a/futures-util/src/try_future/map_err.rs b/futures-util/src/try_future/map_err.rs
index 1095fbd352..f0d4dadcae 100644
--- a/futures-util/src/try_future/map_err.rs
+++ b/futures-util/src/try_future/map_err.rs
@@ -1,28 +1,24 @@
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future, TryFuture};
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`map_err`](super::TryFutureExt::map_err) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct MapErr<Fut, F> {
+    #[pin]
     future: Fut,
     f: Option<F>,
 }
 
 impl<Fut, F> MapErr<Fut, F> {
-    unsafe_pinned!(future: Fut);
-    unsafe_unpinned!(f: Option<F>);
-
-    /// Creates a new MapErr.
     pub(super) fn new(future: Fut, f: F) -> MapErr<Fut, F> {
         MapErr { future, f: Some(f) }
     }
 }
 
-impl<Fut: Unpin, F> Unpin for MapErr<Fut, F> {}
-
 impl<Fut, F> FusedFuture for MapErr<Fut, F> {
     fn is_terminated(&self) -> bool { self.f.is_none() }
 }
@@ -33,15 +29,16 @@ impl<Fut, F, E> Future for MapErr<Fut, F>
 {
     type Output = Result<Fut::Ok, E>;
 
+    #[pin_project(self)]
     fn poll(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Self::Output> {
-        self.as_mut()
-            .future()
+        self.future
+            .as_mut()
             .try_poll(cx)
             .map(|result| {
-                let f = self.as_mut().f().take()
+                let f = self.f.take()
                     .expect("MapErr must not be polled after it returned `Poll::Ready`");
                 result.map_err(f)
             })
diff --git a/futures-util/src/try_future/map_ok.rs b/futures-util/src/try_future/map_ok.rs
index 3debb726c0..050c70082b 100644
--- a/futures-util/src/try_future/map_ok.rs
+++ b/futures-util/src/try_future/map_ok.rs
@@ -1,28 +1,24 @@
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future, TryFuture};
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`map_ok`](super::TryFutureExt::map_ok) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct MapOk<Fut, F> {
+    #[pin]
     future: Fut,
     f: Option<F>,
 }
 
 impl<Fut, F> MapOk<Fut, F> {
-    unsafe_pinned!(future: Fut);
-    unsafe_unpinned!(f: Option<F>);
-
-    /// Creates a new MapOk.
     pub(super) fn new(future: Fut, f: F) -> MapOk<Fut, F> {
         MapOk { future, f: Some(f) }
     }
 }
 
-impl<Fut: Unpin, F> Unpin for MapOk<Fut, F> {}
-
 impl<Fut, F> FusedFuture for MapOk<Fut, F> {
     fn is_terminated(&self) -> bool {
         self.f.is_none()
@@ -35,15 +31,16 @@ impl<Fut, F, T> Future for MapOk<Fut, F>
 {
     type Output = Result<T, Fut::Error>;
 
+    #[pin_project(self)]
     fn poll(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Self::Output> {
-        self.as_mut()
-            .future()
+        self.future
+            .as_mut()
             .try_poll(cx)
             .map(|result| {
-                let op = self.as_mut().f().take()
+                let op = self.f.take()
                     .expect("MapOk must not be polled after it returned `Poll::Ready`");
                 result.map(op)
             })
diff --git a/futures-util/src/try_future/or_else.rs b/futures-util/src/try_future/or_else.rs
index a9c006fa9f..d07484b7cb 100644
--- a/futures-util/src/try_future/or_else.rs
+++ b/futures-util/src/try_future/or_else.rs
@@ -2,12 +2,14 @@ use super::{TryChain, TryChainAction};
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future, TryFuture};
 use futures_core::task::{Context, Poll};
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`or_else`](super::TryFutureExt::or_else) method.
+#[unsafe_project]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct OrElse<Fut1, Fut2, F> {
+    #[pin]
     try_chain: TryChain<Fut1, Fut2, F>,
 }
 
@@ -15,9 +17,6 @@ impl<Fut1, Fut2, F> OrElse<Fut1, Fut2, F>
     where Fut1: TryFuture,
           Fut2: TryFuture,
 {
-    unsafe_pinned!(try_chain: TryChain<Fut1, Fut2, F>);
-
-    /// Creates a new `Then`.
     pub(super) fn new(future: Fut1, f: F) -> OrElse<Fut1, Fut2, F> {
         OrElse {
             try_chain: TryChain::new(future, f),
@@ -42,11 +41,12 @@ impl<Fut1, Fut2, F> Future for OrElse<Fut1, Fut2, F>
 {
     type Output = Result<Fut2::Ok, Fut2::Error>;
 
+    #[pin_project(self)]
     fn poll(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Self::Output> {
-        self.try_chain().poll(cx, |result, async_op| {
+        self.try_chain.poll(cx, |result, async_op| {
             match result {
                 Ok(ok) => TryChainAction::Output(Ok(ok)),
                 Err(err) => TryChainAction::Future(async_op(err)),
diff --git a/futures-util/src/try_future/unwrap_or_else.rs b/futures-util/src/try_future/unwrap_or_else.rs
index d0b80eb872..46e5de58f9 100644
--- a/futures-util/src/try_future/unwrap_or_else.rs
+++ b/futures-util/src/try_future/unwrap_or_else.rs
@@ -1,29 +1,25 @@
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future, TryFuture};
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`unwrap_or_else`](super::TryFutureExt::unwrap_or_else)
 /// method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct UnwrapOrElse<Fut, F> {
+    #[pin]
     future: Fut,
     f: Option<F>,
 }
 
 impl<Fut, F> UnwrapOrElse<Fut, F> {
-    unsafe_pinned!(future: Fut);
-    unsafe_unpinned!(f: Option<F>);
-
-    /// Creates a new UnwrapOrElse.
     pub(super) fn new(future: Fut, f: F) -> UnwrapOrElse<Fut, F> {
         UnwrapOrElse { future, f: Some(f) }
     }
 }
 
-impl<Fut: Unpin, F> Unpin for UnwrapOrElse<Fut, F> {}
-
 impl<Fut, F> FusedFuture for UnwrapOrElse<Fut, F> {
     fn is_terminated(&self) -> bool {
         self.f.is_none()
@@ -36,15 +32,16 @@ impl<Fut, F> Future for UnwrapOrElse<Fut, F>
 {
     type Output = Fut::Ok;
 
+    #[pin_project(self)]
     fn poll(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Self::Output> {
-        self.as_mut()
-            .future()
+        self.future
+            .as_mut()
             .try_poll(cx)
             .map(|result| {
-                let op = self.as_mut().f().take()
+                let op = self.f.take()
                     .expect("UnwrapOrElse already returned `Poll::Ready` before");
                 result.unwrap_or_else(op)
             })
diff --git a/futures-util/src/try_stream/and_then.rs b/futures-util/src/try_stream/and_then.rs
index e991d3b8a8..7ff6222da8 100644
--- a/futures-util/src/try_stream/and_then.rs
+++ b/futures-util/src/try_stream/and_then.rs
@@ -5,18 +5,19 @@ use futures_core::stream::{Stream, TryStream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`and_then`](super::TryStreamExt::and_then) method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct AndThen<St, Fut, F> {
+    #[pin]
     stream: St,
+    #[pin]
     future: Option<Fut>,
     f: F,
 }
 
-impl<St: Unpin, Fut: Unpin, F> Unpin for AndThen<St, Fut, F> {}
-
 impl<St, Fut, F> fmt::Debug for AndThen<St, Fut, F>
 where
     St: fmt::Debug,
@@ -65,8 +66,9 @@ impl<St, Fut, F> AndThen<St, Fut, F>
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -85,21 +87,22 @@ impl<St, Fut, F> Stream for AndThen<St, Fut, F>
 {
     type Item = Result<Fut::Ok, St::Error>;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
         if self.future.is_none() {
-            let item = match ready!(self.as_mut().stream().try_poll_next(cx)?) {
+            let item = match ready!(self.stream.as_mut().try_poll_next(cx)?) {
                 None => return Poll::Ready(None),
                 Some(e) => e,
             };
-            let fut = (self.as_mut().f())(item);
-            self.as_mut().future().set(Some(fut));
+            let fut = (self.f)(item);
+            self.future.set(Some(fut));
         }
 
-        let e = ready!(self.as_mut().future().as_pin_mut().unwrap().try_poll(cx));
-        self.as_mut().future().set(None);
+        let e = ready!(self.future.as_mut().as_pin_mut().unwrap().try_poll(cx));
+        self.future.set(None);
         Poll::Ready(Some(e))
     }
 }
diff --git a/futures-util/src/try_stream/err_into.rs b/futures-util/src/try_stream/err_into.rs
index 99c1c178f1..019618fc66 100644
--- a/futures-util/src/try_stream/err_into.rs
+++ b/futures-util/src/try_stream/err_into.rs
@@ -4,21 +4,19 @@ use futures_core::stream::{FusedStream, Stream, TryStream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`err_into`](super::TryStreamExt::err_into) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "streams do nothing unless polled"]
 pub struct ErrInto<St, E> {
+    #[pin]
     stream: St,
     _marker: PhantomData<E>,
 }
 
-impl<St: Unpin, E> Unpin for ErrInto<St, E> {}
-
 impl<St, E> ErrInto<St, E> {
-    unsafe_pinned!(stream: St);
-
     pub(super) fn new(stream: St) -> Self {
         ErrInto { stream, _marker: PhantomData }
     }
@@ -43,8 +41,9 @@ impl<St, E> ErrInto<St, E> {
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -69,11 +68,13 @@ where
 {
     type Item = Result<St::Ok, E>;
 
+    #[pin_project(self)]
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        self.stream().try_poll_next(cx)
+        self.stream
+            .try_poll_next(cx)
             .map(|res| res.map(|some| some.map_err(Into::into)))
     }
 }
diff --git a/futures-util/src/try_stream/inspect_err.rs b/futures-util/src/try_stream/inspect_err.rs
index 1eb53b11b9..4c04cbadc9 100644
--- a/futures-util/src/try_stream/inspect_err.rs
+++ b/futures-util/src/try_stream/inspect_err.rs
@@ -5,17 +5,17 @@ use futures_core::stream::{FusedStream, Stream, TryStream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`inspect_err`](super::TryStreamExt::inspect_err) method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct InspectErr<St, F> {
+    #[pin]
     stream: St,
     f: F,
 }
 
-impl<St: Unpin, F> Unpin for InspectErr<St, F> {}
-
 impl<St, F> fmt::Debug for InspectErr<St, F>
 where
     St: fmt::Debug,
@@ -61,8 +61,9 @@ where
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -87,14 +88,15 @@ where
 {
     type Item = Result<St::Ok, St::Error>;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        self.as_mut()
-            .stream()
+        self.stream
+            .as_mut()
             .try_poll_next(cx)
-            .map(|opt| opt.map(|res| res.map_err(|e| inspect(e, self.as_mut().f()))))
+            .map(|opt| opt.map(|res| res.map_err(|e| inspect(e, self.f))))
     }
 }
 
diff --git a/futures-util/src/try_stream/inspect_ok.rs b/futures-util/src/try_stream/inspect_ok.rs
index 262b18ebc1..26124708bd 100644
--- a/futures-util/src/try_stream/inspect_ok.rs
+++ b/futures-util/src/try_stream/inspect_ok.rs
@@ -5,17 +5,17 @@ use futures_core::stream::{FusedStream, Stream, TryStream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`inspect_ok`](super::TryStreamExt::inspect_ok) method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct InspectOk<St, F> {
+    #[pin]
     stream: St,
     f: F,
 }
 
-impl<St: Unpin, F> Unpin for InspectOk<St, F> {}
-
 impl<St, F> fmt::Debug for InspectOk<St, F>
 where
     St: fmt::Debug,
@@ -61,8 +61,9 @@ where
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -87,14 +88,15 @@ where
 {
     type Item = Result<St::Ok, St::Error>;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        self.as_mut()
-            .stream()
+        self.stream
+            .as_mut()
             .try_poll_next(cx)
-            .map(|opt| opt.map(|res| res.map(|e| inspect(e, self.as_mut().f()))))
+            .map(|opt| opt.map(|res| res.map(|e| inspect(e, self.f))))
     }
 }
 
diff --git a/futures-util/src/try_stream/into_stream.rs b/futures-util/src/try_stream/into_stream.rs
index 31d95b3d80..0b34285bd3 100644
--- a/futures-util/src/try_stream/into_stream.rs
+++ b/futures-util/src/try_stream/into_stream.rs
@@ -3,18 +3,18 @@ use futures_core::stream::{FusedStream, Stream, TryStream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::unsafe_pinned;
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`into_stream`](super::TryStreamExt::into_stream) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "streams do nothing unless polled"]
 pub struct IntoStream<St> {
+    #[pin]
     stream: St,
 }
 
 impl<St> IntoStream<St> {
-    unsafe_pinned!(stream: St);
-
     #[inline]
     pub(super) fn new(stream: St) -> Self {
         IntoStream { stream }
@@ -40,8 +40,9 @@ impl<St> IntoStream<St> {
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -62,12 +63,13 @@ impl<St: FusedStream> FusedStream for IntoStream<St> {
 impl<St: TryStream> Stream for IntoStream<St> {
     type Item = Result<St::Ok, St::Error>;
 
+    #[pin_project(self)]
     #[inline]
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        self.stream().try_poll_next(cx)
+        self.stream.try_poll_next(cx)
     }
 }
 
diff --git a/futures-util/src/try_stream/map_err.rs b/futures-util/src/try_stream/map_err.rs
index 4ca5cb58d0..61c62fc3c1 100644
--- a/futures-util/src/try_stream/map_err.rs
+++ b/futures-util/src/try_stream/map_err.rs
@@ -4,17 +4,17 @@ use futures_core::stream::{FusedStream, Stream, TryStream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`map_err`](super::TryStreamExt::map_err) method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct MapErr<St, F> {
+    #[pin]
     stream: St,
     f: F,
 }
 
-impl<St: Unpin, F> Unpin for MapErr<St, F> {}
-
 impl<St, F> fmt::Debug for MapErr<St, F>
 where
     St: fmt::Debug,
@@ -27,9 +27,6 @@ where
 }
 
 impl<St, F> MapErr<St, F> {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(f: F);
-
     /// Creates a new MapErr.
     pub(super) fn new(stream: St, f: F) -> Self {
         MapErr { stream, f }
@@ -55,8 +52,9 @@ impl<St, F> MapErr<St, F> {
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -81,14 +79,15 @@ where
 {
     type Item = Result<St::Ok, E>;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        self.as_mut()
-            .stream()
+        self.stream
+            .as_mut()
             .try_poll_next(cx)
-            .map(|opt| opt.map(|res| res.map_err(|e| self.as_mut().f()(e))))
+            .map(|opt| opt.map(|res| res.map_err(|e| (self.f)(e))))
     }
 }
 
diff --git a/futures-util/src/try_stream/map_ok.rs b/futures-util/src/try_stream/map_ok.rs
index de64b7dc34..6889d775df 100644
--- a/futures-util/src/try_stream/map_ok.rs
+++ b/futures-util/src/try_stream/map_ok.rs
@@ -4,17 +4,17 @@ use futures_core::stream::{FusedStream, Stream, TryStream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`map_ok`](super::TryStreamExt::map_ok) method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct MapOk<St, F> {
+    #[pin]
     stream: St,
     f: F,
 }
 
-impl<St: Unpin, F> Unpin for MapOk<St, F> {}
-
 impl<St, F> fmt::Debug for MapOk<St, F>
 where
     St: fmt::Debug,
@@ -27,9 +27,6 @@ where
 }
 
 impl<St, F> MapOk<St, F> {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(f: F);
-
     /// Creates a new MapOk.
     pub(super) fn new(stream: St, f: F) -> Self {
         MapOk { stream, f }
@@ -55,8 +52,9 @@ impl<St, F> MapOk<St, F> {
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -81,14 +79,15 @@ where
 {
     type Item = Result<T, St::Error>;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        self.as_mut()
-            .stream()
+        self.stream
+            .as_mut()
             .try_poll_next(cx)
-            .map(|opt| opt.map(|res| res.map(|x| self.as_mut().f()(x))))
+            .map(|opt| opt.map(|res| res.map(|x| (self.f)(x))))
     }
 }
 
diff --git a/futures-util/src/try_stream/or_else.rs b/futures-util/src/try_stream/or_else.rs
index 31937c2486..4ec0408aea 100644
--- a/futures-util/src/try_stream/or_else.rs
+++ b/futures-util/src/try_stream/or_else.rs
@@ -5,18 +5,19 @@ use futures_core::stream::{Stream, TryStream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`or_else`](super::TryStreamExt::or_else) method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct OrElse<St, Fut, F> {
+    #[pin]
     stream: St,
+    #[pin]
     future: Option<Fut>,
     f: F,
 }
 
-impl<St: Unpin, Fut: Unpin, F> Unpin for OrElse<St, Fut, F> {}
-
 impl<St, Fut, F> fmt::Debug for OrElse<St, Fut, F>
 where
     St: fmt::Debug,
@@ -65,8 +66,9 @@ impl<St, Fut, F> OrElse<St, Fut, F>
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -85,22 +87,23 @@ impl<St, Fut, F> Stream for OrElse<St, Fut, F>
 {
     type Item = Result<St::Ok, Fut::Error>;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        if self.future.is_none() {
-            let item = match ready!(self.as_mut().stream().try_poll_next(cx)) {
+       if self.future.is_none() {
+            let item = match ready!(self.stream.as_mut().try_poll_next(cx)) {
                 None => return Poll::Ready(None),
                 Some(Ok(e)) => return Poll::Ready(Some(Ok(e))),
                 Some(Err(e)) => e,
             };
-            let fut = (self.as_mut().f())(item);
-            self.as_mut().future().set(Some(fut));
+            let fut = (self.f)(item);
+            self.future.set(Some(fut));
         }
 
-        let e = ready!(self.as_mut().future().as_pin_mut().unwrap().try_poll(cx));
-        self.as_mut().future().set(None);
+        let e = ready!(self.future.as_mut().as_pin_mut().unwrap().try_poll(cx));
+        self.future.set(None);
         Poll::Ready(Some(e))
     }
 }
diff --git a/futures-util/src/try_stream/try_buffer_unordered.rs b/futures-util/src/try_stream/try_buffer_unordered.rs
index f2ef185d42..85da405f96 100644
--- a/futures-util/src/try_stream/try_buffer_unordered.rs
+++ b/futures-util/src/try_stream/try_buffer_unordered.rs
@@ -6,32 +6,27 @@ use futures_core::stream::{Stream, TryStream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
 use core::pin::Pin;
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the
 /// [`try_buffer_unordered`](super::TryStreamExt::try_buffer_unordered) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "streams do nothing unless polled"]
 pub struct TryBufferUnordered<St>
     where St: TryStream
 {
+    #[pin]
     stream: Fuse<IntoStream<St>>,
     in_progress_queue: FuturesUnordered<IntoFuture<St::Ok>>,
     max: usize,
 }
 
-impl<St> Unpin for TryBufferUnordered<St>
-    where St: TryStream + Unpin
-{}
-
 impl<St> TryBufferUnordered<St>
     where St: TryStream,
           St::Ok: TryFuture,
 {
-    unsafe_pinned!(stream: Fuse<IntoStream<St>>);
-    unsafe_unpinned!(in_progress_queue: FuturesUnordered<IntoFuture<St::Ok>>);
-
     pub(super) fn new(stream: St, n: usize) -> Self {
         TryBufferUnordered {
             stream: IntoStream::new(stream).fuse(),
@@ -60,8 +55,9 @@ impl<St> TryBufferUnordered<St>
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream().get_pin_mut().get_pin_mut()
+        self.stream.get_pin_mut().get_pin_mut()
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -79,21 +75,22 @@ impl<St> Stream for TryBufferUnordered<St>
 {
     type Item = Result<<St::Ok as TryFuture>::Ok, St::Error>;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
         // First up, try to spawn off as many futures as possible by filling up
         // our queue of futures. Propagate errors from the stream immediately.
-        while self.in_progress_queue.len() < self.max {
-            match self.as_mut().stream().poll_next(cx)? {
-                Poll::Ready(Some(fut)) => self.as_mut().in_progress_queue().push(fut.into_future()),
+        while self.in_progress_queue.len() < *self.max {
+            match self.stream.as_mut().poll_next(cx)? {
+                Poll::Ready(Some(fut)) => self.in_progress_queue.push(fut.into_future()),
                 Poll::Ready(None) | Poll::Pending => break,
             }
         }
 
         // Attempt to pull the next value from the in_progress_queue
-        match self.as_mut().in_progress_queue().poll_next_unpin(cx) {
+        match self.in_progress_queue.poll_next_unpin(cx) {
             x @ Poll::Pending | x @ Poll::Ready(Some(_)) => return x,
             Poll::Ready(None) => {}
         }
diff --git a/futures-util/src/try_stream/try_collect.rs b/futures-util/src/try_stream/try_collect.rs
index 9d6d04b576..31398a6729 100644
--- a/futures-util/src/try_stream/try_collect.rs
+++ b/futures-util/src/try_stream/try_collect.rs
@@ -3,34 +3,27 @@ use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future};
 use futures_core::stream::{FusedStream, TryStream};
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`try_collect`](super::TryStreamExt::try_collect) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct TryCollect<St, C> {
+    #[pin]
     stream: St,
     items: C,
 }
 
 impl<St: TryStream, C: Default> TryCollect<St, C> {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(items: C);
-
     pub(super) fn new(s: St) -> TryCollect<St, C> {
         TryCollect {
             stream: s,
             items: Default::default(),
         }
     }
-
-    fn finish(self: Pin<&mut Self>) -> C {
-        mem::replace(self.items(), Default::default())
-    }
 }
 
-impl<St: Unpin + TryStream, C> Unpin for TryCollect<St, C> {}
-
 impl<St: FusedStream, C> FusedFuture for TryCollect<St, C> {
     fn is_terminated(&self) -> bool {
         self.stream.is_terminated()
@@ -42,14 +35,15 @@ impl<St, C> Future for TryCollect<St, C>
 {
     type Output = Result<C, St::Error>;
 
+    #[pin_project(self)]
     fn poll(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Self::Output> {
         loop {
-            match ready!(self.as_mut().stream().try_poll_next(cx)?) {
-                Some(x) => self.as_mut().items().extend(Some(x)),
-                None => return Poll::Ready(Ok(self.as_mut().finish())),
+            match ready!(self.stream.as_mut().try_poll_next(cx)?) {
+                Some(x) => self.items.extend(Some(x)),
+                None => return Poll::Ready(Ok(mem::replace(self.items, Default::default()))),
             }
         }
     }
diff --git a/futures-util/src/try_stream/try_concat.rs b/futures-util/src/try_stream/try_concat.rs
index 395f166c6b..77c586f3a9 100644
--- a/futures-util/src/try_stream/try_concat.rs
+++ b/futures-util/src/try_stream/try_concat.rs
@@ -2,26 +2,23 @@ use core::pin::Pin;
 use futures_core::future::Future;
 use futures_core::stream::TryStream;
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`try_concat`](super::TryStreamExt::try_concat) method.
+#[unsafe_project(Unpin)]
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct TryConcat<St: TryStream> {
+    #[pin]
     stream: St,
     accum: Option<St::Ok>,
 }
 
-impl<St: TryStream + Unpin> Unpin for TryConcat<St> {}
-
 impl<St> TryConcat<St>
 where
     St: TryStream,
     St::Ok: Extend<<St::Ok as IntoIterator>::Item> + IntoIterator + Default,
 {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(accum: Option<St::Ok>);
-
     pub(super) fn new(stream: St) -> TryConcat<St> {
         TryConcat {
             stream,
@@ -37,19 +34,19 @@ where
 {
     type Output = Result<St::Ok, St::Error>;
 
+    #[pin_project(self)]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         loop {
-            match ready!(self.as_mut().stream().try_poll_next(cx)?) {
+            match ready!(self.stream.as_mut().try_poll_next(cx)?) {
                 Some(x) => {
-                    let accum = self.as_mut().accum();
-                    if let Some(a) = accum {
+                    if let Some(a) = self.accum {
                         a.extend(x)
                     } else {
-                        *accum = Some(x)
+                        *self.accum = Some(x)
                     }
                 },
                 None => {
-                    return Poll::Ready(Ok(self.as_mut().accum().take().unwrap_or_default()))
+                    return Poll::Ready(Ok(self.accum.take().unwrap_or_default()))
                 }
             }
         }
diff --git a/futures-util/src/try_stream/try_filter.rs b/futures-util/src/try_stream/try_filter.rs
index 7ab4891af7..1cb07e022f 100644
--- a/futures-util/src/try_stream/try_filter.rs
+++ b/futures-util/src/try_stream/try_filter.rs
@@ -5,24 +5,23 @@ use futures_core::stream::{Stream, TryStream, FusedStream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`try_filter`](super::TryStreamExt::try_filter)
 /// method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct TryFilter<St, Fut, F>
     where St: TryStream
 {
+    #[pin]
     stream: St,
     f: F,
+    #[pin]
     pending_fut: Option<Fut>,
     pending_item: Option<St::Ok>,
 }
 
-impl<St, Fut, F> Unpin for TryFilter<St, Fut, F>
-    where St: TryStream + Unpin, Fut: Unpin,
-{}
-
 impl<St, Fut, F> fmt::Debug for TryFilter<St, Fut, F>
 where
     St: TryStream + fmt::Debug,
@@ -41,11 +40,6 @@ where
 impl<St, Fut, F> TryFilter<St, Fut, F>
     where St: TryStream
 {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(f: F);
-    unsafe_pinned!(pending_fut: Option<Fut>);
-    unsafe_unpinned!(pending_item: Option<St::Ok>);
-
     pub(super) fn new(stream: St, f: F) -> Self {
         TryFilter {
             stream,
@@ -75,8 +69,9 @@ impl<St, Fut, F> TryFilter<St, Fut, F>
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -105,24 +100,25 @@ impl<St, Fut, F> Stream for TryFilter<St, Fut, F>
 {
     type Item = Result<St::Ok, St::Error>;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Result<St::Ok, St::Error>>> {
         loop {
             if self.pending_fut.is_none() {
-                let item = match ready!(self.as_mut().stream().try_poll_next(cx)?) {
+                let item = match ready!(self.stream.as_mut().try_poll_next(cx)?) {
                     Some(x) => x,
                     None => return Poll::Ready(None),
                 };
-                let fut = (self.as_mut().f())(&item);
-                self.as_mut().pending_fut().set(Some(fut));
-                *self.as_mut().pending_item() = Some(item);
+                let fut = (self.f)(&item);
+                self.pending_fut.set(Some(fut));
+                *self.pending_item = Some(item);
             }
 
-            let yield_item = ready!(self.as_mut().pending_fut().as_pin_mut().unwrap().poll(cx));
-            self.as_mut().pending_fut().set(None);
-            let item = self.as_mut().pending_item().take().unwrap();
+            let yield_item = ready!(self.pending_fut.as_mut().as_pin_mut().unwrap().poll(cx));
+            self.pending_fut.set(None);
+            let item = self.pending_item.take().unwrap();
 
             if yield_item {
                 return Poll::Ready(Some(Ok(item)));
diff --git a/futures-util/src/try_stream/try_filter_map.rs b/futures-util/src/try_stream/try_filter_map.rs
index ab64d282ed..b395cbfb4a 100644
--- a/futures-util/src/try_stream/try_filter_map.rs
+++ b/futures-util/src/try_stream/try_filter_map.rs
@@ -5,21 +5,20 @@ use futures_core::stream::{Stream, TryStream, FusedStream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`try_filter_map`](super::TryStreamExt::try_filter_map)
 /// method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct TryFilterMap<St, Fut, F> {
+    #[pin]
     stream: St,
     f: F,
+    #[pin]
     pending: Option<Fut>,
 }
 
-impl<St, Fut, F> Unpin for TryFilterMap<St, Fut, F>
-    where St: Unpin, Fut: Unpin,
-{}
-
 impl<St, Fut, F> fmt::Debug for TryFilterMap<St, Fut, F>
 where
     St: fmt::Debug,
@@ -34,10 +33,6 @@ where
 }
 
 impl<St, Fut, F> TryFilterMap<St, Fut, F> {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(f: F);
-    unsafe_pinned!(pending: Option<Fut>);
-
     pub(super) fn new(stream: St, f: F) -> Self {
         TryFilterMap { stream, f, pending: None }
     }
@@ -62,8 +57,9 @@ impl<St, Fut, F> TryFilterMap<St, Fut, F> {
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -92,22 +88,23 @@ impl<St, Fut, F, T> Stream for TryFilterMap<St, Fut, F>
 {
     type Item = Result<T, St::Error>;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Result<T, St::Error>>> {
         loop {
             if self.pending.is_none() {
-                let item = match ready!(self.as_mut().stream().try_poll_next(cx)?) {
+                let item = match ready!(self.stream.as_mut().try_poll_next(cx)?) {
                     Some(x) => x,
                     None => return Poll::Ready(None),
                 };
-                let fut = (self.as_mut().f())(item);
-                self.as_mut().pending().set(Some(fut));
+                let fut = (self.f)(item);
+                self.pending.set(Some(fut));
             }
 
-            let result = ready!(self.as_mut().pending().as_pin_mut().unwrap().try_poll(cx));
-            self.as_mut().pending().set(None);
+            let result = ready!(self.pending.as_mut().as_pin_mut().unwrap().try_poll(cx));
+            self.pending.set(None);
             if let Some(x) = result? {
                 return Poll::Ready(Some(Ok(x)));
             }
diff --git a/futures-util/src/try_stream/try_fold.rs b/futures-util/src/try_stream/try_fold.rs
index 73aa26b602..4909a0ea71 100644
--- a/futures-util/src/try_stream/try_fold.rs
+++ b/futures-util/src/try_stream/try_fold.rs
@@ -3,19 +3,20 @@ use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future, TryFuture};
 use futures_core::stream::TryStream;
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`try_fold`](super::TryStreamExt::try_fold) method.
+#[unsafe_project(Unpin)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct TryFold<St, Fut, T, F> {
+    #[pin]
     stream: St,
     f: F,
     accum: Option<T>,
+    #[pin]
     future: Option<Fut>,
 }
 
-impl<St: Unpin, Fut: Unpin, T, F> Unpin for TryFold<St, Fut, T, F> {}
-
 impl<St, Fut, T, F> fmt::Debug for TryFold<St, Fut, T, F>
 where
     St: fmt::Debug,
@@ -36,11 +37,6 @@ where St: TryStream,
       F: FnMut(T, St::Ok) -> Fut,
       Fut: TryFuture<Ok = T, Error = St::Error>,
 {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(f: F);
-    unsafe_unpinned!(accum: Option<T>);
-    unsafe_pinned!(future: Option<Fut>);
-
     pub(super) fn new(stream: St, f: F, t: T) -> TryFold<St, Fut, T, F> {
         TryFold {
             stream,
@@ -64,40 +60,41 @@ impl<St, Fut, T, F> Future for TryFold<St, Fut, T, F>
 {
     type Output = Result<T, St::Error>;
 
+    #[pin_project(self)]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         loop {
             // we're currently processing a future to produce a new accum value
             if self.accum.is_none() {
                 let accum = match ready!(
-                    self.as_mut().future().as_pin_mut()
+                    self.future.as_mut().as_pin_mut()
                        .expect("TryFold polled after completion")
                        .try_poll(cx)
                 ) {
                     Ok(accum) => accum,
                     Err(e) => {
                         // Indicate that the future can no longer be polled.
-                        self.as_mut().future().set(None);
+                        self.future.set(None);
                         return Poll::Ready(Err(e));
                     }
                 };
-                *self.as_mut().accum() = Some(accum);
-                self.as_mut().future().set(None);
+                *self.accum = Some(accum);
+                self.future.set(None);
             }
 
-            let item = match ready!(self.as_mut().stream().try_poll_next(cx)) {
+            let item = match ready!(self.stream.as_mut().try_poll_next(cx)) {
                 Some(Ok(item)) => Some(item),
                 Some(Err(e)) => {
                     // Indicate that the future can no longer be polled.
-                    *self.as_mut().accum() = None;
+                    *self.accum = None;
                     return Poll::Ready(Err(e));
                 }
                 None => None,
             };
-            let accum = self.as_mut().accum().take().unwrap();
+            let accum = self.accum.take().unwrap();
 
             if let Some(e) = item {
-                let future = (self.as_mut().f())(accum, e);
-                self.as_mut().future().set(Some(future));
+                let future = (self.f)(accum, e);
+                self.future.set(Some(future));
             } else {
                 return Poll::Ready(Ok(accum))
             }
diff --git a/futures-util/src/try_stream/try_for_each.rs b/futures-util/src/try_stream/try_for_each.rs
index 2c71107646..27561e8243 100644
--- a/futures-util/src/try_stream/try_for_each.rs
+++ b/futures-util/src/try_stream/try_for_each.rs
@@ -3,18 +3,19 @@ use core::pin::Pin;
 use futures_core::future::{Future, TryFuture};
 use futures_core::stream::TryStream;
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the [`try_for_each`](super::TryStreamExt::try_for_each) method.
+#[unsafe_project(Unpin)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct TryForEach<St, Fut, F> {
+    #[pin]
     stream: St,
     f: F,
+    #[pin]
     future: Option<Fut>,
 }
 
-impl<St: Unpin, Fut: Unpin, F> Unpin for TryForEach<St, Fut, F> {}
-
 impl<St, Fut, F> fmt::Debug for TryForEach<St, Fut, F>
 where
     St: fmt::Debug,
@@ -33,10 +34,6 @@ where St: TryStream,
       F: FnMut(St::Ok) -> Fut,
       Fut: TryFuture<Ok = (), Error = St::Error>,
 {
-    unsafe_pinned!(stream: St);
-    unsafe_unpinned!(f: F);
-    unsafe_pinned!(future: Option<Fut>);
-
     pub(super) fn new(stream: St, f: F) -> TryForEach<St, Fut, F> {
         TryForEach {
             stream,
@@ -53,17 +50,18 @@ impl<St, Fut, F> Future for TryForEach<St, Fut, F>
 {
     type Output = Result<(), St::Error>;
 
+    #[pin_project(self)]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         loop {
-            if let Some(future) = self.as_mut().future().as_pin_mut() {
+            if let Some(future) = self.future.as_mut().as_pin_mut() {
                 ready!(future.try_poll(cx))?;
             }
-            self.as_mut().future().set(None);
+            self.future.set(None);
 
-            match ready!(self.as_mut().stream().try_poll_next(cx)?) {
+            match ready!(self.stream.as_mut().try_poll_next(cx)?) {
                 Some(e) => {
-                    let future = (self.as_mut().f())(e);
-                    self.as_mut().future().set(Some(future));
+                    let future = (self.f)(e);
+                    self.future.set(Some(future));
                 }
                 None => return Poll::Ready(Ok(())),
             }
diff --git a/futures-util/src/try_stream/try_for_each_concurrent.rs b/futures-util/src/try_stream/try_for_each_concurrent.rs
index ab1b8adbd3..ae94eb5d9c 100644
--- a/futures-util/src/try_stream/try_for_each_concurrent.rs
+++ b/futures-util/src/try_stream/try_for_each_concurrent.rs
@@ -6,24 +6,21 @@ use core::num::NonZeroUsize;
 use futures_core::future::{FusedFuture, Future};
 use futures_core::stream::TryStream;
 use futures_core::task::{Context, Poll};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Future for the
 /// [`try_for_each_concurrent`](super::TryStreamExt::try_for_each_concurrent)
 /// method.
+#[unsafe_project(Unpin)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct TryForEachConcurrent<St, Fut, F> {
+    #[pin]
     stream: Option<St>,
     f: F,
     futures: FuturesUnordered<Fut>,
     limit: Option<NonZeroUsize>,
 }
 
-impl<St, Fut, F> Unpin for TryForEachConcurrent<St, Fut, F>
-where St: Unpin,
-      Fut: Unpin,
-{}
-
 impl<St, Fut, F> fmt::Debug for TryForEachConcurrent<St, Fut, F>
 where
     St: fmt::Debug,
@@ -49,11 +46,6 @@ where St: TryStream,
       F: FnMut(St::Ok) -> Fut,
       Fut: Future<Output = Result<(), St::Error>>,
 {
-    unsafe_pinned!(stream: Option<St>);
-    unsafe_unpinned!(f: F);
-    unsafe_unpinned!(futures: FuturesUnordered<Fut>);
-    unsafe_unpinned!(limit: Option<NonZeroUsize>);
-
     pub(super) fn new(stream: St, limit: Option<usize>, f: F) -> TryForEachConcurrent<St, Fut, F> {
         TryForEachConcurrent {
             stream: Some(stream),
@@ -72,6 +64,7 @@ impl<St, Fut, F> Future for TryForEachConcurrent<St, Fut, F>
 {
     type Output = Result<(), St::Error>;
 
+    #[pin_project(self)]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         loop {
             let mut made_progress_this_iter = false;
@@ -80,7 +73,7 @@ impl<St, Fut, F> Future for TryForEachConcurrent<St, Fut, F>
             let current_len = self.futures.len();
             // Check if we've already created a number of futures greater than `limit`
             if self.limit.map(|limit| limit.get() > current_len).unwrap_or(true) {
-                let poll_res = match self.as_mut().stream().as_pin_mut() {
+                let poll_res = match self.stream.as_mut().as_pin_mut() {
                     Some(stream) => stream.try_poll_next(cx),
                     None => Poll::Ready(None),
                 };
@@ -91,26 +84,26 @@ impl<St, Fut, F> Future for TryForEachConcurrent<St, Fut, F>
                         Some(elem)
                     },
                     Poll::Ready(None) => {
-                        self.as_mut().stream().set(None);
+                        self.stream.set(None);
                         None
                     }
                     Poll::Pending => None,
                     Poll::Ready(Some(Err(e))) => {
                         // Empty the stream and futures so that we know
                         // the future has completed.
-                        self.as_mut().stream().set(None);
-                        drop(mem::replace(self.as_mut().futures(), FuturesUnordered::new()));
+                        self.stream.set(None);
+                        drop(mem::replace(self.futures, FuturesUnordered::new()));
                         return Poll::Ready(Err(e));
                     }
                 };
 
                 if let Some(elem) = elem {
-                    let next_future = (self.as_mut().f())(elem);
-                    self.as_mut().futures().push(next_future);
+                    let next_future = (self.f)(elem);
+                    self.futures.push(next_future);
                 }
             }
 
-            match self.as_mut().futures().poll_next_unpin(cx) {
+            match self.futures.poll_next_unpin(cx) {
                 Poll::Ready(Some(Ok(()))) => made_progress_this_iter = true,
                 Poll::Ready(None) => {
                     if self.stream.is_none() {
@@ -121,8 +114,8 @@ impl<St, Fut, F> Future for TryForEachConcurrent<St, Fut, F>
                 Poll::Ready(Some(Err(e))) => {
                     // Empty the stream and futures so that we know
                     // the future has completed.
-                    self.as_mut().stream().set(None);
-                    drop(mem::replace(self.as_mut().futures(), FuturesUnordered::new()));
+                    self.stream.set(None);
+                    drop(mem::replace(self.futures, FuturesUnordered::new()));
                     return Poll::Ready(Err(e));
                 }
             }
diff --git a/futures-util/src/try_stream/try_skip_while.rs b/futures-util/src/try_stream/try_skip_while.rs
index dd676c3937..6e223b35e4 100644
--- a/futures-util/src/try_stream/try_skip_while.rs
+++ b/futures-util/src/try_stream/try_skip_while.rs
@@ -5,21 +5,22 @@ use futures_core::stream::{Stream, TryStream};
 use futures_core::task::{Context, Poll};
 #[cfg(feature = "sink")]
 use futures_sink::Sink;
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
+use pin_project::{pin_project, unsafe_project};
 
 /// Stream for the [`try_skip_while`](super::TryStreamExt::try_skip_while)
 /// method.
+#[unsafe_project(Unpin)]
 #[must_use = "streams do nothing unless polled"]
 pub struct TrySkipWhile<St, Fut, F> where St: TryStream {
+    #[pin]
     stream: St,
     f: F,
+    #[pin]
     pending_fut: Option<Fut>,
     pending_item: Option<St::Ok>,
     done_skipping: bool,
 }
 
-impl<St: Unpin + TryStream, Fut: Unpin, F> Unpin for TrySkipWhile<St, Fut, F> {}
-
 impl<St, Fut, F> fmt::Debug for TrySkipWhile<St, Fut, F>
 where
     St: TryStream + fmt::Debug,
@@ -47,11 +48,6 @@ impl<St, Fut, F> TrySkipWhile<St, Fut, F>
           F: FnMut(&St::Ok) -> Fut,
           Fut: TryFuture<Ok = bool, Error = St::Error>,
 {
-    unsafe_unpinned!(f: F);
-    unsafe_pinned!(pending_fut: Option<Fut>);
-    unsafe_unpinned!(pending_item: Option<St::Ok>);
-    unsafe_unpinned!(done_skipping: bool);
-
     pub(super) fn new(stream: St, f: F) -> TrySkipWhile<St, Fut, F> {
         TrySkipWhile {
             stream,
@@ -82,8 +78,9 @@ impl<St, Fut, F> TrySkipWhile<St, Fut, F>
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
+    #[pin_project(self)]
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        self.stream()
+        self.stream
     }
 
     /// Consumes this combinator, returning the underlying stream.
@@ -102,31 +99,32 @@ impl<St, Fut, F> Stream for TrySkipWhile<St, Fut, F>
 {
     type Item = Result<St::Ok, St::Error>;
 
+    #[pin_project(self)]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        if self.done_skipping {
-            return self.as_mut().stream().try_poll_next(cx);
+        if *self.done_skipping {
+            return self.stream.try_poll_next(cx);
         }
 
         loop {
             if self.pending_item.is_none() {
-                let item = match ready!(self.as_mut().stream().try_poll_next(cx)?) {
+                let item = match ready!(self.stream.as_mut().try_poll_next(cx)?) {
                     Some(e) => e,
                     None => return Poll::Ready(None),
                 };
-                let fut = (self.as_mut().f())(&item);
-                self.as_mut().pending_fut().set(Some(fut));
-                *self.as_mut().pending_item() = Some(item);
+                let fut = (self.f)(&item);
+                self.pending_fut.set(Some(fut));
+                *self.pending_item = Some(item);
             }
 
-            let skipped = ready!(self.as_mut().pending_fut().as_pin_mut().unwrap().try_poll(cx)?);
-            let item = self.as_mut().pending_item().take().unwrap();
-            self.as_mut().pending_fut().set(None);
+            let skipped = ready!(self.pending_fut.as_mut().as_pin_mut().unwrap().try_poll(cx)?);
+            let item = self.pending_item.take().unwrap();
+            self.pending_fut.set(None);
 
             if !skipped {
-                *self.as_mut().done_skipping() = true;
+                *self.done_skipping = true;
                 return Poll::Ready(Some(Ok(item)))
             }
         }