diff --git a/futures-await-async-macro/src/lib.rs b/futures-await-async-macro/src/lib.rs
index 841e5f3..b879ba2 100644
--- a/futures-await-async-macro/src/lib.rs
+++ b/futures-await-async-macro/src/lib.rs
@@ -206,7 +206,7 @@ where F: FnOnce(&Type, &[&Lifetime]) -> proc_macro2::TokenStream
     let gen_function = respan(gen_function.into(), &output_span);
     let body_inner = if pinned {
         quote_cs! {
-            #gen_function (#[allow(unused_unsafe)] unsafe { static move || -> #output #gen_body })
+            #gen_function (static move || -> #output #gen_body)
         }
     } else {
         quote_cs! {
diff --git a/src/__rt/future.rs b/src/__rt/future.rs
index 1ebd745..b52ae45 100644
--- a/src/__rt/future.rs
+++ b/src/__rt/future.rs
@@ -36,7 +36,10 @@ impl<T> Future for GenFuture<T>
     fn poll(&mut self, ctx: &mut task::Context) -> Poll<Self::Item, Self::Error> {
         CTX.with(|cell| {
             let _r = Reset::new(ctx, cell);
-            match self.0.resume() {
+            // Because we are controlling the creation of our underlying
+            // generator, we know that this is definitely a movable generator
+            // so calling resume is always safe.
+            match unsafe { self.0.resume() } {
                 GeneratorState::Yielded(Async::Pending)
                     => Ok(Async::Pending),
                 GeneratorState::Yielded(Async::Ready(mu))
diff --git a/src/__rt/pinned_future.rs b/src/__rt/pinned_future.rs
index 9897369..e69ad02 100644
--- a/src/__rt/pinned_future.rs
+++ b/src/__rt/pinned_future.rs
@@ -31,7 +31,9 @@ impl<T> StableFuture for GenStableFuture<T>
         CTX.with(|cell| {
             let _r = Reset::new(ctx, cell);
             let this: &mut Self = unsafe { Pin::get_mut(&mut self) };
-            match this.0.resume() {
+            // This is an immovable generator, but since we're only accessing
+            // it via a Pin this is safe.
+            match unsafe { this.0.resume() } {
                 GeneratorState::Yielded(Async::Pending)
                     => Ok(Async::Pending),
                 GeneratorState::Yielded(Async::Ready(mu))
diff --git a/src/__rt/pinned_stream.rs b/src/__rt/pinned_stream.rs
index 5eb4b43..f5c55a6 100644
--- a/src/__rt/pinned_stream.rs
+++ b/src/__rt/pinned_stream.rs
@@ -43,7 +43,9 @@ impl<U, T> StableStream for GenStableStream<U, T>
             let _r = Reset::new(ctx, cell);
             let this: &mut Self = unsafe { Pin::get_mut(&mut self) };
             if this.done { return Ok(Async::Ready(None)) }
-            match this.gen.resume() {
+            // This is an immovable generator, but since we're only accessing
+            // it via a Pin this is safe.
+            match unsafe { this.gen.resume() } {
                 GeneratorState::Yielded(Async::Ready(e)) => {
                     Ok(Async::Ready(Some(e)))
                 }
diff --git a/src/__rt/stream.rs b/src/__rt/stream.rs
index 0bb807e..b404a29 100644
--- a/src/__rt/stream.rs
+++ b/src/__rt/stream.rs
@@ -38,7 +38,10 @@ impl<U, T> Stream for GenStream<U, T>
         CTX.with(|cell| {
             let _r = Reset::new(ctx, cell);
             if self.done { return Ok(Async::Ready(None)) }
-            match self.gen.resume() {
+            // Because we are controlling the creation of our underlying
+            // generator, we know that this is definitely a movable generator
+            // so calling resume is always safe.
+            match unsafe { self.gen.resume() } {
                 GeneratorState::Yielded(Async::Ready(e)) => {
                     Ok(Async::Ready(Some(e)))
                 }