reactor: Remove extra semi colon (#1616 )

* reactor: Remove extra semi colon * fmt
v0.1.x: stage -threadpool 0.1.16 -reactor 0.1.10 releases (#1604 )
2026-09-09 00:00:08 +02:00 · 2019-09-30 15:06:17 -04:00 · 2019-09-30 14:21:56 -04:00 · 2019-08-30 22:29:02 -04:00 · 2019-08-30 17:51:48 -04:00 · 2019-08-30 11:13:54 -07:00
229 changed files with 3043 additions and 7947 deletions
@@ -31,11 +31,11 @@ task:
    folder: $HOME/.cargo/registry
  test_script:
    - . $HOME/.cargo/env
-    - cargo test --all --no-fail-fast
+    - cargo test --all
    - cargo doc --all
  i686_test_script:
    - . $HOME/.cargo/env
    - |
-      cargo test --all --exclude tokio-tls --no-fail-fast --target i686-unknown-freebsd
+      cargo test --all --exclude tokio-tls --exclude tokio-macros --target i686-unknown-freebsd
  before_cache_script:
    - rm -rf $HOME/.cargo/registry/index
@@ -2,22 +2,21 @@

 members = [
  "tokio",
-  "tokio-async-await",
  "tokio-buf",
  "tokio-codec",
  "tokio-current-thread",
  "tokio-executor",
  "tokio-fs",
+  "tokio-futures",
  "tokio-io",
  "tokio-reactor",
  "tokio-signal",
  "tokio-sync",
+  "tokio-test",
  "tokio-threadpool",
  "tokio-timer",
  "tokio-tcp",
  "tokio-tls",
-  "tokio-trace",
-  "tokio-trace/tokio-trace-core",
  "tokio-udp",
  "tokio-uds",
 ]
@@ -20,7 +20,7 @@ the Rust programming language. It is:
 [crates-badge]: https://img.shields.io/crates/v/tokio.svg
 [crates-url]: https://crates.io/crates/tokio
 [mit-badge]: https://img.shields.io/badge/license-MIT-blue.svg
-[mit-url]: LICENSE-MIT
+[mit-url]: LICENSE
 [azure-badge]: https://dev.azure.com/tokio-rs/Tokio/_apis/build/status/tokio-rs.tokio?branchName=master
 [azure-url]: https://dev.azure.com/tokio-rs/Tokio/_build/latest?definitionId=1&branchName=master
 [gitter-badge]: https://img.shields.io/gitter/room/tokio-rs/tokio.svg
@@ -28,7 +28,7 @@ the Rust programming language. It is:

 [Website](https://tokio.rs) |
 [Guides](https://tokio.rs/docs/getting-started/hello-world/) |
-[API Docs](https://docs.rs/tokio/0.1.18/tokio) |
+[API Docs](https://docs.rs/tokio/0.1.20/tokio) |
 [Chat](https://gitter.im/tokio-rs/tokio)

 The API docs for the master branch are published [here][master-dox].
@@ -49,9 +49,9 @@ level, it provides a few major components:
 These components provide the runtime components necessary for building
 an asynchronous application.

-[net]: https://docs.rs/tokio/0.1.18/tokio/net/index.html
-[reactor]: https://docs.rs/tokio/0.1.18/tokio/reactor/index.html
-[scheduler]: https://docs.rs/tokio/0.1.18/tokio/runtime/index.html
+[net]: https://docs.rs/tokio/0.1.20/tokio/net/index.html
+[reactor]: https://docs.rs/tokio/0.1.20/tokio/reactor/index.html
+[scheduler]: https://docs.rs/tokio/0.1.20/tokio/runtime/index.html

 ## Example

@@ -98,7 +98,7 @@ fn main() {
 }
 ```

-More examples can be found [here](examples).
+More examples can be found [here](tokio/examples).

 ## Getting Help

@@ -126,10 +126,6 @@ have greater guarantees of stability.

 The crates included as part of Tokio are:

-* [`tokio-async-await`]: Experimental `async` / `await` support.
-
-* [`tokio-codec`]: Utilities for encoding and decoding protocol frames.
-
 * [`tokio-current-thread`]: Schedule the execution of futures on the current
  thread.

@@ -137,8 +133,14 @@ The crates included as part of Tokio are:

 * [`tokio-fs`]: Filesystem (and standard in / out) APIs.

+* [`tokio-futures`]: Experimental `std::future::Future` and `async` / `await` support.
+
+* [`tokio-codec`]: Utilities for encoding and decoding protocol frames.
+
 * [`tokio-io`]: Asynchronous I/O related traits and utilities.

+* [`tokio-macros`]: Macros for usage with Tokio.
+
 * [`tokio-reactor`]: Event loop that drives I/O resources (like TCP and UDP
  sockets).

@@ -154,12 +156,13 @@ The crates included as part of Tokio are:
 * [`tokio-uds`]: Unix Domain Socket bindings for use with `tokio-io` and
  `tokio-reactor`.

-[`tokio-async-await`]: tokio-async-await
 [`tokio-codec`]: tokio-codec
 [`tokio-current-thread`]: tokio-current-thread
 [`tokio-executor`]: tokio-executor
 [`tokio-fs`]: tokio-fs
+[`tokio-futures`]: tokio-futures
 [`tokio-io`]: tokio-io
+[`tokio-macros`]: tokio-macros
 [`tokio-reactor`]: tokio-reactor
 [`tokio-tcp`]: tokio-tcp
 [`tokio-threadpool`]: tokio-threadpool
@@ -167,6 +170,23 @@ The crates included as part of Tokio are:
 [`tokio-udp`]: tokio-udp
 [`tokio-uds`]: tokio-uds

+## Related Projects
+
+In addition to the crates in this repository, the Tokio project also maintains
+several other libraries, including:
+
+* [`tracing`] (formerly `tokio-trace`): A framework for application-level
+  tracing and async-aware diagnostics.
+
+* [`mio`]: A low-level, cross-platform abstraction over OS I/O APIs that powers
+  `tokio`.
+
+* [`bytes`]: Utilities for working with bytes, including efficient byte buffers.
+
+[`tracing`]: https://github.com/tokio-rs/tracing
+[`mio`]: https://github.com/tokio-rs/mio
+[`bytes`]: https://github.com/tokio-rs/bytes
+
 ## Supported Rust Versions

 Tokio is built against the latest stable, nightly, and beta Rust releases. The
@@ -0,0 +1,2 @@
+[build]
+target-dir = "../target"
@@ -0,0 +1,49 @@
+[package]
+name = "examples"
+edition = "2018"
+version = "0.1.0"
+authors = ["Carl Lerche <[email protected]>"]
+license = "MIT"
+
+# Break out of the parent workspace
+[workspace]
+
+[[bin]]
+name = "chat"
+path = "src/chat.rs"
+
+[[bin]]
+name = "echo_client"
+path = "src/echo_client.rs"
+
+[[bin]]
+name = "echo_server"
+path = "src/echo_server.rs"
+
+[[bin]]
+name = "hyper"
+path = "src/hyper.rs"
+
+[dependencies]
+tokio = { version = "0.1.18", features = ["async-await-preview"] }
+futures = "0.1.23"
+bytes = "0.4.9"
+hyper = "0.12.8"
+
+# Avoid using crates.io for Tokio dependencies
+[patch.crates-io]
+tokio = { path = "../tokio" }
+tokio-codec = { path = "../tokio-codec" }
+tokio-current-thread = { path = "../tokio-current-thread" }
+tokio-executor = { path = "../tokio-executor" }
+tokio-fs = { path = "../tokio-fs" }
+tokio-futures  = { path = "../tokio-futures" }
+tokio-io = { path = "../tokio-io" }
+tokio-reactor = { path = "../tokio-reactor" }
+tokio-signal = { path = "../tokio-signal" }
+tokio-tcp = { path = "../tokio-tcp" }
+tokio-threadpool = { path = "../tokio-threadpool" }
+tokio-timer = { path = "../tokio-timer" }
+tokio-tls = { path = "../tokio-tls" }
+tokio-udp = { path = "../tokio-udp" }
+tokio-uds = { path = "../tokio-uds" }
@@ -1,9 +1,6 @@
-#![feature(await_macro, async_await, futures_api)]
-
-#[macro_use]
-extern crate tokio;
-extern crate futures; // v0.1
+#![feature(await_macro, async_await)]

+use tokio::await;
 use tokio::codec::{LinesCodec, Decoder};
 use tokio::net::{TcpListener, TcpStream};
 use tokio::prelude::*;
@@ -95,7 +92,8 @@ async fn process(stream: TcpStream, state: Arc<Mutex<Shared>>) -> io::Result<()>
    Ok(())
 }

-fn main() {
+#[tokio::main]
+async fn main() {
    // Create the shared state. This is how all the peers communicate.
    //
    // The server task will hold a handle to this. For every new client, the
@@ -113,23 +111,21 @@ fn main() {
    println!("server running on localhost:6142");

    // Start the Tokio runtime.
-    tokio::run_async(async move {
-        let mut incoming = listener.incoming();
+    let mut incoming = listener.incoming();

-        while let Some(stream) = await!(incoming.next()) {
-            let stream = match stream {
-                Ok(stream) => stream,
-                Err(_) => continue,
-            };
+    while let Some(stream) = await!(incoming.next()) {
+        let stream = match stream {
+            Ok(stream) => stream,
+            Err(_) => continue,
+        };

-            let state = state.clone();
+        let state = state.clone();

-            tokio::spawn_async(async move {
-                if let Err(_) = await!(process(stream, state)) {
-                    eprintln!("failed to process connection");
-                }
-            });
-        }
-    });
+        tokio::spawn_async(async move {
+            if let Err(_) = await!(process(stream, state)) {
+                eprintln!("failed to process connection");
+            }
+        });
+    }
 }

@@ -1,8 +1,6 @@
-#![feature(await_macro, async_await, futures_api)]
-
-#[macro_use]
-extern crate tokio;
+#![feature(await_macro, async_await)]

+use tokio::await;
 use tokio::net::TcpStream;
 use tokio::prelude::*;

@@ -36,7 +34,8 @@ async fn run_client(addr: &SocketAddr) -> io::Result<()> {
    Ok(())
 }

-fn main() {
+#[tokio::main]
+async fn main() {
    use std::env;

    let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
@@ -44,10 +43,8 @@ fn main() {

    // Connect to the echo serveer

-    tokio::run_async(async move {
-        match await!(run_client(&addr)) {
-            Ok(_) => println!("done."),
-            Err(e) => eprintln!("echo client failed; error = {:?}", e),
-        }
-    });
+    match await!(run_client(&addr)) {
+        Ok(_) => println!("done."),
+        Err(e) => eprintln!("echo client failed; error = {:?}", e),
+    }
 }
@@ -1,8 +1,6 @@
-#![feature(await_macro, async_await, futures_api)]
-
-#[macro_use]
-extern crate tokio;
+#![feature(await_macro, async_await)]

+use tokio::await;
 use tokio::net::{TcpListener, TcpStream};
 use tokio::prelude::*;

@@ -24,7 +22,8 @@ fn handle(mut stream: TcpStream) {
    });
 }

-fn main() {
+#[tokio::main]
+async fn main() {
    use std::env;

    let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
@@ -34,12 +33,10 @@ fn main() {
    let listener = TcpListener::bind(&addr).unwrap();
    println!("Listening on: {}", addr);

-    tokio::run_async(async {
-        let mut incoming = listener.incoming();
+    let mut incoming = listener.incoming();

-        while let Some(stream) = await!(incoming.next()) {
-            let stream = stream.unwrap();
-            handle(stream);
-        }
-    });
+    while let Some(stream) = await!(incoming.next()) {
+        let stream = stream.unwrap();
+        handle(stream);
+    }
 }
@@ -0,0 +1,29 @@
+#![feature(await_macro, async_await)]
+
+use tokio::await;
+use tokio::prelude::*;
+use hyper::Client;
+
+use std::time::Duration;
+use std::str;
+
+#[tokio::main]
+async fn main() {
+    let client = Client::new();
+
+    let uri = "http://httpbin.org/ip".parse().unwrap();
+
+    let response = await!({
+        client.get(uri)
+            .timeout(Duration::from_secs(10))
+    }).unwrap();
+
+    println!("Response: {}", response.status());
+
+    let mut body = response.into_body();
+
+    while let Some(chunk) = await!(body.next()) {
+        let chunk = chunk.unwrap();
+        println!("chunk = {}", str::from_utf8(&chunk[..]).unwrap());
+    }
+}
@@ -0,0 +1,22 @@
+#![feature(await_macro, async_await)]
+
+use tokio::await;
+use tokio::timer::Delay;
+use std::time::{Duration, Instant};
+
+#[tokio::test]
+async fn success_no_async() {
+    assert!(true);
+}
+
+#[tokio::test]
+#[should_panic]
+async fn fail_no_async() {
+    assert!(false);
+}
+
+#[tokio::test]
+async fn use_timer() {
+    let when = Instant::now() + Duration::from_millis(10);
+    await!(Delay::new(when));
+}
@@ -1,5 +1,5 @@
-trigger: ["master"]
-pr: ["master"]
+trigger: ["master", "v0.1.x"]
+pr: ["master", "v0.1.x"]

 jobs:
 # Check formatting
@@ -45,8 +45,7 @@ jobs:
      - tokio-sync
      - tokio-threadpool
      - tokio-timer
-      - tokio-trace
-      - tokio-trace/tokio-trace-core
+      - tokio-test

 - template: ci/azure-cargo-check.yml
  parameters:
@@ -64,20 +63,17 @@ jobs:
        - timer
        - udp
        - uds
+        - sync
+        - experimental-tracing
      tokio-buf:
        - util

-# Check async / await
- template: ci/azure-cargo-check.yml
+# Run async-await tests
+- template: ci/azure-test-nightly.yml
  parameters:
-    name: async_await
-    displayName: Async / Await
-    rust: nightly-2019-02-28
-    noDefaultFeatures: ''
-    benches: true
-    crates:
-      tokio:
-        - async-await-preview
+    name: test_nightly
+    displayName: Test Async / Await
+    rust: nightly-2019-04-25

 # Try cross compiling
 - template: ci/azure-cross-compile.yml
@@ -95,7 +91,7 @@ jobs:
 - template: ci/azure-check-minrust.yml
  parameters:
    name: minrust
-    rust_version: 1.26.0
+    rust_version: 1.31.0

 - template: ci/azure-tsan.yml
  parameters:
@@ -109,7 +105,7 @@ jobs:
      - test_sub_cross
      - test_linux
      - features
-      - async_await
+      - test_nightly
      - cross_32bit_linux
      - minrust
      - tsan
@@ -27,7 +27,3 @@ jobs:
      - script: cargo check ${{ parameters.noDefaultFeatures }} --features ${{ feature }}
        displayName: Check `${{ crate.key }}`, features = ${{ feature }}
        workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}
-
-  - ${{ if parameters.benches }}:
-    - script: cargo check --benches --all
-      displayName: Check benchmarks
@@ -8,6 +8,9 @@ jobs:
    parameters:
      rust_version: stable

+  - script: sudo apt-get update
+    displayName: "apt-get update"
+
  - script: sudo apt-get install gcc-multilib
    displayName: "Install gcc-multilib"

@@ -2,7 +2,10 @@ steps:
  # Linux and macOS.
  - script: |
      set -e
-      curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain $RUSTUP_TOOLCHAIN
+      curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain none
+      export PATH=$PATH:$HOME/.cargo/bin
+      rustup toolchain install $RUSTUP_TOOLCHAIN
+      rustup default $RUSTUP_TOOLCHAIN
      echo "##vso[task.setvariable variable=PATH;]$PATH:$HOME/.cargo/bin"
    env:
      RUSTUP_TOOLCHAIN: ${{parameters.rust_version}}
@@ -11,13 +14,16 @@ steps:

  # Windows.
  - script: |
+      echo "windows"
      curl -sSf -o rustup-init.exe https://win.rustup.rs
-      rustup-init.exe -y --default-toolchain %RUSTUP_TOOLCHAIN%
+      rustup-init.exe -y --default-toolchain none
      set PATH=%PATH%;%USERPROFILE%\.cargo\bin
+      rustup toolchain install %RUSTUP_TOOLCHAIN%
+      rustup default %RUSTUP_TOOLCHAIN%
      echo "##vso[task.setvariable variable=PATH;]%PATH%;%USERPROFILE%\.cargo\bin"
    env:
      RUSTUP_TOOLCHAIN: ${{parameters.rust_version}}
-    displayName: "Install rust (windows)"
+    displayName: Install rust (windows)
    condition: eq(variables['Agent.OS'], 'Windows_NT')

  # All platforms.
@@ -2,7 +2,7 @@ steps:
  - bash: |
      set -e

-      if git log --no-merges -1 --format='%s' | grep -q '[ci-release]'; then
+      if git log --no-merges -1 --format='%B' | grep -qF '[ci-release]'; then
        echo "##vso[task.setvariable variable=isRelease]true"
      fi
    failOnStderr: true
@@ -0,0 +1,19 @@
+jobs:
+- job: ${{ parameters.name }}
+  displayName: ${{ parameters.displayName }}
+  pool:
+    vmImage: ubuntu-16.04
+
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: ${{ parameters.rust }}
+
+  - template: azure-patch-crates.yml
+
+  - script: cargo check --all
+    displayName: cargo check --all
+
+  # Check benches
+  - script: cargo check --benches --all
+    displayName: Check benchmarks
@@ -28,7 +28,7 @@ jobs:
        CI: 'True'
      displayName: cargo test -p ${{ crate }}
      workingDirectory: $(Build.SourcesDirectory)/${{ crate }}
-      condition: and(succeeded(), not(variables['isRelease']))
+      condition: and(succeeded(), ne(variables['isRelease'], 'true'))

  - template: azure-patch-crates.yml

@@ -12,7 +12,7 @@ jobs:
  steps:
  - template: azure-install-rust.yml
    parameters:
-      rust_version: nightly-2018-11-18
+      rust_version: nightly-2019-07-17

  - template: azure-patch-crates.yml
  - script: |
@@ -2,12 +2,12 @@
 # repository.
 [patch.crates-io]
 tokio = { path = "tokio" }
-tokio-async-await = { path = "tokio-async-await" }
 tokio-buf = { path = "tokio-buf" }
 tokio-codec = { path = "tokio-codec" }
 tokio-current-thread = { path = "tokio-current-thread" }
 tokio-executor = { path = "tokio-executor" }
 tokio-fs = { path = "tokio-fs" }
+tokio-futures = { path = "tokio-futures" }
 tokio-io = { path = "tokio-io" }
 tokio-reactor = { path = "tokio-reactor" }
 tokio-signal = { path = "tokio-signal" }
@@ -16,7 +16,5 @@ tokio-threadpool = { path = "tokio-threadpool" }
 tokio-timer = { path = "tokio-timer" }
 tokio-tcp = { path = "tokio-tcp" }
 tokio-tls = { path = "tokio-tls" }
-tokio-trace = { path = "tokio-trace" }
-tokio-trace-core = { path = "tokio-trace/tokio-trace-core" }
 tokio-udp = { path = "tokio-udp" }
 tokio-uds = { path = "tokio-uds" }
@@ -35,3 +35,10 @@ race:WorkerEntry::set_next_sleeper
 # This ignores a false positive caused by `thread::park()`/`thread::unpark()`.
 # See: https://github.com/rust-lang/rust/pull/54806#issuecomment-436193353
 race:pthread_cond_destroy
+
+# Recent rand dependency updates and seeding changes have introduced
+# lazy_static's and other racy code. See:
+# https://github.com/tokio-rs/tokio/pull/1358#issuecomment-516172383
+race:RandomState*::build_hasher
+race:lazy_static::
+race:c2_chacha::guts
@@ -1,2 +0,0 @@
-[build]
-target-dir = "../../target"
@@ -1,49 +0,0 @@
-[package]
-name = "examples"
-edition = "2018"
-version = "0.1.0"
-authors = ["Carl Lerche <[email protected]>"]
-license = "MIT"
-
-# Break out of the parent workspace
-[workspace]
-
-[[bin]]
-name = "chat"
-path = "src/chat.rs"
-
-[[bin]]
-name = "echo_client"
-path = "src/echo_client.rs"
-
-[[bin]]
-name = "echo_server"
-path = "src/echo_server.rs"
-
-[[bin]]
-name = "hyper"
-path = "src/hyper.rs"
-
-[dependencies]
-tokio = { version = "0.1.0", path = "../..", features = ["async-await-preview"] }
-futures = "0.1.23"
-bytes = "0.4.9"
-hyper = "0.12.8"
-
-# Avoid using crates.io for Tokio dependencies
-[patch.crates-io]
-tokio = { path = "../.." }
-tokio-async-await  = { path = "../" }
-tokio-codec = { path = "../../tokio-codec" }
-tokio-current-thread = { path = "../../tokio-current-thread" }
-tokio-executor = { path = "../../tokio-executor" }
-tokio-fs = { path = "../../tokio-fs" }
-tokio-io = { path = "../../tokio-io" }
-tokio-reactor = { path = "../../tokio-reactor" }
-tokio-signal = { path = "../../tokio-signal" }
-tokio-tcp = { path = "../../tokio-tcp" }
-tokio-threadpool = { path = "../../tokio-threadpool" }
-tokio-timer = { path = "../../tokio-timer" }
-tokio-tls = { path = "../../tokio-tls" }
-tokio-udp = { path = "../../tokio-udp" }
-tokio-uds = { path = "../../tokio-uds" }
@@ -1,33 +0,0 @@
-#![feature(await_macro, async_await, futures_api)]
-
-#[macro_use]
-extern crate tokio;
-extern crate hyper;
-
-use tokio::prelude::*;
-use hyper::Client;
-
-use std::time::Duration;
-use std::str;
-
-pub fn main() {
-    tokio::run_async(async {
-        let client = Client::new();
-
-        let uri = "http://httpbin.org/ip".parse().unwrap();
-
-        let response = await!({
-            client.get(uri)
-                .timeout(Duration::from_secs(10))
-        }).unwrap();
-
-        println!("Response: {}", response.status());
-
-        let mut body = response.into_body();
-
-        while let Some(chunk) = await!(body.next()) {
-            let chunk = chunk.unwrap();
-            println!("chunk = {}", str::from_utf8(&chunk[..]).unwrap());
-        }
-    });
-}
@@ -1,4 +0,0 @@
-#![doc(hidden)]
-
-pub mod backward;
-pub mod forward;
@@ -1,3 +1,14 @@
+# 0.1.1 (April 22, 2019)
+
+### Added
+- Utilities for creating a `BufStream` from iterators and streams (#1011).
+- Add `BufStream::into_stream` (#1048).
+- Implement `FromBufStream` for `Bytes` (#1009).
+- Implement `Error` for `CollectVecError` (#1010).
+
+### Fixed
+- Implement `size_hint` for string types (#1012).
+
 # 0.1.0 (February 23, 2019)

 * Initial release
@@ -1,19 +1,19 @@
 [package]
 name = "tokio-buf"
-
 # When releasing to crates.io:
+# - Remove path dependencies
 # - Update html_root_url.
 # - Update doc url
 #   - Cargo.toml
 #   - README.md
 # - Update CHANGELOG.md.
 # - Create "v0.1.x" git tag.
-version = "0.1.0"
+version = "0.1.1"
 authors = ["Carl Lerche <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/tokio-rs/tokio"
 homepage = "https://tokio.rs"
-documentation = "https://docs.rs/tokio-buf/0.1.0/tokio_buf"
+documentation = "https://docs.rs/tokio-buf/0.1.1/tokio_buf"
 description = """
 Asynchronous stream of byte buffers
 """
@@ -27,3 +27,6 @@ futures = "0.1.23"
 [features]
 default = ["util"]
 util = ["bytes/either", "either"]
+
+[dev-dependencies]
+tokio-mock-task = "0.1.1"
@@ -10,7 +10,7 @@ First, add this to your `Cargo.toml`:

 ```toml
 [dependencies]
-tokio-buf = "0.1.0"
+tokio-buf = "0.1.1"
 ```

 Next, add this to your crate:
@@ -1,4 +1,4 @@
-#![doc(html_root_url = "https://docs.rs/tokio-buf/0.1.0")]
+#![doc(html_root_url = "https://docs.rs/tokio-buf/0.1.1")]
 #![deny(missing_docs, missing_debug_implementations, unreachable_pub)]
 #![cfg_attr(test, deny(warnings))]

@@ -29,7 +29,7 @@ impl SizeHint {
    ///
    /// # Panics
    ///
-    /// The function panics if `value` is less than `upper`.
+    /// The function panics if `value` is greater than `upper`.
    pub fn set_lower(&mut self, value: u64) {
        assert!(value <= self.upper.unwrap_or(u64::MAX));
        self.lower = value;
@@ -1,5 +1,6 @@
 use never::Never;
 use BufStream;
+use SizeHint;

 use futures::Poll;

@@ -20,6 +21,10 @@ impl BufStream for String {

        Ok(Some(buf).into())
    }
+
+    fn size_hint(&self) -> SizeHint {
+        size_hint(&self[..])
+    }
 }

 impl BufStream for &'static str {
@@ -36,4 +41,15 @@ impl BufStream for &'static str {

        Ok(Some(buf).into())
    }
+
+    fn size_hint(&self) -> SizeHint {
+        size_hint(&self[..])
+    }
+}
+
+fn size_hint(s: &str) -> SizeHint {
+    let mut hint = SizeHint::new();
+    hint.set_lower(s.len() as u64);
+    hint.set_upper(s.len() as u64);
+    hint
 }
@@ -1,7 +1,9 @@
 use SizeHint;

-use bytes::{Buf, BufMut};
+use bytes::{Buf, BufMut, Bytes};

+use std::error::Error;
+use std::fmt;
 use std::usize;

 /// Conversion from a `BufStream`.
@@ -47,12 +49,18 @@ pub struct CollectVecError {
    _p: (),
 }

+/// Error returned from collecting into a `Bytes`
+#[derive(Debug)]
+pub struct CollectBytesError {
+    _p: (),
+}
+
 impl<T: Buf> FromBufStream<T> for Vec<u8> {
    type Builder = Vec<u8>;
    type Error = CollectVecError;

-    fn builder(_hint: &SizeHint) -> Vec<u8> {
-        Vec::new()
+    fn builder(hint: &SizeHint) -> Vec<u8> {
+        Vec::with_capacity(hint.lower() as usize)
    }

    fn extend(builder: &mut Self, buf: &mut T, hint: &SizeHint) -> Result<(), Self::Error> {
@@ -110,3 +118,45 @@ impl<T: Buf> FromBufStream<T> for Vec<u8> {
        Ok(builder)
    }
 }
+
+impl<T: Buf> FromBufStream<T> for Bytes {
+    type Builder = Vec<u8>;
+    type Error = CollectBytesError;
+
+    fn builder(hint: &SizeHint) -> Vec<u8> {
+        <Vec<u8> as FromBufStream<T>>::builder(hint)
+    }
+
+    fn extend(builder: &mut Vec<u8>, buf: &mut T, hint: &SizeHint) -> Result<(), Self::Error> {
+        <Vec<u8> as FromBufStream<T>>::extend(builder, buf, hint)
+            .map_err(|_| CollectBytesError { _p: () })
+    }
+
+    fn build(builder: Vec<u8>) -> Result<Self, Self::Error> {
+        Ok(builder.into())
+    }
+}
+
+impl fmt::Display for CollectVecError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "BufStream is too big")
+    }
+}
+
+impl Error for CollectVecError {
+    fn description(&self) -> &str {
+        "BufStream too big"
+    }
+}
+
+impl fmt::Display for CollectBytesError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "BufStream too big")
+    }
+}
+
+impl Error for CollectBytesError {
+    fn description(&self) -> &str {
+        "BufStream too big"
+    }
+}
@@ -0,0 +1,54 @@
+use bytes::Buf;
+use futures::Poll;
+use std::error::Error;
+use std::fmt;
+use BufStream;
+
+/// Converts an `Iterator` into a `BufStream` which is always ready to yield the
+/// next value.
+///
+/// Iterators in Rust don't express the ability to block, so this adapter
+/// simply always calls `iter.next()` and returns that.
+pub fn iter<I>(i: I) -> Iter<I::IntoIter>
+where
+    I: IntoIterator,
+    I::Item: Buf,
+{
+    Iter {
+        iter: i.into_iter(),
+    }
+}
+
+/// `BufStream` returned by the [`iter`] function.
+#[derive(Debug)]
+pub struct Iter<I> {
+    iter: I,
+}
+
+#[derive(Debug)]
+pub enum Never {}
+
+impl<I> BufStream for Iter<I>
+where
+    I: Iterator,
+    I::Item: Buf,
+{
+    type Item = I::Item;
+    type Error = Never;
+
+    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
+        Ok(self.iter.next().into())
+    }
+}
+
+impl fmt::Display for Never {
+    fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
+        unreachable!();
+    }
+}
+
+impl Error for Never {
+    fn description(&self) -> &str {
+        unreachable!();
+    }
+}
@@ -3,18 +3,22 @@
 mod chain;
 mod collect;
 mod from;
+mod iter;
 mod limit;
+mod stream;

 pub use self::chain::Chain;
 pub use self::collect::Collect;
 pub use self::from::FromBufStream;
+pub use self::iter::iter;
 pub use self::limit::Limit;
+pub use self::stream::{stream, IntoStream};

 pub mod error {
    //! Error types

    pub use super::collect::CollectError;
-    pub use super::from::CollectVecError;
+    pub use super::from::{CollectBytesError, CollectVecError};
    pub use super::limit::LimitError;
 }

@@ -70,4 +74,14 @@ pub trait BufStreamExt: BufStream {
    {
        Limit::new(self, amount)
    }
+
+    /// Creates a `Stream` from a `BufStream`.
+    ///
+    /// This produces a `Stream` of `BufStream::Items`.
+    fn into_stream(self) -> IntoStream<Self>
+    where
+        Self: Sized,
+    {
+        IntoStream::new(self)
+    }
 }
@@ -0,0 +1,76 @@
+use bytes::Buf;
+use futures::{Async, Poll, Stream};
+use BufStream;
+
+/// Converts a `Stream` of `Buf` types into a `BufStream`.
+///
+/// While `Stream` and `BufStream` are very similar, they are not identical. The
+/// `stream` function returns a `BufStream` that is backed by the provided
+/// `Stream` type.
+pub fn stream<T>(stream: T) -> FromStream<T>
+where
+    T: Stream,
+    T::Item: Buf,
+{
+    FromStream { stream }
+}
+
+/// `BufStream` returned by the [`stream`] function.
+#[derive(Debug)]
+pub struct FromStream<T> {
+    stream: T,
+}
+
+impl<T> BufStream for FromStream<T>
+where
+    T: Stream,
+    T::Item: Buf,
+{
+    type Item = T::Item;
+    type Error = T::Error;
+
+    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
+        self.stream.poll()
+    }
+}
+
+/// Converts a `BufStream` into a `Stream`.
+#[derive(Debug)]
+pub struct IntoStream<T> {
+    buf: T,
+}
+
+impl<T> IntoStream<T> {
+    /// Create a new `Stream` from the provided `BufStream`.
+    pub fn new(buf: T) -> Self {
+        IntoStream { buf }
+    }
+
+    /// Get a reference to the inner `BufStream`.
+    pub fn get_ref(&self) -> &T {
+        &self.buf
+    }
+
+    /// Get a mutable reference to the inner `BufStream`
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.buf
+    }
+
+    /// Get the inner `BufStream`.
+    pub fn into_inner(self) -> T {
+        self.buf
+    }
+}
+
+impl<T: BufStream> Stream for IntoStream<T> {
+    type Item = T::Item;
+    type Error = T::Error;
+
+    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
+        match self.buf.poll_buf()? {
+            Async::Ready(Some(buf)) => Ok(Async::Ready(Some(buf))),
+            Async::Ready(None) => Ok(Async::Ready(None)),
+            Async::NotReady => Ok(Async::NotReady),
+        }
+    }
+}
@@ -1,66 +1,7 @@
-extern crate bytes;
-extern crate futures;
 extern crate tokio_buf;

-use bytes::Buf;
-use futures::Async::*;
-use tokio_buf::{BufStream, SizeHint};
+use tokio_buf::BufStream;

-#[macro_use]
-mod support;
-
-// ===== test `SizeHint` =====
-
-#[test]
-fn size_hint() {
-    let hint = SizeHint::new();
-    assert_eq!(hint.lower(), 0);
-    assert!(hint.upper().is_none());
-
-    let mut hint = SizeHint::new();
-    hint.set_lower(100);
-    assert_eq!(hint.lower(), 100);
-    assert!(hint.upper().is_none());
-
-    let mut hint = SizeHint::new();
-    hint.set_upper(200);
-    assert_eq!(hint.lower(), 0);
-    assert_eq!(hint.upper(), Some(200));
-
-    let mut hint = SizeHint::new();
-    hint.set_lower(100);
-    hint.set_upper(100);
-    assert_eq!(hint.lower(), 100);
-    assert_eq!(hint.upper(), Some(100));
-}
-
-#[test]
-#[should_panic]
-fn size_hint_lower_bigger_than_upper() {
-    let mut hint = SizeHint::new();
-    hint.set_upper(100);
-    hint.set_lower(200);
-}
-
-#[test]
-#[should_panic]
-fn size_hint_upper_less_than_lower() {
-    let mut hint = SizeHint::new();
-    hint.set_lower(200);
-    hint.set_upper(100);
-}
-
-// ===== BufStream impelmentations for misc types =====
-
-#[test]
-fn str_buf_stream() {
-    let mut bs = "hello world".to_string();
-    assert_buf_eq!(bs.poll_buf(), "hello world");
-    assert!(bs.is_empty());
-    assert_none!(bs.poll_buf());
-
-    let mut bs = "hello world";
-    assert_buf_eq!(bs.poll_buf(), "hello world");
-    assert!(bs.is_empty());
-    assert_none!(bs.poll_buf());
-}
+// Ensures that `BufStream` can be a trait object
+#[allow(dead_code)]
+fn obj(_: &mut dyn BufStream<Item = u32, Error = ()>) {}
@@ -1,145 +0,0 @@
-#![cfg(feature = "ext")]
-
-extern crate bytes;
-extern crate futures;
-extern crate tokio_buf;
-
-use bytes::Buf;
-use futures::Async::*;
-use futures::Future;
-use tokio_buf::{BufStream, BufStreamExt};
-
-#[macro_use]
-mod support;
-
-use support::*;
-
-// ===== test `chain()` =====
-
-#[test]
-fn chain() {
-    // Chain one with one
-    //
-    let mut bs = one("hello").chain(one("world"));
-
-    assert_buf_eq!(bs.poll_buf(), "hello");
-    assert_buf_eq!(bs.poll_buf(), "world");
-    assert_none!(bs.poll_buf());
-
-    // Chain multi with multi
-    let mut bs = list(&["foo", "bar"]).chain(list(&["baz", "bok"]));
-
-    assert_buf_eq!(bs.poll_buf(), "foo");
-    assert_buf_eq!(bs.poll_buf(), "bar");
-    assert_buf_eq!(bs.poll_buf(), "baz");
-    assert_buf_eq!(bs.poll_buf(), "bok");
-    assert_none!(bs.poll_buf());
-
-    // Chain includes a not ready call
-    //
-    let mut bs = new_mock(&[Ok(Ready("foo")), Ok(NotReady), Ok(Ready("bar"))]).chain(one("baz"));
-
-    assert_buf_eq!(bs.poll_buf(), "foo");
-    assert_not_ready!(bs.poll_buf());
-    assert_buf_eq!(bs.poll_buf(), "bar");
-    assert_buf_eq!(bs.poll_buf(), "baz");
-    assert_none!(bs.poll_buf());
-}
-
-// ===== Test `collect()` =====
-
-#[test]
-fn collect_vec() {
-    // While unfortunate, this test makes some assumptions on vec's resizing
-    // behavior.
-    //
-    // Collect one
-    //
-    let bs = one("hello world");
-
-    let vec: Vec<u8> = bs.collect().wait().unwrap();
-
-    assert_eq!(vec, b"hello world");
-    assert_eq!(vec.capacity(), 64);
-
-    // Collect one, with size hint
-    //
-    let mut bs = one("hello world");
-    bs.size_hint.set_lower(11);
-
-    let vec: Vec<u8> = bs.collect().wait().unwrap();
-
-    assert_eq!(vec, b"hello world");
-    assert_eq!(vec.capacity(), 64);
-
-    // Collect one, with size hint
-    //
-    let mut bs = one("hello world");
-    bs.size_hint.set_lower(10);
-
-    let vec: Vec<u8> = bs.collect().wait().unwrap();
-
-    assert_eq!(vec, b"hello world");
-    assert_eq!(vec.capacity(), 64);
-
-    // Collect many
-    //
-    let bs = list(&["hello", " ", "world", ", one two three"]);
-
-    let vec: Vec<u8> = bs.collect().wait().unwrap();
-
-    assert_eq!(vec, b"hello world, one two three");
-}
-
-// ===== Test limit() =====
-
-#[test]
-fn limit() {
-    // Not limited
-
-    let res = one("hello world")
-        .limit(100)
-        .collect::<Vec<_>>()
-        .wait()
-        .unwrap();
-
-    assert_eq!(res, b"hello world");
-
-    let res = list(&["hello", " ", "world"])
-        .limit(100)
-        .collect::<Vec<_>>()
-        .wait()
-        .unwrap();
-
-    assert_eq!(res, b"hello world");
-
-    let res = list(&["hello", " ", "world"])
-        .limit(11)
-        .collect::<Vec<_>>()
-        .wait()
-        .unwrap();
-
-    assert_eq!(res, b"hello world");
-
-    // Limited
-
-    let res = one("hello world").limit(5).collect::<Vec<_>>().wait();
-
-    assert!(res.is_err());
-
-    let res = one("hello world").limit(10).collect::<Vec<_>>().wait();
-
-    assert!(res.is_err());
-
-    let mut bs = list(&["hello", " ", "world"]).limit(9);
-
-    assert_buf_eq!(bs.poll_buf(), "hello");
-    assert_buf_eq!(bs.poll_buf(), " ");
-    assert!(bs.poll_buf().is_err());
-
-    let mut bs = list(&["hello", " ", "world"]);
-    bs.size_hint.set_lower(11);
-    let mut bs = bs.limit(9);
-
-    assert!(bs.poll_buf().is_err());
-}
@@ -0,0 +1,43 @@
+#![cfg(feature = "util")]
+
+extern crate bytes;
+extern crate futures;
+extern crate tokio_buf;
+
+use futures::Async::*;
+use tokio_buf::{BufStream, BufStreamExt};
+
+#[macro_use]
+mod support;
+
+use support::*;
+
+#[test]
+fn chain() {
+    // Chain one with one
+    //
+    let mut bs = one("hello").chain(one("world"));
+
+    assert_buf_eq!(bs.poll_buf(), "hello");
+    assert_buf_eq!(bs.poll_buf(), "world");
+    assert_none!(bs.poll_buf());
+
+    // Chain multi with multi
+    let mut bs = list(&["foo", "bar"]).chain(list(&["baz", "bok"]));
+
+    assert_buf_eq!(bs.poll_buf(), "foo");
+    assert_buf_eq!(bs.poll_buf(), "bar");
+    assert_buf_eq!(bs.poll_buf(), "baz");
+    assert_buf_eq!(bs.poll_buf(), "bok");
+    assert_none!(bs.poll_buf());
+
+    // Chain includes a not ready call
+    //
+    let mut bs = new_mock(&[Ok(Ready("foo")), Ok(NotReady), Ok(Ready("bar"))]).chain(one("baz"));
+
+    assert_buf_eq!(bs.poll_buf(), "foo");
+    assert_not_ready!(bs.poll_buf());
+    assert_buf_eq!(bs.poll_buf(), "bar");
+    assert_buf_eq!(bs.poll_buf(), "baz");
+    assert_none!(bs.poll_buf());
+}
@@ -0,0 +1,68 @@
+#![cfg(feature = "util")]
+
+extern crate bytes;
+extern crate futures;
+extern crate tokio_buf;
+
+use bytes::Bytes;
+use futures::Future;
+use tokio_buf::BufStreamExt;
+
+#[macro_use]
+mod support;
+
+use support::*;
+
+macro_rules! test_collect_impl {
+    ($t:ty $(, $capacity:ident)*) => {
+        // While unfortunate, this test makes some assumptions on vec's resizing
+        // behavior.
+        //
+        // Collect one
+        //
+        let bs = one("hello world");
+
+        let vec: $t = bs.collect().wait().unwrap();
+
+        assert_eq!(vec, &b"hello world"[..]);
+        $( assert_eq!(vec.$capacity(), 64); )*
+
+        // Collect one, with size hint
+        //
+        let mut bs = one("hello world");
+        bs.size_hint.set_lower(11);
+
+        let vec: $t = bs.collect().wait().unwrap();
+
+        assert_eq!(vec, &b"hello world"[..]);
+        $( assert_eq!(vec.$capacity(), 64); )*
+
+        // Collect one, with size hint
+        //
+        let mut bs = one("hello world");
+        bs.size_hint.set_lower(10);
+
+        let vec: $t = bs.collect().wait().unwrap();
+
+        assert_eq!(vec, &b"hello world"[..]);
+        $( assert_eq!(vec.$capacity(), 64); )*
+
+        // Collect many
+        //
+        let bs = list(&["hello", " ", "world", ", one two three"]);
+
+        let vec: $t = bs.collect().wait().unwrap();
+
+        assert_eq!(vec, &b"hello world, one two three"[..]);
+    }
+}
+
+#[test]
+fn collect_vec() {
+    test_collect_impl!(Vec<u8>, capacity);
+}
+
+#[test]
+fn collect_bytes() {
+    test_collect_impl!(Bytes);
+}
@@ -0,0 +1,33 @@
+extern crate bytes;
+extern crate futures;
+extern crate tokio_buf;
+
+use futures::Async::*;
+use std::io::Cursor;
+use tokio_buf::{util, BufStream};
+
+#[macro_use]
+mod support;
+
+type Buf = Cursor<&'static [u8]>;
+
+#[test]
+fn empty_iter() {
+    let mut bs = util::iter(Vec::<Buf>::new());
+    assert_none!(bs.poll_buf());
+}
+
+#[test]
+fn full_iter() {
+    let bufs = vec![buf(b"one"), buf(b"two"), buf(b"three")];
+
+    let mut bs = util::iter(bufs);
+    assert_buf_eq!(bs.poll_buf(), "one");
+    assert_buf_eq!(bs.poll_buf(), "two");
+    assert_buf_eq!(bs.poll_buf(), "three");
+    assert_none!(bs.poll_buf());
+}
+
+fn buf(data: &'static [u8]) -> Buf {
+    Cursor::new(data)
+}
@@ -0,0 +1,65 @@
+#![cfg(feature = "util")]
+
+extern crate bytes;
+extern crate futures;
+extern crate tokio_buf;
+
+use futures::Async::*;
+use futures::Future;
+use tokio_buf::{BufStream, BufStreamExt};
+
+#[macro_use]
+mod support;
+
+use support::*;
+
+#[test]
+fn limit() {
+    // Not limited
+
+    let res = one("hello world")
+        .limit(100)
+        .collect::<Vec<_>>()
+        .wait()
+        .unwrap();
+
+    assert_eq!(res, b"hello world");
+
+    let res = list(&["hello", " ", "world"])
+        .limit(100)
+        .collect::<Vec<_>>()
+        .wait()
+        .unwrap();
+
+    assert_eq!(res, b"hello world");
+
+    let res = list(&["hello", " ", "world"])
+        .limit(11)
+        .collect::<Vec<_>>()
+        .wait()
+        .unwrap();
+
+    assert_eq!(res, b"hello world");
+
+    // Limited
+
+    let res = one("hello world").limit(5).collect::<Vec<_>>().wait();
+
+    assert!(res.is_err());
+
+    let res = one("hello world").limit(10).collect::<Vec<_>>().wait();
+
+    assert!(res.is_err());
+
+    let mut bs = list(&["hello", " ", "world"]).limit(9);
+
+    assert_buf_eq!(bs.poll_buf(), "hello");
+    assert_buf_eq!(bs.poll_buf(), " ");
+    assert!(bs.poll_buf().is_err());
+
+    let mut bs = list(&["hello", " ", "world"]);
+    bs.size_hint.set_lower(11);
+    let mut bs = bs.limit(9);
+
+    assert!(bs.poll_buf().is_err());
+}
@@ -0,0 +1,42 @@
+extern crate tokio_buf;
+
+use tokio_buf::SizeHint;
+
+#[test]
+fn size_hint() {
+    let hint = SizeHint::new();
+    assert_eq!(hint.lower(), 0);
+    assert!(hint.upper().is_none());
+
+    let mut hint = SizeHint::new();
+    hint.set_lower(100);
+    assert_eq!(hint.lower(), 100);
+    assert!(hint.upper().is_none());
+
+    let mut hint = SizeHint::new();
+    hint.set_upper(200);
+    assert_eq!(hint.lower(), 0);
+    assert_eq!(hint.upper(), Some(200));
+
+    let mut hint = SizeHint::new();
+    hint.set_lower(100);
+    hint.set_upper(100);
+    assert_eq!(hint.lower(), 100);
+    assert_eq!(hint.upper(), Some(100));
+}
+
+#[test]
+#[should_panic]
+fn size_hint_lower_bigger_than_upper() {
+    let mut hint = SizeHint::new();
+    hint.set_upper(100);
+    hint.set_lower(200);
+}
+
+#[test]
+#[should_panic]
+fn size_hint_upper_less_than_lower() {
+    let mut hint = SizeHint::new();
+    hint.set_lower(200);
+    hint.set_upper(100);
+}
@@ -0,0 +1,49 @@
+extern crate bytes;
+extern crate futures;
+extern crate tokio_buf;
+extern crate tokio_mock_task;
+
+use futures::sync::mpsc;
+use futures::Async::*;
+use std::io::Cursor;
+use tokio_buf::{util, BufStream};
+use tokio_mock_task::MockTask;
+
+#[macro_use]
+mod support;
+
+type Buf = Cursor<&'static [u8]>;
+
+#[test]
+fn empty_stream() {
+    let (_, rx) = mpsc::unbounded::<Buf>();
+    let mut bs = util::stream(rx);
+    assert_none!(bs.poll_buf());
+}
+
+#[test]
+fn full_stream() {
+    let (tx, rx) = mpsc::unbounded();
+    let mut bs = util::stream(rx);
+    let mut task = MockTask::new();
+
+    tx.unbounded_send(buf(b"one")).unwrap();
+
+    assert_buf_eq!(bs.poll_buf(), "one");
+    task.enter(|| assert_not_ready!(bs.poll_buf()));
+
+    tx.unbounded_send(buf(b"two")).unwrap();
+
+    assert!(task.is_notified());
+    assert_buf_eq!(bs.poll_buf(), "two");
+    task.enter(|| assert_not_ready!(bs.poll_buf()));
+
+    drop(tx);
+
+    assert!(task.is_notified());
+    assert_none!(bs.poll_buf());
+}
+
+fn buf(data: &'static [u8]) -> Buf {
+    Cursor::new(data)
+}
@@ -0,0 +1,38 @@
+extern crate bytes;
+extern crate futures;
+extern crate tokio_buf;
+
+use futures::Async::*;
+use std::fmt;
+use tokio_buf::BufStream;
+
+#[macro_use]
+mod support;
+
+fn test_hello_world<B>(mut bs: B)
+where
+    B: BufStream + fmt::Debug,
+    B::Item: fmt::Debug,
+    B::Error: fmt::Debug,
+{
+    let hint = bs.size_hint();
+    assert_eq!(hint.lower(), 11);
+    assert_eq!(hint.upper(), Some(11));
+
+    assert_buf_eq!(bs.poll_buf(), "hello world");
+
+    let hint = bs.size_hint();
+    assert_eq!(hint.lower(), 0);
+    assert_eq!(hint.upper(), Some(0));
+    assert_none!(bs.poll_buf());
+}
+
+#[test]
+fn string() {
+    test_hello_world("hello world".to_string());
+}
+
+#[test]
+fn str() {
+    test_hello_world("hello world");
+}
@@ -14,6 +14,7 @@ use std::io::Cursor;

 macro_rules! assert_buf_eq {
    ($actual:expr, $expect:expr) => {{
+        use bytes::Buf;
        match $actual {
            Ok(Ready(Some(val))) => {
                assert_eq!(val.remaining(), val.bytes().len());
@@ -1,9 +1,11 @@
 [package]
 name = "tokio-codec"
-
 # When releasing to crates.io:
+# - Remove path dependencies
 # - Update html_root_url.
-# - Update doc URL.
+# - Update doc url
+#   - Cargo.toml
+#   - README.md
 # - Update CHANGELOG.md.
 # - Create "v0.1.x" git tag.
 version = "0.1.1"
@@ -1,7 +1,7 @@
 [package]
 name = "tokio-current-thread"
-
 # When releasing to crates.io:
+# - Remove path dependencies
 # - Update html_root_url.
 # - Update doc url
 #   - Cargo.toml
@@ -64,7 +64,7 @@ pub struct CurrentThread<P: Park = ParkThread> {
    spawn_handle: Handle,

    /// Receiver for futures spawned from other threads
-    spawn_receiver: mpsc::Receiver<Box<Future<Item = (), Error = ()> + Send + 'static>>,
+    spawn_receiver: mpsc::Receiver<Box<dyn Future<Item = (), Error = ()> + Send + 'static>>,

    /// The thread-local ID assigned to this executor.
    id: u64,
@@ -186,11 +186,15 @@ struct Borrow<'a, U: 'a> {
 }

 trait SpawnLocal {
-    fn spawn_local(&mut self, future: Box<Future<Item = (), Error = ()>>, already_counted: bool);
+    fn spawn_local(
+        &mut self,
+        future: Box<dyn Future<Item = (), Error = ()>>,
+        already_counted: bool,
+    );
 }

 struct CurrentRunner {
-    spawn: Cell<Option<*mut SpawnLocal>>,
+    spawn: Cell<Option<*mut dyn SpawnLocal>>,
    id: Cell<Option<u64>>,
 }

@@ -424,7 +428,7 @@ impl<P: Park> Drop for CurrentThread<P> {
 impl tokio_executor::Executor for CurrentThread {
    fn spawn(
        &mut self,
-        future: Box<Future<Item = (), Error = ()> + Send>,
+        future: Box<dyn Future<Item = (), Error = ()> + Send>,
    ) -> Result<(), SpawnError> {
        self.borrow().spawn_local(future, false);
        Ok(())
@@ -629,7 +633,7 @@ impl<'a, P: Park> fmt::Debug for Entered<'a, P> {
 /// Handle to spawn a future on the corresponding `CurrentThread` instance
 #[derive(Clone)]
 pub struct Handle {
-    sender: mpsc::Sender<Box<Future<Item = (), Error = ()> + Send + 'static>>,
+    sender: mpsc::Sender<Box<dyn Future<Item = (), Error = ()> + Send + 'static>>,
    num_futures: Arc<atomic::AtomicUsize>,
    shut_down: Cell<bool>,
    notify: executor::NotifyHandle,
@@ -731,7 +735,7 @@ impl TaskExecutor {
    /// Spawn a future onto the current `CurrentThread` instance.
    pub fn spawn_local(
        &mut self,
-        future: Box<Future<Item = (), Error = ()>>,
+        future: Box<dyn Future<Item = (), Error = ()>>,
    ) -> Result<(), SpawnError> {
        CURRENT.with(|current| match current.spawn.get() {
            Some(spawn) => {
@@ -746,7 +750,7 @@ impl TaskExecutor {
 impl tokio_executor::Executor for TaskExecutor {
    fn spawn(
        &mut self,
-        future: Box<Future<Item = (), Error = ()> + Send>,
+        future: Box<dyn Future<Item = (), Error = ()> + Send>,
    ) -> Result<(), SpawnError> {
        self.spawn_local(future)
    }
@@ -791,7 +795,11 @@ impl<'a, U: Unpark> Borrow<'a, U> {
 }

 impl<'a, U: Unpark> SpawnLocal for Borrow<'a, U> {
-    fn spawn_local(&mut self, future: Box<Future<Item = (), Error = ()>>, already_counted: bool) {
+    fn spawn_local(
+        &mut self,
+        future: Box<dyn Future<Item = (), Error = ()>>,
+        already_counted: bool,
+    ) {
        if !already_counted {
            // NOTE: we have a borrow of the Runtime, so we know that it isn't shut down.
            // NOTE: += 2 since LSB is the shutdown bit
@@ -804,7 +812,7 @@ impl<'a, U: Unpark> SpawnLocal for Borrow<'a, U> {
 // ===== impl CurrentRunner =====

 impl CurrentRunner {
-    fn set_spawn<F, R>(&self, spawn: &mut SpawnLocal, f: F) -> R
+    fn set_spawn<F, R>(&self, spawn: &mut dyn SpawnLocal, f: F) -> R
    where
        F: FnOnce() -> R,
    {
@@ -819,14 +827,14 @@ impl CurrentRunner {

        let _reset = Reset(self);

-        let spawn = unsafe { hide_lt(spawn as *mut SpawnLocal) };
+        let spawn = unsafe { hide_lt(spawn as *mut dyn SpawnLocal) };
        self.spawn.set(Some(spawn));

        f()
    }
 }

-unsafe fn hide_lt<'a>(p: *mut (SpawnLocal + 'a)) -> *mut (SpawnLocal + 'static) {
+unsafe fn hide_lt<'a>(p: *mut (dyn SpawnLocal + 'a)) -> *mut (dyn SpawnLocal + 'static) {
    use std::mem;
    mem::transmute(p)
 }
@@ -125,7 +125,7 @@ enum Dequeue<U> {
 }

 /// Wraps a spawned boxed future
-struct Task(Spawn<Box<Future<Item = (), Error = ()>>>);
+struct Task(Spawn<Box<dyn Future<Item = (), Error = ()>>>);

 /// A task that is scheduled. `turn` must be called
 pub struct Scheduled<'a, U: 'a> {
@@ -171,7 +171,7 @@ where
        self.inner.clone().into()
    }

-    pub fn schedule(&mut self, item: Box<Future<Item = (), Error = ()>>) {
+    pub fn schedule(&mut self, item: Box<dyn Future<Item = (), Error = ()>>) {
        // Get the current scheduler tick
        let tick_num = self.inner.tick_num.load(SeqCst);

@@ -359,7 +359,7 @@ impl<'a, U: Unpark> Scheduled<'a, U> {
 }

 impl Task {
-    pub fn new(future: Box<Future<Item = (), Error = ()> + 'static>) -> Self {
+    pub fn new(future: Box<dyn Future<Item = (), Error = ()> + 'static>) -> Self {
        Task(executor::spawn(future))
    }
 }
@@ -687,8 +687,8 @@ unsafe impl<U: Unpark> UnsafeNotify for ArcNode<U> {
    }
 }

-unsafe fn hide_lt<U: Unpark>(p: *mut ArcNode<U>) -> *mut UnsafeNotify {
-    mem::transmute(p as *mut UnsafeNotify)
+unsafe fn hide_lt<U: Unpark>(p: *mut ArcNode<U>) -> *mut dyn UnsafeNotify {
+    mem::transmute(p as *mut dyn UnsafeNotify)
 }

 impl<U: Unpark> Node<U> {
@@ -22,7 +22,7 @@ use futures::sync::oneshot;

 mod from_block_on_all {
    use super::*;
-    fn test<F: Fn(Box<Future<Item = (), Error = ()>>) + 'static>(spawn: F) {
+    fn test<F: Fn(Box<dyn Future<Item = (), Error = ()>>) + 'static>(spawn: F) {
        let cnt = Rc::new(Cell::new(0));
        let c = cnt.clone();

@@ -102,7 +102,7 @@ fn spawn_many() {
 mod does_not_set_global_executor_by_default {
    use super::*;

-    fn test<F: Fn(Box<Future<Item = (), Error = ()> + Send>) -> Result<(), E> + 'static, E>(
+    fn test<F: Fn(Box<dyn Future<Item = (), Error = ()> + Send>) -> Result<(), E> + 'static, E>(
        spawn: F,
    ) {
        block_on_all(lazy(|| {
@@ -127,7 +127,7 @@ mod does_not_set_global_executor_by_default {
 mod from_block_on_future {
    use super::*;

-    fn test<F: Fn(Box<Future<Item = (), Error = ()>>)>(spawn: F) {
+    fn test<F: Fn(Box<dyn Future<Item = (), Error = ()>>)>(spawn: F) {
        let cnt = Rc::new(Cell::new(0));

        let mut tokio_current_thread = CurrentThread::new();
@@ -181,8 +181,8 @@ mod outstanding_tasks_are_dropped_when_executor_is_dropped {

    fn test<F, G>(spawn: F, dotspawn: G)
    where
-        F: Fn(Box<Future<Item = (), Error = ()>>) + 'static,
-        G: Fn(&mut CurrentThread, Box<Future<Item = (), Error = ()>>),
+        F: Fn(Box<dyn Future<Item = (), Error = ()>>) + 'static,
+        G: Fn(&mut CurrentThread, Box<dyn Future<Item = (), Error = ()>>),
    {
        let mut rc = Rc::new(());

@@ -383,8 +383,8 @@ mod and_turn {

    fn test<F, G>(spawn: F, dotspawn: G)
    where
-        F: Fn(Box<Future<Item = (), Error = ()>>) + 'static,
-        G: Fn(&mut CurrentThread, Box<Future<Item = (), Error = ()>>),
+        F: Fn(Box<dyn Future<Item = (), Error = ()>>) + 'static,
+        G: Fn(&mut CurrentThread, Box<dyn Future<Item = (), Error = ()>>),
    {
        let cnt = Rc::new(Cell::new(0));
        let c = cnt.clone();
@@ -445,7 +445,6 @@ mod and_turn {
            },
        );
    }
-
 }

 mod in_drop {
@@ -459,7 +458,7 @@ mod in_drop {
    }

    struct MyFuture {
-        _data: Box<Any>,
+        _data: Box<dyn Any>,
    }

    impl Future for MyFuture {
@@ -473,8 +472,8 @@ mod in_drop {

    fn test<F, G>(spawn: F, dotspawn: G)
    where
-        F: Fn(Box<Future<Item = (), Error = ()>>) + 'static,
-        G: Fn(&mut CurrentThread, Box<Future<Item = (), Error = ()>>),
+        F: Fn(Box<dyn Future<Item = (), Error = ()>>) + 'static,
+        G: Fn(&mut CurrentThread, Box<dyn Future<Item = (), Error = ()>>),
    {
        let mut tokio_current_thread = CurrentThread::new();

@@ -520,7 +519,6 @@ mod in_drop {
            },
        );
    }
-
 }

 #[test]
@@ -1,3 +1,8 @@
+# 0.1.8 (June 2, 2019)
+
+### Added
+- Add `executor::exit` to allow other executors inside `threadpool::blocking` (#1155).
+
 # 0.1.7 (March 22, 2019)

 ### Added
@@ -1,14 +1,14 @@
 [package]
 name = "tokio-executor"
-
 # When releasing to crates.io:
+# - Remove path dependencies
 # - Update html_root_url.
-# - Update CHANGELOG.md.
-# - Update doc URL.
+# - Update doc url
 #   - Cargo.toml
 #   - README.md
+# - Update CHANGELOG.md.
 # - Create "v0.1.x" git tag.
-version = "0.1.7"
+version = "0.1.8"
 documentation = "https://docs.rs/tokio-executor/0.1.7/tokio_executor"
 repository = "https://github.com/tokio-rs/tokio"
 homepage = "https://github.com/tokio-rs/tokio"
@@ -2,7 +2,7 @@

 Task execution related traits and utilities.

-[Documentation](https://docs.rs/tokio-executor/0.1.7/tokio_executor)
+[Documentation](https://docs.rs/tokio-executor/0.1.8/tokio_executor)

 ## Overview

@@ -31,10 +31,10 @@ executor, including:

 * [`Park`] abstracts over blocking and unblocking the current thread.

-[`Executor`]: https://docs.rs/tokio-executor/0.1.7/tokio_executor/trait.Executor.html
-[`enter`]: https://docs.rs/tokio-executor/0.1.7/tokio_executor/fn.enter.html
-[`DefaultExecutor`]: https://docs.rs/tokio-executor/0.1.7/tokio_executor/struct.DefaultExecutor.html
-[`Park`]: https://docs.rs/tokio-executor/0.1.7/tokio_executor/park/trait.Park.html
+[`Executor`]: https://docs.rs/tokio-executor/0.1.8/tokio_executor/trait.Executor.html
+[`enter`]: https://docs.rs/tokio-executor/0.1.8/tokio_executor/fn.enter.html
+[`DefaultExecutor`]: https://docs.rs/tokio-executor/0.1.8/tokio_executor/struct.DefaultExecutor.html
+[`Park`]: https://docs.rs/tokio-executor/0.1.8/tokio_executor/park/trait.Park.html

 ## License

@@ -11,7 +11,7 @@ thread_local!(static ENTERED: Cell<bool> = Cell::new(false));
 ///
 /// For more details, see [`enter` documentation](fn.enter.html)
 pub struct Enter {
-    on_exit: Vec<Box<Callback>>,
+    on_exit: Vec<Box<dyn Callback>>,
    permanent: bool,
 }

@@ -67,6 +67,42 @@ pub fn enter() -> Result<Enter, EnterError> {
    })
 }

+// Forces the current "entered" state to be cleared while the closure
+// is executed.
+//
+// # Warning
+//
+// This is hidden for a reason. Do not use without fully understanding
+// executors. Misuing can easily cause your program to deadlock.
+#[doc(hidden)]
+pub fn exit<F: FnOnce() -> R, R>(f: F) -> R {
+    // Reset in case the closure panics
+    struct Reset;
+    impl Drop for Reset {
+        fn drop(&mut self) {
+            ENTERED.with(|c| {
+                c.set(true);
+            });
+        }
+    }
+
+    ENTERED.with(|c| {
+        debug_assert!(c.get());
+        c.set(false);
+    });
+
+    let reset = Reset;
+    let ret = f();
+    ::std::mem::forget(reset);
+
+    ENTERED.with(|c| {
+        assert!(!c.get(), "closure claimed permanent executor");
+        c.set(true);
+    });
+
+    ret
+}
+
 impl Enter {
    /// Register a callback to be invoked if and when the thread
    /// ceased to act as an executor.
@@ -94,7 +94,7 @@ pub trait Executor {
    /// ```
    fn spawn(
        &mut self,
-        future: Box<Future<Item = (), Error = ()> + Send>,
+        future: Box<dyn Future<Item = (), Error = ()> + Send>,
    ) -> Result<(), SpawnError>;

    /// Provides a best effort **hint** to whether or not `spawn` will succeed.
@@ -140,7 +140,7 @@ pub trait Executor {
 impl<E: Executor + ?Sized> Executor for Box<E> {
    fn spawn(
        &mut self,
-        future: Box<Future<Item = (), Error = ()> + Send>,
+        future: Box<dyn Future<Item = (), Error = ()> + Send>,
    ) -> Result<(), SpawnError> {
        (**self).spawn(future)
    }
@@ -37,7 +37,7 @@ impl DefaultExecutor {
    }

    #[inline]
-    fn with_current<F: FnOnce(&mut Executor) -> R, R>(f: F) -> Option<R> {
+    fn with_current<F: FnOnce(&mut dyn Executor) -> R, R>(f: F) -> Option<R> {
        EXECUTOR.with(
            |current_executor| match current_executor.replace(State::Active) {
                State::Ready(executor_ptr) => {
@@ -57,7 +57,7 @@ enum State {
    // default executor not defined
    Empty,
    // default executor is defined and ready to be used
-    Ready(*mut Executor),
+    Ready(*mut dyn Executor),
    // default executor is currently active (used to detect recursive calls)
    Active,
 }
@@ -72,7 +72,7 @@ thread_local! {
 impl super::Executor for DefaultExecutor {
    fn spawn(
        &mut self,
-        future: Box<Future<Item = (), Error = ()> + Send>,
+        future: Box<dyn Future<Item = (), Error = ()> + Send>,
    ) -> Result<(), SpawnError> {
        DefaultExecutor::with_current(|executor| executor.spawn(future))
            .unwrap_or_else(|| Err(SpawnError::shutdown()))
@@ -210,7 +210,7 @@ where
    })
 }

-unsafe fn hide_lt<'a>(p: *mut (Executor + 'a)) -> *mut (Executor + 'static) {
+unsafe fn hide_lt<'a>(p: *mut (dyn Executor + 'a)) -> *mut (dyn Executor + 'static) {
    use std::mem;
    mem::transmute(p)
 }
@@ -1,5 +1,5 @@
 #![deny(missing_docs, missing_debug_implementations, warnings)]
-#![doc(html_root_url = "https://docs.rs/tokio-executor/0.1.7")]
+#![doc(html_root_url = "https://docs.rs/tokio-executor/0.1.8")]

 //! Task execution related traits and utilities.
 //!
@@ -61,7 +61,7 @@ mod global;
 pub mod park;
 mod typed;

-pub use enter::{enter, Enter, EnterError};
+pub use enter::{enter, exit, Enter, EnterError};
 pub use error::SpawnError;
 pub use executor::Executor;
 pub use global::{spawn, with_default, DefaultExecutor};
@@ -128,13 +128,13 @@ pub trait Unpark: Sync + Send + 'static {
    fn unpark(&self);
 }

-impl Unpark for Box<Unpark> {
+impl Unpark for Box<dyn Unpark> {
    fn unpark(&self) {
        (**self).unpark()
    }
 }

-impl Unpark for Arc<Unpark> {
+impl Unpark for Arc<dyn Unpark> {
    fn unpark(&self) {
        (**self).unpark()
    }
@@ -10,7 +10,7 @@ mod out_of_executor_context {

    fn test<F, E>(spawn: F)
    where
-        F: Fn(Box<Future<Item = (), Error = ()> + Send>) -> Result<(), E>,
+        F: Fn(Box<dyn Future<Item = (), Error = ()> + Send>) -> Result<(), E>,
    {
        let res = spawn(Box::new(lazy(|| Ok(()))));
        assert!(res.is_err());
@@ -1,12 +1,12 @@
 [package]
 name = "tokio-fs"
-
 # When releasing to crates.io:
+# - Remove path dependencies
 # - Update html_root_url.
-# - Update CHANGELOG.md.
-# - Update doc URL.
+# - Update doc url
 #   - Cargo.toml
 #   - README.md
+# - Update CHANGELOG.md.
 # - Create "v0.1.x" git tag.
 version = "0.1.6"
 authors = ["Carl Lerche <[email protected]>"]
@@ -27,9 +27,8 @@ tokio-threadpool = "0.1.3"
 tokio-io = "0.1.6"

 [dev-dependencies]
-rand = "0.6"
-tempfile = "3"
-tempdir = "0.3"
+rand = "0.7"
+tempfile = "~3.1.0"
 tokio-io = "0.1.6"
 tokio-codec = "0.1.0"
 tokio = "0.1.7"
@@ -14,7 +14,7 @@ use futures::{Future, Sink, Stream};

 use std::io;

-pub fn main() -> Result<(), Box<std::error::Error>> {
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
    let pool = Builder::new().pool_size(1).build();

    pool.spawn({
@@ -1,18 +1,18 @@
 extern crate futures;
-extern crate tempdir;
+extern crate tempfile;
 extern crate tokio_fs;

 use futures::{Future, Stream};
 use std::fs;
 use std::sync::{Arc, Mutex};
-use tempdir::TempDir;
+use tempfile::tempdir;
 use tokio_fs::*;

 mod pool;

 #[test]
 fn create() {
-    let base_dir = TempDir::new("base").unwrap();
+    let base_dir = tempdir().unwrap();
    let new_dir = base_dir.path().join("foo");

    pool::run({ create_dir(new_dir.clone()) });
@@ -22,7 +22,7 @@ fn create() {

 #[test]
 fn create_all() {
-    let base_dir = TempDir::new("base").unwrap();
+    let base_dir = tempdir().unwrap();
    let new_dir = base_dir.path().join("foo").join("bar");

    pool::run({ create_dir_all(new_dir.clone()) });
@@ -32,7 +32,7 @@ fn create_all() {

 #[test]
 fn remove() {
-    let base_dir = TempDir::new("base").unwrap();
+    let base_dir = tempdir().unwrap();
    let new_dir = base_dir.path().join("foo");

    fs::create_dir(new_dir.clone()).unwrap();
@@ -44,7 +44,7 @@ fn remove() {

 #[test]
 fn read() {
-    let base_dir = TempDir::new("base").unwrap();
+    let base_dir = tempdir().unwrap();

    let p = base_dir.path();
    fs::create_dir(p.join("aa")).unwrap();
@@ -1,19 +1,19 @@
 extern crate futures;
-extern crate tempdir;
+extern crate tempfile;
 extern crate tokio_fs;

 use futures::Future;
 use std::fs;
 use std::io::prelude::*;
 use std::io::BufReader;
-use tempdir::TempDir;
+use tempfile::tempdir;
 use tokio_fs::*;

 mod pool;

 #[test]
 fn test_hard_link() {
-    let dir = TempDir::new("base").unwrap();
+    let dir = tempdir().unwrap();
    let src = dir.path().join("src.txt");
    let dst = dir.path().join("dst.txt");

@@ -38,7 +38,7 @@ fn test_hard_link() {
 #[cfg(unix)]
 #[test]
 fn test_symlink() {
-    let dir = TempDir::new("base").unwrap();
+    let dir = tempdir().unwrap();
    let src = dir.path().join("src.txt");
    let dst = dir.path().join("dst.txt");

@@ -1,16 +1,16 @@
 [package]
-name = "tokio-async-await"
+name = "tokio-futures"

 # When releasing to crates.io:
 # - Update html_root_url.
-version = "0.1.6"
+version = "0.1.0"
 authors = ["Carl Lerche <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/tokio-rs/tokio"
 homepage = "https://tokio.rs"
-documentation = "https://docs.rs/tokio-async-await/0.1.6"
+documentation = "https://docs.rs/tokio-futures/0.1.0"
 description = """
-Experimental async/await support for Tokio
+Experimental std::future::Future and async/await support for Tokio
 """
 categories = ["asynchronous"]

@@ -25,5 +25,5 @@ tokio-io = "0.1.7"

 [dev-dependencies]
 bytes = "0.4.9"
-tokio = "0.1.8"
 hyper = "0.12.8"
+tokio = { version = "0.1.8", path = "../tokio" }
@@ -9,7 +9,7 @@ guarantees. You are living on the edge here.**
 ## Usage

 To use this crate, you need to start with a Rust 2018 edition crate, with rustc
-1.34.0-nightly or later.
+1.35.0-nightly or later.

 Add this to your `Cargo.toml`:

@@ -25,9 +25,9 @@ Then, get started. In your application, add:

 ```rust
 // The nightly features that are commonly needed with async / await
-#![feature(await_macro, async_await, futures_api)]
+#![feature(await_macro, async_await)]

-// This pulls in the `tokio-async-await` crate. While Rust 2018 doesn't require
+// This pulls in the `tokio-futures` crate. While Rust 2018 doesn't require
 // `extern crate`, we need to pull in the macros.
 #[macro_use]
 extern crate tokio;
@@ -1,22 +1,24 @@
+//! Converts a `std::future::Future` into an 0.1 `Future.
+
 use futures::{Future, Poll};

 use std::future::Future as StdFuture;
 use std::pin::Pin;
 use std::ptr;
-use std::task::{Poll as StdPoll, RawWaker, RawWakerVTable, Waker};
+use std::task::{Context, Poll as StdPoll, RawWaker, RawWakerVTable, Waker};

-/// Convert an 0.3 `Future` to an 0.1 `Future`.
+/// Converts a `std::future::Future` into an 0.1 `Future.
 #[derive(Debug)]
 pub struct Compat<T>(Pin<Box<T>>);

 impl<T> Compat<T> {
    /// Create a new `Compat` backed by `future`.
-    pub fn new(future: T) -> Compat<T> {
+    pub(crate) fn new(future: T) -> Compat<T> {
        Compat(Box::pin(future))
    }
 }

-/// Convert a value into one that can be used with `await!`.
+#[doc(hidden)]
 pub trait IntoAwaitable {
    type Awaitable;

@@ -45,8 +47,9 @@ where
        use futures::Async::*;

        let waker = noop_waker();
+        let mut context = Context::from_waker(&waker);

-        let res = self.0.as_mut().poll(&waker);
+        let res = self.0.as_mut().poll(&mut context);

        match res {
            StdPoll::Ready(Ok(val)) => Ok(Ready(val)),
@@ -63,7 +66,7 @@ fn noop_raw_waker() -> RawWaker {
 }

 fn noop_waker() -> Waker {
-    unsafe { Waker::new_unchecked(noop_raw_waker()) }
+    unsafe { Waker::from_raw(noop_raw_waker()) }
 }

 unsafe fn clone_raw(_data: *const ()) -> RawWaker {
@@ -73,11 +76,11 @@ unsafe fn clone_raw(_data: *const ()) -> RawWaker {
 unsafe fn drop_raw(_data: *const ()) {}

 unsafe fn wake(_data: *const ()) {
-    unimplemented!("async-await-preview currently only supports futures 0.1. Use the compatibility layer of futures 0.3 instead, if you want to use futures 0.3.");
+    unimplemented!(
+        "async-await-preview currently only supports futures 0.1. Use \
+         the compatibility layer of futures 0.3 instead, if you want \
+         to use futures 0.3."
+    );
 }

-const NOOP_WAKER_VTABLE: RawWakerVTable = RawWakerVTable {
-    clone: clone_raw,
-    drop: drop_raw,
-    wake,
-};
+const NOOP_WAKER_VTABLE: RawWakerVTable = RawWakerVTable::new(clone_raw, wake, wake, drop_raw);
@@ -1,10 +1,12 @@
+//! Converts an 0.1 `Future` into a `std::future::Future`.
+//!
 use futures::{Async, Future};

 use std::future::Future as StdFuture;
 use std::pin::Pin;
-use std::task::{Poll as StdPoll, Waker};
+use std::task::{Context, Poll as StdPoll};

-/// Converts an 0.1 `Future` into an 0.3 `Future`.
+/// Converts an 0.1 `Future` into a `std::future::Future`.
 #[derive(Debug)]
 pub struct Compat<T>(T);

@@ -31,7 +33,7 @@ pub(crate) fn convert_poll_stream<T, E>(
    }
 }

-/// Convert a value into one that can be used with `await!`.
+#[doc(hidden)]
 pub trait IntoAwaitable {
    type Awaitable;

@@ -53,7 +55,7 @@ where
 {
    type Output = Result<T::Item, T::Error>;

-    fn poll(mut self: Pin<&mut Self>, _waker: &Waker) -> StdPoll<Self::Output> {
+    fn poll(mut self: Pin<&mut Self>, _context: &mut Context) -> StdPoll<Self::Output> {
        use futures::Async::{NotReady, Ready};

        // TODO: wire in cx
@@ -0,0 +1,42 @@
+//! Compatibility layer between futures 0.1 and `std`.
+
+pub mod backward;
+pub mod forward;
+
+/// Convert a `std::future::Future` yielding `Result` into an 0.1 `Future`.
+pub fn into_01<T, Item, Error>(future: T) -> backward::Compat<T>
+where
+    T: std::future::Future<Output = Result<Item, Error>>,
+{
+    backward::Compat::new(future)
+}
+
+/// Convert a `std::future::Future` into an 0.1 `Future` with unit error.
+pub fn infallible_into_01<T>(future: T) -> impl futures::Future<Item = T::Output, Error = ()>
+where
+    T: std::future::Future,
+{
+    use std::pin::Pin;
+    use std::task::{Context, Poll};
+
+    pub struct Map<T>(T);
+
+    impl<T> Map<T> {
+        fn future<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut T> {
+            unsafe { Pin::map_unchecked_mut(self, |x| &mut x.0) }
+        }
+    }
+
+    impl<T: std::future::Future> std::future::Future for Map<T> {
+        type Output = Result<T::Output, ()>;
+
+        fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+            match self.future().poll(cx) {
+                Poll::Ready(v) => Poll::Ready(Ok(v)),
+                Poll::Pending => Poll::Pending,
+            }
+        }
+    }
+
+    into_01(Map(future))
+}
@@ -3,7 +3,7 @@ use tokio_io::AsyncWrite;
 use std::future::Future;
 use std::io;
 use std::pin::Pin;
-use std::task::{Poll, Waker};
+use std::task::{Context, Poll};

 /// A future used to fully flush an I/O object.
 #[derive(Debug)]
@@ -23,7 +23,7 @@ impl<'a, T: AsyncWrite + ?Sized> Flush<'a, T> {
 impl<'a, T: AsyncWrite + ?Sized> Future for Flush<'a, T> {
    type Output = io::Result<()>;

-    fn poll(mut self: Pin<&mut Self>, _wx: &Waker) -> Poll<Self::Output> {
+    fn poll(mut self: Pin<&mut Self>, _context: &mut Context) -> Poll<Self::Output> {
        use crate::compat::forward::convert_poll;
        convert_poll(self.writer.poll_flush())
    }
@@ -24,8 +24,8 @@ pub trait AsyncReadExt: AsyncRead {
    ///
    /// # Examples
    ///
-    /// ```
-    /// #![feature(async_await, await_macro, futures_api)]
+    /// ```edition2018
+    /// #![feature(async_await, await_macro)]
    /// tokio::run_async(async {
    /// // The extension trait can also be imported with
    /// // `use tokio::prelude::*`.
@@ -58,8 +58,8 @@ pub trait AsyncReadExt: AsyncRead {
    ///
    /// # Examples
    ///
-    /// ```
-    /// #![feature(async_await, await_macro, futures_api)]
+    /// ```edition2018
+    /// #![feature(async_await, await_macro)]
    /// tokio::run_async(async {
    /// // The extension trait can also be imported with
    /// // `use tokio::prelude::*`.
@@ -77,8 +77,8 @@ pub trait AsyncReadExt: AsyncRead {
    ///
    /// ## EOF is hit before `buf` is filled
    ///
-    /// ```
-    /// #![feature(async_await, await_macro, futures_api)]
+    /// ```edition2018
+    /// #![feature(async_await, await_macro)]
    /// tokio::run_async(async {
    /// // The extension trait can also be imported with
    /// // `use tokio::prelude::*`.
@@ -109,8 +109,8 @@ pub trait AsyncWriteExt: AsyncWrite {
    ///
    /// # Examples
    ///
-    /// ```
-    /// #![feature(async_await, await_macro, futures_api)]
+    /// ```edition2018
+    /// #![feature(async_await, await_macro)]
    /// tokio::run_async(async {
    /// // The extension trait can also be imported with
    /// // `use tokio::prelude::*`.
@@ -138,8 +138,8 @@ pub trait AsyncWriteExt: AsyncWrite {
    ///
    /// # Examples
    ///
-    /// ```
-    /// #![feature(async_await, await_macro, futures_api)]
+    /// ```edition2018
+    /// #![feature(async_await, await_macro)]
    /// tokio::run_async(async {
    /// // The extension trait can also be imported with
    /// // `use tokio::prelude::*`.
@@ -162,8 +162,8 @@ pub trait AsyncWriteExt: AsyncWrite {
    ///
    /// # Examples
    ///
-    /// ```
-    /// #![feature(async_await, await_macro, futures_api)]
+    /// ```edition2018
+    /// #![feature(async_await, await_macro)]
    /// tokio::run_async(async {
    /// // The extension trait can also be imported with
    /// // `use tokio::prelude::*`.
@@ -25,7 +25,7 @@ impl<'a, T: AsyncRead + ?Sized> Read<'a, T> {
 impl<'a, T: AsyncRead + ?Sized> Future for Read<'a, T> {
    type Output = io::Result<usize>;

-    fn poll(mut self: Pin<&mut Self>, _waker: &task::Waker) -> Poll<Self::Output> {
+    fn poll(mut self: Pin<&mut Self>, _context: &mut task::Context) -> Poll<Self::Output> {
        use crate::compat::forward::convert_poll;

        let this = &mut *self;
@@ -30,7 +30,7 @@ fn eof() -> io::Error {
 impl<'a, T: AsyncRead + ?Sized> Future for ReadExact<'a, T> {
    type Output = io::Result<()>;

-    fn poll(mut self: Pin<&mut Self>, _waker: &task::Waker) -> Poll<Self::Output> {
+    fn poll(mut self: Pin<&mut Self>, _context: &mut task::Context) -> Poll<Self::Output> {
        use crate::compat::forward::convert_poll;

        let this = &mut *self;
@@ -25,7 +25,7 @@ impl<'a, T: AsyncWrite + ?Sized> Write<'a, T> {
 impl<'a, T: AsyncWrite + ?Sized> Future for Write<'a, T> {
    type Output = io::Result<usize>;

-    fn poll(mut self: Pin<&mut Self>, _waker: &task::Waker) -> Poll<io::Result<usize>> {
+    fn poll(mut self: Pin<&mut Self>, _context: &mut task::Context) -> Poll<io::Result<usize>> {
        use crate::compat::forward::convert_poll;

        let this = &mut *self;
@@ -30,7 +30,7 @@ fn zero_write() -> io::Error {
 impl<'a, T: AsyncWrite + ?Sized> Future for WriteAll<'a, T> {
    type Output = io::Result<()>;

-    fn poll(mut self: Pin<&mut Self>, _waker: &task::Waker) -> Poll<io::Result<()>> {
+    fn poll(mut self: Pin<&mut Self>, _context: &mut task::Context) -> Poll<io::Result<()>> {
        use crate::compat::forward::convert_poll;

        let this = &mut *self;
@@ -1,6 +1,6 @@
 #![cfg(feature = "async-await-preview")]
-#![feature(rust_2018_preview, async_await, await_macro, futures_api)]
-#![doc(html_root_url = "https://docs.rs/tokio-async-await/0.1.6")]
+#![feature(await_macro)]
+#![doc(html_root_url = "https://docs.rs/tokio-futures/0.1.0")]
 #![deny(missing_docs, missing_debug_implementations)]
 #![cfg_attr(test, deny(warnings))]

@@ -27,7 +27,7 @@ impl<'a, T: Sink + Unpin + ?Sized> Send<'a, T> {
 impl<T: Sink + Unpin + ?Sized> Future for Send<'_, T> {
    type Output = Result<(), T::SinkError>;

-    fn poll(mut self: Pin<&mut Self>, _waker: &task::Waker) -> Poll<Self::Output> {
+    fn poll(mut self: Pin<&mut Self>, _context: &mut task::Context) -> Poll<Self::Output> {
        use crate::compat::forward::convert_poll;
        use futures::AsyncSink::{NotReady, Ready};

@@ -12,12 +12,12 @@ pub trait StreamExt: Stream {
    ///
    /// # Examples
    ///
-    /// ```
+    /// ```edition2018
    /// #![feature(await_macro, async_await)]
    /// tokio::run_async(async {
    /// // The extension trait can also be imported with
    /// // `use tokio::prelude::*`.
-    /// use tokio::prelude::{stream, StreamExt};
+    /// use tokio::prelude::{stream, StreamAsyncExt};
    ///
    /// let mut stream = stream::iter_ok::<_, ()>(1..3);
    ///
@@ -2,7 +2,7 @@ use futures::Stream;

 use std::future::Future;
 use std::pin::Pin;
-use std::task::{Poll, Waker};
+use std::task::{Context, Poll};

 /// A future of the next element of a stream.
 #[derive(Debug)]
@@ -21,7 +21,7 @@ impl<'a, T: Stream + Unpin> Next<'a, T> {
 impl<'a, T: Stream + Unpin> Future for Next<'a, T> {
    type Output = Option<Result<T::Item, T::Error>>;

-    fn poll(mut self: Pin<&mut Self>, _waker: &Waker) -> Poll<Self::Output> {
+    fn poll(mut self: Pin<&mut Self>, _context: &mut Context) -> Poll<Self::Output> {
        use crate::compat::forward::convert_poll_stream;

        convert_poll_stream(self.stream.poll())
@@ -1,12 +1,12 @@
 [package]
 name = "tokio-io"
-
 # When releasing to crates.io:
+# - Remove path dependencies
 # - Update html_root_url.
-# - Update CHANGELOG.md.
-# - Update doc URL.
+# - Update doc url
 #   - Cargo.toml
-#   - Readme.md
+#   - README.md
+# - Update CHANGELOG.md.
 # - Create "v0.1.x" git tag.
 version = "0.1.12"
 authors = ["Carl Lerche <[email protected]>"]
@@ -186,13 +186,13 @@ where
            // readable again, at which point the stream is terminated.
            if self.is_readable {
                if self.eof {
-                    let frame = try!(self.inner.decode_eof(&mut self.buffer));
+                    let frame = self.inner.decode_eof(&mut self.buffer)?;
                    return Ok(Async::Ready(frame));
                }

                trace!("attempting to decode a frame");

-                if let Some(frame) = try!(self.inner.decode(&mut self.buffer)) {
+                if let Some(frame) = self.inner.decode(&mut self.buffer)? {
                    trace!("frame decoded from buffer");
                    return Ok(Async::Ready(Some(frame)));
                }
@@ -94,7 +94,7 @@ where
    }

    fn close(&mut self) -> Poll<(), Self::SinkError> {
-        Ok(try!(self.inner.close()))
+        Ok(self.inner.close()?)
    }
 }

@@ -173,14 +173,14 @@ where
        // If the buffer is already over 8KiB, then attempt to flush it. If after flushing it's
        // *still* over 8KiB, then apply backpressure (reject the send).
        if self.buffer.len() >= BACKPRESSURE_BOUNDARY {
-            try!(self.poll_complete());
+            self.poll_complete()?;

            if self.buffer.len() >= BACKPRESSURE_BOUNDARY {
                return Ok(AsyncSink::NotReady(item));
            }
        }

-        try!(self.inner.encode(item, &mut self.buffer));
+        self.inner.encode(item, &mut self.buffer)?;

        Ok(AsyncSink::Ready)
    }
@@ -216,7 +216,7 @@ where

    fn close(&mut self) -> Poll<(), Self::SinkError> {
        try_ready!(self.poll_complete());
-        Ok(try!(self.inner.shutdown()))
+        Ok(self.inner.shutdown()?)
    }
 }

@@ -79,7 +79,7 @@ pub trait Decoder {
    /// frames to yield. This behavior enables returning finalization frames
    /// that may not be based on inbound data.
    fn decode_eof(&mut self, buf: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
-        match try!(self.decode(buf)) {
+        match self.decode(buf)? {
            Some(frame) => Ok(Some(frame)),
            None => {
                if buf.is_empty() {
@@ -190,13 +190,13 @@ where
            // readable again, at which point the stream is terminated.
            if self.is_readable {
                if self.eof {
-                    let frame = try!(self.inner.decode_eof(&mut self.buffer));
+                    let frame = self.inner.decode_eof(&mut self.buffer)?;
                    return Ok(Async::Ready(frame));
                }

                trace!("attempting to decode a frame");

-                if let Some(frame) = try!(self.inner.decode(&mut self.buffer)) {
+                if let Some(frame) = self.inner.decode(&mut self.buffer)? {
                    trace!("frame decoded from buffer");
                    return Ok(Async::Ready(Some(frame)));
                }
@@ -98,7 +98,7 @@ where
    }

    fn close(&mut self) -> Poll<(), Self::SinkError> {
-        Ok(try!(self.inner.close()))
+        Ok(self.inner.close()?)
    }
 }

@@ -177,14 +177,14 @@ where
        // If the buffer is already over 8KiB, then attempt to flush it. If after flushing it's
        // *still* over 8KiB, then apply backpressure (reject the send).
        if self.buffer.len() >= BACKPRESSURE_BOUNDARY {
-            try!(self.poll_complete());
+            self.poll_complete()?;

            if self.buffer.len() >= BACKPRESSURE_BOUNDARY {
                return Ok(AsyncSink::NotReady(item));
            }
        }

-        try!(self.inner.encode(item, &mut self.buffer));
+        self.inner.encode(item, &mut self.buffer)?;

        Ok(AsyncSink::Ready)
    }
@@ -220,7 +220,7 @@ where

    fn close(&mut self) -> Poll<(), Self::SinkError> {
        try_ready!(self.poll_complete());
-        Ok(try!(self.inner.shutdown()))
+        Ok(self.inner.shutdown()?)
    }
 }

@@ -368,7 +368,7 @@ impl codec::Decoder for Decoder {

    fn decode(&mut self, src: &mut BytesMut) -> io::Result<Option<BytesMut>> {
        let n = match self.state {
-            DecodeState::Head => match try!(self.decode_head(src)) {
+            DecodeState::Head => match self.decode_head(src)? {
                Some(n) => {
                    self.state = DecodeState::Data(n);
                    n
@@ -378,7 +378,7 @@ impl codec::Decoder for Decoder {
            DecodeState::Data(n) => n,
        };

-        match try!(self.decode_data(n, src)) {
+        match self.decode_data(n, src)? {
            Some(data) => {
                // Update the decode state
                self.state = DecodeState::Head;
@@ -525,11 +525,11 @@ impl<T: AsyncWrite, B: IntoBuf> Sink for FramedWrite<T, B> {
    type SinkError = io::Error;

    fn start_send(&mut self, item: B) -> StartSend<B, io::Error> {
-        if !try!(self.do_write()).is_ready() {
+        if !self.do_write()?.is_ready() {
            return Ok(AsyncSink::NotReady(item));
        }

-        try!(self.set_frame(item.into_buf()));
+        self.set_frame(item.into_buf())?;

        Ok(AsyncSink::Ready)
    }
@@ -21,10 +21,10 @@ use std::io as std_io;
 use futures::{Future, Stream};

 /// A convenience typedef around a `Future` whose error component is `io::Error`
-pub type IoFuture<T> = Box<Future<Item = T, Error = std_io::Error> + Send>;
+pub type IoFuture<T> = Box<dyn Future<Item = T, Error = std_io::Error> + Send>;

 /// A convenience typedef around a `Stream` whose error component is `io::Error`
-pub type IoStream<T> = Box<Stream<Item = T, Error = std_io::Error> + Send>;
+pub type IoStream<T> = Box<dyn Stream<Item = T, Error = std_io::Error> + Send>;

 /// A convenience macro for working with `io::Result<T>` from the `Read` and
 /// `Write` traits.
@@ -65,6 +65,6 @@ pub use self::async_write::AsyncWrite;

 fn _assert_objects() {
    fn _assert<T>() {}
-    _assert::<Box<AsyncRead>>();
-    _assert::<Box<AsyncWrite>>();
+    _assert::<Box<dyn AsyncRead>>();
+    _assert::<Box<dyn AsyncWrite>>();
 }
@@ -0,0 +1,27 @@
+[package]
+name = "tokio-macros"
+# When releasing to crates.io:
+# - Remove path dependencies
+# - Update html_root_url.
+# - Update doc url
+#   - Cargo.toml
+#   - README.md
+# - Update CHANGELOG.md.
+# - Create "v0.1.x" git tag.
+version = "0.1.0"
+authors = ["Tokio Contributors <[email protected]>"]
+edition = "2018"
+publish = false
+
+[lib]
+proc-macro = true
+
+[features]
+# This feature comes with no promise of stability. Things will
+# break with each patch release. Use at your own risk.
+async-await-preview = []
+
+[dependencies]
+proc-macro2 = "0.4.27"
+quote = "0.6.11"
+syn = { version = "0.15.27", features = ["full", "extra-traits", "visit-mut"] }
@@ -0,0 +1,47 @@
+Copyright (c) 2019 Tokio Contributors
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+The MIT License (MIT)
+
+Copyright (c) 2019 Yoshua Wuyts
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
@@ -0,0 +1,13 @@
+# Tokio Macros
+
+Procedural macros for use with Tokio
+
+## License
+
+This project is licensed under the [MIT license](LICENSE).
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in Tokio by you, shall be licensed as MIT, without any additional
+terms or conditions.
@@ -0,0 +1,81 @@
+#![cfg(feature = "async-await-preview")]
+
+extern crate proc_macro;
+
+use proc_macro::TokenStream;
+use quote::{quote, quote_spanned};
+use syn::spanned::Spanned;
+
+/// Define the program entry point
+///
+/// # Examples
+///
+/// ```
+/// #[tokio::main]
+/// async fn main() {
+///     println!("Hello world");
+/// }
+#[proc_macro_attribute]
+pub fn main(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let input = syn::parse_macro_input!(item as syn::ItemFn);
+
+    let ret = &input.decl.output;
+    let name = &input.ident;
+    let body = &input.block;
+
+    if input.asyncness.is_none() {
+        let tokens = quote_spanned! { input.span() =>
+          compile_error!("the async keyword is missing from the function declaration");
+        };
+
+        return TokenStream::from(tokens);
+    }
+
+    let result = quote! {
+        fn #name() #ret {
+            let mut rt = tokio::runtime::Runtime::new().unwrap();
+            rt.block_on_async(async { #body })
+        }
+    };
+
+    result.into()
+}
+
+/// Define a Tokio aware unit test
+///
+/// # Examples
+///
+/// ```
+/// #[tokio::test]
+/// async fn my_test() {
+///     assert!(true);
+/// }
+/// ```
+#[proc_macro_attribute]
+pub fn test(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let input = syn::parse_macro_input!(item as syn::ItemFn);
+
+    let ret = &input.decl.output;
+    let name = &input.ident;
+    let body = &input.block;
+    let attrs = &input.attrs;
+
+    if input.asyncness.is_none() {
+        let tokens = quote_spanned! { input.span() =>
+          compile_error!("the async keyword is missing from the function declaration");
+        };
+
+        return TokenStream::from(tokens);
+    }
+
+    let result = quote! {
+        #[test]
+        #(#attrs)*
+        fn #name() #ret {
+            let mut rt = tokio::runtime::current_thread::Runtime::new().unwrap();
+            rt.block_on_async(async { #body })
+        }
+    };
+
+    result.into()
+}
@@ -1,3 +1,9 @@
+# 0.1.10 (September 25, 2019)
+
+### Changed
+- Upgrade to parking_lot 0.9.0 (#1298 backport)
+- The minimum supported rust version (MSRV) is now 1.31.0. (#1358)
+
 # 0.1.9 (March 1, 2019)

 ### Added
@@ -1,20 +1,20 @@
 [package]
 name = "tokio-reactor"
-
 # When releasing to crates.io:
+# - Remove path dependencies
 # - Update html_root_url.
-# - Update CHANGELOG.md.
-# - Update doc URL.
+# - Update doc url
 #   - Cargo.toml
 #   - README.md
+# - Update CHANGELOG.md.
 # - Create "v0.1.x" git tag.
-version = "0.1.9"
+version = "0.1.10"
 authors = ["Carl Lerche <[email protected]>"]
 license = "MIT"
 readme = "README.md"
 repository = "https://github.com/tokio-rs/tokio"
 homepage = "https://tokio.rs"
-documentation = "https://docs.rs/tokio-reactor/0.1.9/tokio_reactor"
+documentation = "https://docs.rs/tokio-reactor/0.1.10/tokio_reactor"
 description = """
 Event loop that drives Tokio I/O resources.
 """
@@ -27,7 +27,7 @@ lazy_static = "1.0.2"
 log = "0.4.1"
 mio = "0.6.14"
 num_cpus = "1.8.0"
-parking_lot = "0.7.0"
+parking_lot = "0.9.0"
 slab = "0.4.0"
 tokio-executor = "0.1.1"
 tokio-io = "0.1.6"
@@ -36,4 +36,4 @@ tokio-sync = "0.1.1"
 [dev-dependencies]
 num_cpus = "1.8.0"
 tokio = "0.1.7"
-tokio-io-pool = "0.1.4"
+tokio-io-pool = "=0.1.4"
@@ -2,7 +2,7 @@

 Event loop that drives Tokio I/O resources.

-[Documentation](https://docs.rs/tokio-reactor/0.1.9/tokio_reactor)
+[Documentation](https://docs.rs/tokio-reactor/0.1.10/tokio_reactor)

 ## Overview

@@ -25,10 +25,10 @@ are building a custom I/O resource.

 [`mio`]: http://github.com/carllerche/mio
 [`futures`]: http://github.com/rust-lang-nursery/futures-rs
-[`Reactor`]: https://docs.rs/tokio-reactor/0.1.9/tokio_reactor/struct.Reactor.html
-[`Handle`]: https://docs.rs/tokio-reactor/0.1.9/tokio_reactor/struct.Handle.html
-[`Registration`]: https://docs.rs/tokio-reactor/0.1.9/tokio_reactor/struct.Registration.html
-[`PollEvented`]: https://docs.rs/tokio-reactor/0.1.9/tokio_reactor/struct.PollEvented.html
+[`Reactor`]: https://docs.rs/tokio-reactor/0.1.10/tokio_reactor/struct.Reactor.html
+[`Handle`]: https://docs.rs/tokio-reactor/0.1.10/tokio_reactor/struct.Handle.html
+[`Registration`]: https://docs.rs/tokio-reactor/0.1.10/tokio_reactor/struct.Registration.html
+[`PollEvented`]: https://docs.rs/tokio-reactor/0.1.10/tokio_reactor/struct.PollEvented.html
 [`tokio`]: ../

 ## License
@@ -1,4 +1,4 @@
-#![doc(html_root_url = "https://docs.rs/tokio-reactor/0.1.9")]
+#![doc(html_root_url = "https://docs.rs/tokio-reactor/0.1.10")]
 #![deny(missing_docs, warnings, missing_debug_implementations)]

 //! Event loop that drives Tokio I/O resources.
@@ -631,7 +631,7 @@ impl HandlePriv {
    }

    unsafe fn from_usize(val: usize) -> HandlePriv {
-        let inner = mem::transmute::<usize, Weak<Inner>>(val);;
+        let inner = mem::transmute::<usize, Weak<Inner>>(val);
        HandlePriv { inner }
    }

@@ -652,7 +652,7 @@ impl Inner {
    /// Register an I/O resource with the reactor.
    ///
    /// The registration token is returned.
-    fn add_source(&self, source: &Evented) -> io::Result<usize> {
+    fn add_source(&self, source: &dyn Evented) -> io::Result<usize> {
        // Get an ABA guard value
        let aba_guard = self.next_aba_guard.fetch_add(1 << TOKEN_SHIFT, Relaxed);

@@ -690,7 +690,7 @@ impl Inner {
    }

    /// Deregisters an I/O resource from the reactor.
-    fn deregister_source(&self, source: &Evented) -> io::Result<()> {
+    fn deregister_source(&self, source: &dyn Evented) -> io::Result<()> {
        self.io.deregister(source)
    }

@@ -1,3 +1,11 @@
+# 0.2.9
+
+### Fixed
+- `windows::Event` performs internal registrations lazily, so now it can be
+constructed outside of a running task
+- remove usage of deprecated `Handle::current` in default `windows::Event`
+constructors
+
 # 0.2.8 (March 22, 2019)

 ### Fixed
@@ -1,10 +1,12 @@
 [package]
 name = "tokio-signal"
-
 # When releasing to crates.io:
+# - Remove path dependencies
 # - Update html_root_url.
+# - Update doc url
+#   - Cargo.toml
+#   - README.md
 # - Update CHANGELOG.md.
-# - Update doc URL.
 # - Create "v0.2.x" git tag.
 version = "0.2.8"
 authors = ["Tokio Contributors <[email protected]>"]
@@ -31,11 +33,11 @@ tokio-io = "0.1"
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"
 mio-uds = "0.6"
-signal-hook = "0.1"
+signal-hook-registry = "~1"

 [dev-dependencies]
 tokio = "0.1.8"

 [target.'cfg(windows)'.dependencies.winapi]
 version = "0.3"
-features = ["minwindef", "wincon"]
+features = ["consoleapi", "minwindef", "wincon"]
@@ -7,7 +7,7 @@ use futures::{Future, Stream};
 /// how many signals to handle before exiting
 const STOP_AFTER: u64 = 10;

-fn main() -> Result<(), Box<std::error::Error>> {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
    // tokio_signal provides a convenience builder for Ctrl+C
    // this even works cross-platform: linux and windows!
    //
@@ -53,7 +53,12 @@ fn main() -> Result<(), Box<std::error::Error>> {
    // Up until now, we haven't really DONE anything, just prepared
    // now it's time to actually schedule, and thus execute, the stream
    // on our event loop
-    tokio::runtime::current_thread::block_on_all(future)?;
+    // FIXME(1000): windows uses a global driver task which doesn't terminate
+    // on its own, so if we use block_on_all our application will never exit
+    //tokio::runtime::current_thread::block_on_all(future)?;
+    tokio::runtime::current_thread::Runtime::new()
+        .expect("failed to start runtime on current thread")
+        .block_on(future)?;

    println!("Stream ended, quiting the program.");
    Ok(())
--- a/Show More
+++ b/Show More