Future::boxed and Stream::boxed should prevent double boxing

Fixes rust-lang#511

Author: stepancheg

Cargo.toml

@@ -20,6 +20,9 @@ appveyor = { repository = "alexcrichton/futures-rs" }
 
 [dependencies]
 
+[build-dependencies]
+regex = "0.2"
+
 [features]
 use_std = []
 with-deprecated = []

build.rs

@@ -0,0 +1,36 @@
+extern crate regex;
+
+use std::env;
+use std::str;
+use std::process;
+
+fn main() {
+    let rustc = env::var("RUSTC").expect("RUSTC variable is unset");
+
+    let command = process::Command::new(rustc)
+        .args(&["--version"])
+        .stdin(process::Stdio::null())
+        .stderr(process::Stdio::inherit())
+        .stdout(process::Stdio::piped())
+        .spawn()
+        .expect("spawn rustc");
+
+    let wait = command.wait_with_output().expect("wait for rust");
+    if !wait.status.success() {
+        panic!("rustc --version exited with non-zero code");
+    }
+
+    let stdout = str::from_utf8(&wait.stdout).expect("stdout is not UTF-8");
+
+    let re = regex::Regex::new(r"^rustc (\d+)\.(\d+)\.(\d+)").expect("compile regex");
+    let captures = re.captures(stdout)
+        .expect(&format!("regex cannot match `rustc --version` output: {:?}", stdout));
+
+    let major: u32 = captures.get(1).expect("major").as_str().parse().unwrap();
+    let minor: u32 = captures.get(2).expect("minor").as_str().parse().unwrap();
+    let _patch: u32 = captures.get(3).expect("patch").as_str().parse().unwrap();
+
+    if major > 1 || minor >= 18 {
+        println!("cargo:rustc-cfg=rust_at_least_1_18");
+    }
+}

src/future/mod.rs

@@ -308,7 +308,40 @@ pub trait Future {
     fn boxed(self) -> BoxFuture<Self::Item, Self::Error>
         where Self: Sized + Send + 'static
     {
-        ::std::boxed::Box::new(self)
+        #[cfg(rust_at_least_1_18)]
+        fn boxed<F>(future: F) -> BoxFuture<F::Item, F::Error>
+            where F: Future + Sized + Send + 'static
+        {
+            use std::any::TypeId;
+            use std::mem;
+            use std::ptr;
+            use std::boxed;
+
+            // Prevent double boxing
+            if TypeId::of::<F>() == TypeId::of::<BoxFuture<F::Item, F::Error>>() {
+                assert!(mem::size_of::<F>() == mem::size_of::<BoxFuture<F::Item, F::Error>>());
+                unsafe {
+                    let mut r: BoxFuture<F::Item, F::Error> = mem::uninitialized();
+                    ptr::copy_nonoverlapping(
+                        &future as *const F,
+                        &mut r as *mut BoxFuture<F::Item, F::Error> as *mut u8 as *mut F,
+                        1);
+                    mem::forget(future);
+                    r
+                }
+            } else {
+                boxed::Box::new(future)
+            }
+        }
+
+        #[cfg(not(rust_at_least_1_18))]
+        fn boxed<F>(future: F) -> BoxFuture<F::Item, F::Error>
+            where F: Future + Sized + Send + 'static
+        {
+            ::std::boxed::Box::new(future)
+        }
+
+        boxed(self)
     }
 
     /// Map this future's result to a different type, returning a new future of

src/stream/mod.rs

@@ -250,7 +250,40 @@ pub trait Stream {
     fn boxed(self) -> BoxStream<Self::Item, Self::Error>
         where Self: Sized + Send + 'static,
     {
-        ::std::boxed::Box::new(self)
+        #[cfg(rust_at_least_1_18)]
+        fn boxed<S>(stream: S) -> BoxStream<S::Item, S::Error>
+            where S: Stream + Sized + Send + 'static
+        {
+            use std::any::TypeId;
+            use std::mem;
+            use std::ptr;
+            use std::boxed;
+
+            // Prevent double boxing
+            if TypeId::of::<S>() == TypeId::of::<BoxStream<S::Item, S::Error>>() {
+                assert!(mem::size_of::<S>() == mem::size_of::<BoxStream<S::Item, S::Error>>());
+                unsafe {
+                    let mut r: BoxStream<S::Item, S::Error> = mem::uninitialized();
+                    ptr::copy_nonoverlapping(
+                        &stream as *const S,
+                        &mut r as *mut BoxStream<S::Item, S::Error> as *mut u8 as *mut S,
+                        1);
+                    mem::forget(stream);
+                    r
+                }
+            } else {
+                boxed::Box::new(stream)
+            }
+        }
+
+        #[cfg(not(rust_at_least_1_18))]
+        fn boxed<S>(stream: S) -> BoxStream<S::Item, S::Error>
+            where S: Stream + Sized + Send + 'static
+        {
+            ::std::boxed::Box::new(stream)
+        }
+
+        boxed(self)
     }
 
     /// Converts this stream into a `Future`.

tests/boxed.rs

@@ -0,0 +1,62 @@
+#![cfg(rust_at_least_1_18)]
+
+extern crate futures;
+
+use futures::Async;
+use futures::Poll;
+use futures::future::Future;
+use futures::stream::Stream;
+
+
+#[test]
+fn future_boxed_prevents_double_boxing() {
+    struct MyFuture {
+        r: &'static str,
+    }
+
+    impl Future for MyFuture {
+        type Item = &'static str;
+        type Error = ();
+
+        fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+            Ok(Async::Ready(self.r))
+        }
+    }
+
+    let f = MyFuture { r: "I'm ready" };
+    let f = f.boxed();
+    let ptr = f.as_ref() as *const Future<Item=_, Error=_>;
+    let f = f.boxed();
+    let f = f.boxed();
+    let mut f = f.boxed();
+    assert_eq!(f.as_ref() as *const Future<Item=_, Error=_>, ptr);
+    assert_eq!(Ok(Async::Ready("I'm ready")), f.poll());
+}
+
+#[test]
+fn stream_boxed_prevents_double_boxing() {
+    struct MyStream {
+        i: u32,
+    }
+
+    impl Stream for MyStream {
+        type Item = u32;
+        type Error = ();
+
+        fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
+            self.i += 1;
+            Ok(Async::Ready(Some(self.i)))
+        }
+    }
+
+    let s = MyStream { i: 0 };
+    let s = s.boxed();
+    let ptr = s.as_ref() as *const Stream<Item=_, Error=_>;
+    let s = s.boxed();
+    let s = s.boxed();
+    let mut s = s.boxed();
+    assert_eq!(s.as_ref() as *const Stream<Item=_, Error=_>, ptr);
+    assert_eq!(Ok(Async::Ready(Some(1))), s.poll());
+    assert_eq!(Ok(Async::Ready(Some(2))), s.poll());
+    assert_eq!(Ok(Async::Ready(Some(3))), s.poll());
+}