Change Never to use ! instead of PhantomData

Author: cramertj

.travis.yml

@@ -21,6 +21,7 @@ before_script:
   - pip install git+https://github.com/euclio/travis-cargo@kcov --user && export PATH=$HOME/.local/bin:$PATH
 script:
   - cargo test
+  - cargo test --features "nightly"
   - cargo test --manifest-path futures-io/Cargo.toml
   - cargo test --manifest-path futures-iobuf/Cargo.toml
   - cargo test --manifest-path futures-cpupool/Cargo.toml

Cargo.toml

@@ -13,6 +13,9 @@ An implementation of futures and streams featuring zero allocations,
 composability, and iterator-like interfaces.
 """
 
+[features]
+nightly = []
+
 [workspace]
 members = [
   "futures-tls",

src/lib.rs

@@ -150,6 +150,7 @@
 //! [README]: https://github.com/alexcrichton/futures-rs#futures-rs
 
 #![deny(missing_docs)]
+#![cfg_attr(feature = "nightly", feature(never_type, conservative_impl_trait))]
 
 #[macro_use]
 extern crate log;

src/never.rs

@@ -1,10 +1,18 @@
+#[cfg(not(feature = "nightly"))]
 use std::marker;
 
 use {Future, Task, Poll};
 
 /// A future which is never resolved.
 ///
 /// This future can be created with the `empty` function.
+#[cfg(feature = "nightly")]
+pub struct Never {}
+
+/// A future which is never resolved.
+///
+/// This future can be created with the `empty` function.
+#[cfg(not(feature = "nightly"))]
 pub struct Never<T, E>
     where T: 'static,
           E: 'static,
@@ -18,10 +26,39 @@ pub struct Never<T, E>
 /// The returned future will never resolve with a success but is still
 /// susceptible to cancellation. That is, if a callback is scheduled on the
 /// returned future, it is only run once the future is dropped (canceled).
+#[cfg(feature = "nightly")]
+pub fn never<T, E>() -> impl Future<Item = T, Error = E> + Send + 'static
+    where T: 'static,
+          E: 'static,
+{
+    (Never {})
+        .map(|x| x)
+        .map_err(|x| x)
+}
+
+/// Creates a future which never resolves, representing a computation that never
+/// finishes.
+///
+/// The returned future will never resolve with a success but is still
+/// susceptible to cancellation. That is, if a callback is scheduled on the
+/// returned future, it is only run once the future is dropped (canceled).
+#[cfg(not(feature = "nightly"))]
 pub fn never<T: 'static, E: 'static>() -> Never<T, E> {
     Never { _data: marker::PhantomData }
 }
 
+#[cfg(feature = "nightly")]
+impl Future for Never {
+    type Item = !;
+    type Error = !;
+
+    fn poll(&mut self, _: &mut Task) -> Poll<!, !> {
+        Poll::NotReady
+    }
+
+    fn schedule(&mut self, _task: &mut Task) {}
+}
+#[cfg(not(feature = "nightly"))]
 impl<T, E> Future for Never<T, E>
     where T: 'static,
           E: 'static,

tests/all.rs

@@ -1,3 +1,5 @@
+#![cfg_attr(feature = "nightly", feature(never_type, conservative_impl_trait))]
+
 extern crate futures;
 
 use std::sync::mpsc::{channel, TryRecvError};
@@ -63,6 +65,10 @@ fn result_smoke() {
 
 #[test]
 fn test_never() {
+    #[cfg(feature = "nightly")]
+    fn never() -> impl Future<Item = i32, Error = u32> + Send + 'static { futures::never() }
+
+    #[cfg(not(feature = "nightly"))]
     fn never() -> Never<i32, u32> { futures::never() }
 
     assert_empty(|| never());