Start work on compat feature

This makes it consistent with `TcpListener::poll_accept` and other
public poll methods the library provides. This particular method is
useful for writing generic code that accepts connections since async
functions can't easily be used with traits. It is possible to
generically accept connections with `Incoming`, however, this doesn't
return the incoming `SocketAddr`.

.cargo/audit.toml

@@ -1,8 +0,0 @@
-# See https://github.com/rustsec/rustsec/blob/59e1d2ad0b9cbc6892c26de233d4925074b4b97b/cargo-audit/audit.toml.example for example.
-
-[advisories]
-ignore = [
-    # We depend on nix 0.22 only via mio-aio, a dev-dependency.
-    # https://github.com/tokio-rs/tokio/pull/4255#issuecomment-974786349
-    "RUSTSEC-2021-0119",
-]

.cargo/config

@@ -1,2 +0,0 @@
-# [build]
-# rustflags = ["--cfg", "tokio_unstable"]

.circleci/config.yml

@@ -1,25 +0,0 @@
-version: 2.1        
-jobs:
-  test-arm:
-    machine:
-      image: ubuntu-2004:202101-01
-    resource_class: arm.medium
-    environment:
-      # Change to pin rust version
-      RUST_STABLE: 1.62.1
-    steps:
-      - checkout
-      - run:
-          name: Install Rust
-          command: |
-            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs -o rustup.sh
-            chmod +x rustup.sh
-            ./rustup.sh -y --default-toolchain $RUST_STABLE
-            source "$HOME"/.cargo/env
-      # Only run Tokio tests
-      - run: cargo test --all-features -p tokio
-
-workflows:
-  ci:
-    jobs:
-      - test-arm

.cirrus.yml

@@ -1,53 +1,19 @@
-only_if: $CIRRUS_TAG == '' && ($CIRRUS_PR != '' || $CIRRUS_BRANCH == 'master' || $CIRRUS_BRANCH =~ 'tokio-.*')
-auto_cancellation: $CIRRUS_BRANCH != 'master' && $CIRRUS_BRANCH !=~ 'tokio-.*'
 freebsd_instance:
-  image_family: freebsd-13-1
-env:
-  RUST_STABLE: 1.62.1
-  RUST_NIGHTLY: nightly-2022-03-21
-  RUSTFLAGS: -D warnings
+  image: freebsd-12-1-release-amd64
 
 # Test FreeBSD in a full VM on cirrus-ci.com.  Test the i686 target too, in the
 # same VM.  The binary will be built in 32-bit mode, but will execute on a
 # 64-bit kernel and in a 64-bit environment.  Our tests don't execute any of
 # the system's binaries, so the environment shouldn't matter.
 task:
-  name: FreeBSD 64-bit
-  setup_script:
-    - pkg install -y bash
-    - curl https://sh.rustup.rs -sSf --output rustup.sh
-    - sh rustup.sh -y --profile minimal --default-toolchain $RUST_STABLE
-    - . $HOME/.cargo/env
-    - |
-      echo "~~~~ rustc --version ~~~~"
-      rustc --version
-  test_script:
-    - . $HOME/.cargo/env
-    - cargo test --all --all-features
-
-task:
-  name: FreeBSD docs
+  name: FreeBSD 12.0
   env:
-    RUSTFLAGS: --cfg docsrs --cfg tokio_unstable
-    RUSTDOCFLAGS: --cfg docsrs --cfg tokio_unstable -Dwarnings
+    LOOM_MAX_PREEMPTIONS: 2
+    RUSTFLAGS: -Dwarnings
   setup_script:
-    - pkg install -y bash
+    - pkg install -y curl
     - curl https://sh.rustup.rs -sSf --output rustup.sh
-    - sh rustup.sh -y --profile minimal --default-toolchain $RUST_NIGHTLY
-    - . $HOME/.cargo/env
-    - |
-      echo "~~~~ rustc --version ~~~~"
-      rustc --version
-  test_script:
-    - . $HOME/.cargo/env
-    - cargo doc --lib --no-deps --all-features --document-private-items
-
-task:
-  name: FreeBSD 32-bit
-  setup_script:
-    - pkg install -y bash
-    - curl https://sh.rustup.rs -sSf --output rustup.sh
-    - sh rustup.sh -y --profile minimal --default-toolchain $RUST_STABLE
+    - sh rustup.sh -y --profile minimal --default-toolchain stable
     - . $HOME/.cargo/env
     - rustup target add i686-unknown-freebsd
     - |
@@ -55,4 +21,10 @@ task:
       rustc --version
   test_script:
     - . $HOME/.cargo/env
-    - cargo test --all --all-features --target i686-unknown-freebsd
+    - cargo test --all
+    - cargo doc --all --no-deps
+  # TODO: Re-enable
+  # i686_test_script:
+  #   - . $HOME/.cargo/env
+  #   - |
+  #     cargo test --all --exclude tokio-macros --target i686-unknown-freebsd

.clippy.toml

@@ -1 +0,0 @@
-msrv = "1.49"

.github/FUNDING.yml

@@ -1,3 +0,0 @@
-# These are supported funding model platforms
-
-github: [tokio-rs]

.github/ISSUE_TEMPLATE/bug_report.md

@@ -9,7 +9,12 @@ assignees: ''
 
 **Version**
 List the versions of all `tokio` crates you are using. The easiest way to get
-this information is using `cargo tree` subcommand:
+this information is using `cargo-tree`.
+
+`cargo install cargo-tree`
+(see install here: https://github.com/sfackler/cargo-tree)
+
+Then:
 
 `cargo tree | grep tokio`
 

.github/labeler.yml

@@ -1,8 +0,0 @@
-
-R-loom:
-- tokio/src/sync/*
-- tokio/src/sync/**/*
-- tokio-util/src/sync/*
-- tokio-util/src/sync/**/*
-- tokio/src/runtime/*
-- tokio/src/runtime/**/*

.github/workflows/audit.yml

@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     if: "!contains(github.event.head_commit.message, 'ci skip')"
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
 
       - name: Audit Check
         uses: actions-rs/audit-check@v1

.github/workflows/ci.yml

@@ -1,31 +1,16 @@
 on:
   push:
-    branches: ["master", "tokio-*.x"]
+    branches: ["v0.2.x"]
   pull_request:
-    branches: ["master", "tokio-*.x"]
+    branches: ["v0.2.x"]
 
 name: CI
 
 env:
   RUSTFLAGS: -Dwarnings
   RUST_BACKTRACE: 1
-  # Change to specific Rust release to pin
-  rust_stable: 1.62.1
-  rust_nightly: nightly-2022-04-18
-  rust_clippy: 1.56.0
-  # When updating this, also update:
-  # - README.md
-  # - tokio/README.md
-  # - CONTRIBUTING.md
-  # - tokio/Cargo.toml
-  # - tokio-util/Cargo.toml
-  # - tokio-test/Cargo.toml
-  # - tokio-stream/Cargo.toml
-  rust_min: 1.49.0
-
-defaults:
-  run:
-    shell: bash
+  nightly: nightly-2020-09-21
+  minrust: 1.39.0
 
 jobs:
   # Depends on all action sthat are required for a "successful" CI run.
@@ -35,19 +20,14 @@ jobs:
     needs:
       - test
       - test-unstable
-      - test-parking_lot
       - miri
       - cross
       - features
       - minrust
       - fmt
+      - clippy
       - docs
-      - valgrind
-      - loom-compile
-      - check-readme
-      - test-hyper
-      - wasm32-unknown-unknown
-      - wasm32-wasi
+      - loom
     steps:
       - run: exit 0
 
@@ -61,17 +41,11 @@ jobs:
           - ubuntu-latest
           - macos-latest
     steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: ${{ env.rust_stable }}
-            override: true
+      - uses: actions/checkout@v2
       - name: Install Rust
         run: rustup update stable
-      - uses: Swatinem/rust-cache@v1
       - name: Install cargo-hack
-        run: cargo install cargo-hack --version 0.5.26
+        run: cargo install cargo-hack
 
       # Run `tokio` with `full` features. This excludes testing utilities which
       # can alter the runtime behavior of Tokio.
@@ -79,6 +53,11 @@ jobs:
         run: cargo test --features full
         working-directory: tokio
 
+      # Check `tokio` with `full + parking_lot` to make sure it compiles.
+      - name: check tokio full,parking_lot
+        run: cargo check --features full,parking_lot
+        working-directory: tokio
+
       # Test **all** crates in the workspace with all features.
       - name: test all --all-features
         run: cargo test --workspace --all-features
@@ -93,72 +72,6 @@ jobs:
         run: cargo hack test --each-feature
         working-directory: tests-build
 
-      # Build benchmarks. Run of benchmarks is done by bench.yml workflow.
-      - name: build benches
-        run: cargo build --benches
-        working-directory: benches
-        # bench.yml workflow runs benchmarks only on linux.
-        if: startsWith(matrix.os, 'ubuntu')
-
-  test-parking_lot:
-    # The parking_lot crate has a feature called send_guard which changes when
-    # some of its types are Send. Tokio has some measures in place to prevent
-    # this from affecting when Tokio types are Send, and this test exists to
-    # ensure that those measures are working.
-    #
-    # This relies on the potentially affected Tokio type being listed in
-    # `tokio/tokio/tests/async_send_sync.rs`.
-    name: compile tests with parking lot send guards
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: ${{ env.rust_stable }}
-            override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: Enable parking_lot send_guard feature
-        # Inserts the line "plsend = ["parking_lot/send_guard"]" right after [features]
-        run: sed -i '/\[features\]/a plsend = ["parking_lot/send_guard"]' tokio/Cargo.toml
-      - name: Compile tests with all features enabled
-        run: cargo build --workspace --all-features --tests
-
-  valgrind:
-    name: valgrind
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: ${{ env.rust_stable }}
-            override: true
-      - uses: Swatinem/rust-cache@v1
-
-      - name: Install Valgrind
-        run: |
-          sudo apt-get update -y
-          sudo apt-get install -y valgrind
-
-      # Compile tests
-      - name: cargo build test-mem
-        run: cargo build --features rt-net --bin test-mem
-        working-directory: tests-integration
-
-      # Run with valgrind
-      - name: Run valgrind test-mem
-        run: valgrind --error-exitcode=1 --leak-check=full --show-leak-kinds=all ./target/debug/test-mem
-
-      # Compile tests
-      - name: cargo build test-process-signal
-        run: cargo build --features rt-process-signal --bin test-process-signal
-        working-directory: tests-integration
-
-      # Run with valgrind
-      - name: Run valgrind test-process-signal
-        run: valgrind --error-exitcode=1 --leak-check=full --show-leak-kinds=all ./target/debug/test-process-signal
-
   test-unstable:
     name: test tokio full --unstable
     runs-on: ${{ matrix.os }}
@@ -169,64 +82,36 @@ jobs:
           - ubuntu-latest
           - macos-latest
     steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: ${{ env.rust_stable }}
-            override: true
-      - uses: Swatinem/rust-cache@v1
+      - uses: actions/checkout@v2
+      - name: Install Rust
+        run: rustup update stable
+
       # Run `tokio` with "unstable" cfg flag.
       - name: test tokio full --cfg unstable
-        run: cargo test --all-features
+        run: cargo test --features full
         working-directory: tokio
         env:
-          RUSTFLAGS: --cfg tokio_unstable -Dwarnings
-          # in order to run doctests for unstable features, we must also pass
-          # the unstable cfg to RustDoc
-          RUSTDOCFLAGS: --cfg tokio_unstable
+          RUSTFLAGS: '--cfg tokio_unstable'
 
   miri:
     name: miri
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_nightly }}
-        uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2022-07-10
-          components: miri
+          toolchain: ${{ env.nightly }}
           override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: miri
-        # Many of tests in tokio/tests and doctests use #[tokio::test] or
-        # #[tokio::main] that calls epoll_create1 that Miri does not support.
-        run: cargo miri test --features full --lib --no-fail-fast
-        working-directory: tokio
-        env:
-          MIRIFLAGS: -Zmiri-disable-isolation -Zmiri-tag-raw-pointers
-          PROPTEST_CASES: 10
+      - name: Install Miri
+        run: |
+          set -e
+          rustup component add miri
+          cargo miri setup
+          rm -rf tokio/tests
 
-  asan:
-    name: asan
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install llvm
-        # Required to resolve symbols in sanitizer output
-        run: sudo apt-get install -y llvm
-      - name: Install Rust ${{ env.rust_nightly }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.rust_nightly }}
-          override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: asan
-        run: cargo test --workspace --all-features --target x86_64-unknown-linux-gnu --tests -- --test-threads 1
-        env:
-          RUSTFLAGS: -Z sanitizer=address
-          # Ignore `trybuild` errors as they are irrelevant and flaky on nightly
-          TRYBUILD: overwrite
+      - name: miri
+        run: cargo miri test --features rt-core,rt-threaded,rt-util,sync task
+        working-directory: tokio
 
   cross:
     name: cross
@@ -239,247 +124,121 @@ jobs:
           - powerpc64-unknown-linux-gnu
           - mips-unknown-linux-gnu
           - arm-linux-androideabi
-          - mipsel-unknown-linux-musl
     steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: ${{ env.rust_stable }}
+          toolchain: stable
           target: ${{ matrix.target }}
           override: true
       - uses: actions-rs/cargo@v1
         with:
           use-cross: true
           command: check
-          args: --workspace --all-features --target ${{ matrix.target }}
-      - uses: actions-rs/cargo@v1
-        with:
-          use-cross: true
-          command: check
-          args: --workspace --all-features --target ${{ matrix.target }}
-        env:
-          RUSTFLAGS: --cfg tokio_unstable -Dwarnings
+          args: --workspace --target ${{ matrix.target }}
 
   features:
     name: features
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_nightly }}
-        uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: ${{ env.rust_nightly }}
-          target: ${{ matrix.target }}
+          toolchain: ${{ env.nightly }}
           override: true
-      - uses: Swatinem/rust-cache@v1
       - name: Install cargo-hack
-        run: cargo install cargo-hack --version 0.5.26
+        run: cargo install cargo-hack
+
       - name: check --each-feature
         run: cargo hack check --all --each-feature -Z avoid-dev-deps
+
       # Try with unstable feature flags
       - name: check --each-feature --unstable
         run: cargo hack check --all --each-feature -Z avoid-dev-deps
         env:
-          RUSTFLAGS: --cfg tokio_unstable -Dwarnings
+          RUSTFLAGS: --cfg tokio_unstable
 
   minrust:
     name: minrust
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_min }}
-        uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: ${{ env.rust_min }}
+          toolchain: ${{ env.minrust }}
           override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: "test --all-features"
-        run: cargo check --all-features
-        working-directory: tokio
 
-  minimal-versions:
-    name: minimal-versions
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_nightly }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.rust_nightly }}
-          override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: Install cargo-hack
-        run: cargo install cargo-hack --version 0.5.26
-      - name: "check --all-features -Z minimal-versions"
-        run: |
-          # Remove dev-dependencies from Cargo.toml to prevent the next `cargo update`
-          # from determining minimal versions based on dev-dependencies.
-          cargo hack --remove-dev-deps --workspace
-          # Update Cargo.lock to minimal version dependencies.
-          cargo update -Z minimal-versions
-          cargo hack check --all-features --ignore-private
-      - name: "check --all-features --unstable -Z minimal-versions"
-        env:
-          RUSTFLAGS: --cfg tokio_unstable -Dwarnings
-        run: |
-          # Remove dev-dependencies from Cargo.toml to prevent the next `cargo update`
-          # from determining minimal versions based on dev-dependencies.
-          cargo hack --remove-dev-deps --workspace
-          # Update Cargo.lock to minimal version dependencies.
-          cargo update -Z minimal-versions
-          cargo hack check --all-features --ignore-private
+      - name: "test --workspace --all-features"
+        run: cargo check --workspace --all-features
 
   fmt:
     name: fmt
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.rust_stable }}
-          override: true
-          components: rustfmt
-      - uses: Swatinem/rust-cache@v1
+      - uses: actions/checkout@v2
+      - name: Install Rust
+        run: rustup update stable
+      - name: Install rustfmt
+        run: rustup component add rustfmt
+
       # Check fmt
       - name: "rustfmt --check"
         # Workaround for rust-lang/cargo#7732
         run: |
-          if ! rustfmt --check --edition 2018 $(git ls-files '*.rs'); then
-            printf "Please run \`rustfmt --edition 2018 \$(git ls-files '*.rs')\` to fix rustfmt errors.\nSee CONTRIBUTING.md for more details.\n" >&2
+          if ! rustfmt --check --edition 2018 $(find . -name '*.rs' -print); then
+            printf "Please run \`rustfmt --edition 2018 \$(find . -name '*.rs' -print)\` to fix rustfmt errors.\nSee CONTRIBUTING.md for more details.\n" >&2
             exit 1
           fi
 
+  clippy:
+    name: clippy
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install Rust
+        run: rustup update stable
+      - name: Install clippy
+        run: rustup component add clippy
+
+      # Run clippy
+      - name: "clippy --all"
+        run: cargo clippy --all --tests
+
   docs:
     name: docs
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_nightly }}
-        uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: ${{ env.rust_nightly }}
+          toolchain: ${{ env.nightly }}
           override: true
-      - uses: Swatinem/rust-cache@v1
+
       - name: "doc --lib --all-features"
-        run: cargo doc --lib --no-deps --all-features --document-private-items
+        run: cargo doc --lib --no-deps --all-features
         env:
-          RUSTFLAGS: --cfg docsrs --cfg tokio_unstable
-          RUSTDOCFLAGS: --cfg docsrs --cfg tokio_unstable -Dwarnings
+          RUSTDOCFLAGS: --cfg docsrs
 
-  loom-compile:
-    name: build loom tests
+  loom:
+    name: loom
     runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.rust_stable }}
-          override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: build --cfg loom
-        run: cargo test --no-run --lib --features full
-        working-directory: tokio
-        env:
-          RUSTFLAGS: --cfg loom --cfg tokio_unstable -Dwarnings
-
-  check-readme:
-    name: Check README
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Verify that both READMEs are identical
-        run: diff README.md tokio/README.md
-
-      - name: Verify that Tokio version is up to date in README
-        working-directory: tokio
-        run: grep -q "$(sed '/^version = /!d' Cargo.toml | head -n1)" README.md
-
-  test-hyper:
-    name: Test hyper
-    runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os:
-          - windows-latest
-          - ubuntu-latest
-          - macos-latest
+        scope:
+          - --skip loom_pool
+          - loom_pool::group_a
+          - loom_pool::group_b
+          - loom_pool::group_c
+          - loom_pool::group_d
     steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.rust_stable }}
-          override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: Test hyper
-        run: |
-          set -x
-          git clone https://github.com/hyperium/hyper.git
-          cd hyper
-          # checkout the latest release because HEAD maybe contains breakage.
-          tag=$(git describe --abbrev=0 --tags)
-          git checkout "${tag}"
-          echo '[workspace]' >>Cargo.toml
-          echo '[patch.crates-io]' >>Cargo.toml
-          echo 'tokio = { path = "../tokio" }' >>Cargo.toml
-          echo 'tokio-util = { path = "../tokio-util" }' >>Cargo.toml
-          echo 'tokio-stream = { path = "../tokio-stream" }' >>Cargo.toml
-          echo 'tokio-test = { path = "../tokio-test" }' >>Cargo.toml
-          git diff
-          cargo test --features full
+      - uses: actions/checkout@v2
+      - name: Install Rust
+        run: rustup update stable
 
-  wasm32-unknown-unknown:
-    name: test tokio for wasm32-unknown-unknown
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.rust_stable }}
-          override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: Install wasm-pack
-        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
-      - name: test tokio
-        run: wasm-pack test --node -- --features "macros sync"
+      - name: loom ${{ matrix.scope }}
+        run: cargo test --lib --release --features full -- --nocapture $SCOPE
         working-directory: tokio
-
-  wasm32-wasi:
-    name: wasm32-wasi
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          override: true
-      - uses: Swatinem/rust-cache@v1
-
-      # Install dependencies
-      - name: Install cargo-hack
-        run: cargo install cargo-hack
-
-      - name: Install wasm32-wasi target
-        run: rustup target add wasm32-wasi
-
-      - name: Install wasmtime
-        run: cargo install wasmtime-cli
-
-      - name: Install cargo-wasi
-        run: cargo install cargo-wasi
-
-      # TODO: Expand this when full WASI support lands.
-      #   Currently, this is a bare bones regression test
-      #   for features that work today with wasi.
-
-      - name: test tests-integration --features wasi-rt
-        # TODO: this should become: `cargo hack wasi test --each-feature`
-        run: cargo wasi test --test rt_yield --features wasi-rt
-        working-directory: tests-integration
         env:
-          RUSTFLAGS: ""
+          RUSTFLAGS: --cfg loom --cfg tokio_unstable
+          LOOM_MAX_PREEMPTIONS: 2
+          SCOPE: ${{ matrix.scope }}

.github/workflows/labeler.yml

@@ -1,14 +0,0 @@
-name: "Pull Request Labeler"
-on:
-- pull_request_target
-
-# See .github/labeler.yml file
-
-jobs:
-  triage:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/labeler@v3
-      with:
-        repo-token: "${{ secrets.GITHUB_TOKEN }}"
-        sync-labels: true

.github/workflows/loom.yml

@@ -1,45 +0,0 @@
-on:
-  push:
-    branches: ["master", "tokio-*.x"]
-  pull_request:
-    types: [labeled, opened, synchronize, reopened]
-    branches: ["master", "tokio-*.x"]
-
-name: Loom
-
-env:
-  RUSTFLAGS: -Dwarnings
-  RUST_BACKTRACE: 1
-  # Change to specific Rust release to pin
-  rust_stable: 1.62.1
-
-jobs:
-  loom:
-    name: loom
-    # base_ref is null when it's not a pull request
-    if: contains(github.event.pull_request.labels.*.name, 'R-loom') || (github.base_ref == null)
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        scope:
-          - --skip loom_pool
-          - loom_pool::group_a
-          - loom_pool::group_b
-          - loom_pool::group_c
-          - loom_pool::group_d
-          - time::driver
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: ${{ env.rust_stable }}
-            override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: loom ${{ matrix.scope }}
-        run: cargo test --lib --release --features full -- --nocapture $SCOPE
-        working-directory: tokio
-        env:
-          RUSTFLAGS: --cfg loom --cfg tokio_unstable -Dwarnings
-          LOOM_MAX_PREEMPTIONS: 2
-          SCOPE: ${{ matrix.scope }}

.github/workflows/pr-audit.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     if: "!contains(github.event.head_commit.message, 'ci skip')"
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
 
       - name: Install cargo-audit
         uses: actions-rs/cargo@v1

.github/workflows/stress-test.yml

@@ -1,41 +0,0 @@
-name: Stress Test
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-
-env:
-  RUSTFLAGS: -Dwarnings
-  RUST_BACKTRACE: 1
-  # Change to specific Rust release to pin
-  rust_stable: 1.62.1
-
-jobs:
-  stess-test:
-    name: Stress Test
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        stress-test:
-          - simple_echo_tcp
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: ${{ env.rust_stable }}
-            override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: Install Valgrind
-        run: |
-          sudo apt-get update -y
-          sudo apt-get install -y valgrind
-
-      # Compiles each of the stress test examples.
-      - name: Compile stress test examples
-        run: cargo build -p stress-test --release --example ${{ matrix.stress-test }}
-
-      # Runs each of the examples using Valgrind. Detects leaks and displays them.
-      - name: Run valgrind
-        run: valgrind  --leak-check=full --show-leak-kinds=all ./target/release/examples/${{ matrix.stress-test }}

.gitignore

@@ -1,4 +1,2 @@
 target
 Cargo.lock
-
-.cargo/config.toml

CONTRIBUTING.md

@@ -124,59 +124,23 @@ arguments to many common cargo commands. This section lists some commonly needed
 commands.
 
 Some commands just need the `--all-features` argument:
-
 ```
 cargo build --all-features
 cargo check --all-features
 cargo test --all-features
 ```
-
-Clippy must be run using the MSRV, so Tokio can avoid having to `#[allow]` new
-lints whose fixes would be incompatible with the current MSRV:
-
-<!--
-When updating this, also update:
-- .github/workflows/ci.yml
-- README.md
-- tokio/README.md
-- tokio/Cargo.toml
-- tokio-util/Cargo.toml
-- tokio-test/Cargo.toml
-- tokio-stream/Cargo.toml
--->
-
-```
-cargo +1.49.0 clippy --all-features
-```
-
 When building documentation normally, the markers that list the features
 required for various parts of Tokio are missing. To build the documentation
 correctly, use this command:
-
 ```
 RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc --all-features
 ```
-
-To build documentation including Tokio's unstable features, it is necessary to
-pass `--cfg tokio_unstable` to both RustDoc *and* rustc. To build the
-documentation for unstable features, use this command:
-
-```
-RUSTDOCFLAGS="--cfg docsrs --cfg tokio_unstable" RUSTFLAGS="--cfg tokio_unstable" cargo +nightly doc --all-features
-```
-
-There is currently a [bug in cargo] that means documentation cannot be built
-from the root of the workspace. If you `cd` into the `tokio` subdirectory the
-command shown above will work.
-
-[bug in cargo]: https://github.com/rust-lang/cargo/issues/9274
-
 The `cargo fmt` command does not work on the Tokio codebase. You can use the
 command below instead:
 
 ```
 # Mac or Linux
-rustfmt --check --edition 2018 $(git ls-files '*.rs')
+rustfmt --check --edition 2018 $(find . -name '*.rs' -print)
 
 # Powershell
 Get-ChildItem . -Filter "*.rs" -Recurse | foreach { rustfmt --check --edition 2018 $_.FullName }
@@ -191,12 +155,6 @@ LOOM_MAX_PREEMPTIONS=1 RUSTFLAGS="--cfg loom" \
     cargo test --lib --release --features full -- --test-threads=1 --nocapture
 ```
 
-You can run miri tests with
-```
-MIRIFLAGS="-Zmiri-disable-isolation -Zmiri-tag-raw-pointers" PROPTEST_CASES=10 \
-    cargo +nightly miri test --features full --lib
-```
-
 ### Tests
 
 If the change being proposed alters code (as opposed to only documentation for
@@ -469,14 +427,11 @@ _Adapted from the [Node.js contributing guide][node]_.
 
 ## Keeping track of issues and PRs
 
-The Tokio GitHub repository has a lot of issues and PRs to keep track of. This
-section explains the meaning of various labels, as well as our [GitHub
-project][project]. The section is primarily targeted at maintainers.  Most
-contributors aren't able to set these labels.
+The Tokio GitHub repository has a lot of issues and PRs, which is not easy to
+keep track of. This section explains the meaning of various labels, as well as
+our [GitHub project][project]. The section is primarily targeted at maintainers.
 
-### Area
-
-The area label describes the crates relevant to this issue or PR.
+**Area.** The area label describes the crates relevant to this issue or PR.
 
  - **A-tokio** This issue concerns the main Tokio crate.
  - **A-tokio-util** This issue concerns the `tokio-util` crate.
@@ -487,7 +442,7 @@ The area label describes the crates relevant to this issue or PR.
    be used for the procedural macros, and not `join!` or `select!`.
  - **A-ci** This issue concerns our GitHub Actions setup.
 
-### Category
+**Category.** The category label describes the category.
 
  - **C-bug** This is a bug-report. Bug-fix PRs use `C-enhancement` instead.
  - **C-enhancement** This is a PR that adds a new features.
@@ -505,7 +460,8 @@ The area label describes the crates relevant to this issue or PR.
  - **C-request** A non-feature request, e.g. "please add deprecation notices to
    `-alpha.*` versions of crates"
 
-### Calls for participation
+**Call for participation.** I don't know why it's called `E-`. Many issues are
+missing a difficulty rating, and you should feel free to add one.
 
  - **E-help-wanted** Stuff where we want help. Often seen together with `C-bug`
    or `C-feature-accepted`.
@@ -517,13 +473,7 @@ The area label describes the crates relevant to this issue or PR.
  - **E-needs-mvce** This bug is missing a minimal complete and verifiable
    example.
 
-The "E-" prefix is the same as used in the Rust compiler repository. Some
-issues are missing a difficulty rating, but feel free to ask on our Discord
-server if you want to know how difficult an issue likely is.
-
-### Module
-
-The module label provides a more fine grained categorization than **Area**.
+**Module.** A more fine groaned categorization than area.
 
  - **M-blocking** Things relevant to `spawn_blocking`, `block_in_place`.
  - **M-codec** The `tokio_util::codec` module.
@@ -536,14 +486,13 @@ The module label provides a more fine grained categorization than **Area**.
  - **M-process** The `tokio::process` module.
  - **M-runtime** The `tokio::runtime` module.
  - **M-signal** The `tokio::signal` module.
+ - **M-stream** The `tokio::stream` module.
  - **M-sync** The `tokio::sync` module.
  - **M-task** The `tokio::task` module.
  - **M-time** The `tokio::time` module.
  - **M-tracing** Tracing support in Tokio.
 
-### Topic
-
-Some extra information.
+**Topic.** Some extra information.
 
  - **T-docs** This is about documentation.
  - **T-performance** This is about performance.
@@ -553,34 +502,6 @@ Any label not listed here is not in active use.
 
 [project]: https://github.com/orgs/tokio-rs/projects/1
 
-## LTS guarantees
-
-Tokio ≥1.0.0 comes with LTS guarantees:
-
- * A minimum of 5 years of maintenance.
- * A minimum of 3 years before a hypothetical 2.0 release.
-
-The goal of these guarantees is to provide stability to the ecosystem.
-
-## Mininum Supported Rust Version (MSRV)
-
- * All Tokio ≥1.0.0 releases will support at least a 6-month old Rust
-   compiler release.
- * The MSRV will only be increased on 1.x releases.
-
-## Versioning Policy
-
-With Tokio ≥1.0.0:
-
- * Patch (1.\_.x) releases _should only_ contain bug fixes or documentation
-   changes. Besides this, these releases should not substantially change
-   runtime behavior.
- * Minor (1.x) releases may contain new functionality, MSRV increases (see
-   above), minor dependency updates, deprecations, and larger internal
-   implementation changes.
-
-This is as defined by [Semantic Versioning 2.0](https://semver.org/).
-
 ## Releasing
 
 Since the Tokio project consists of a number of crates, many of which depend on
@@ -613,8 +534,9 @@ When releasing a new version of a crate, follow these steps:
 2. **Update Cargo metadata.** After releasing any path dependencies, update the
    `version` field in `Cargo.toml` to the new version, and the `documentation`
    field to the docs.rs URL of the new version.
-3. **Update other documentation links.** Update the "Documentation" link in the
-   crate's `README.md` to point to the docs.rs URL of the new version.
+3. **Update other documentation links.** Update the `#![doc(html_root_url)]`
+   attribute in the crate's `lib.rs` and the "Documentation" link in the crate's
+   `README.md` to point to the docs.rs URL of the new version.
 4. **Update the changelog for the crate.** Each crate in the Tokio repository
    has its own `CHANGELOG.md` in that crate's subdirectory. Any changes to that
    crate since the last release should be added to the changelog. Change

Cargo.lock

@@ -1,32 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "predicates"
-version = "1.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f49cfaf7fdaa3bfacc6fa3e7054e65148878354a5cfddcf661df4c851f8021df"
-dependencies = [
- "difference",
- "float-cmp",
- "normalize-line-endings",
- "predicates-core",
- "regex",
-]
-
-[[package]]
-name = "predicates-core"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72f883590242d3c6fc5bf50299011695fa6590c2c70eac95ee1bdb9a733ad1a2"
-
-[[package]]
-name = "predicates-tree"
-version = "1.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54ff541861505aabf6ea722d2131ee980b8276e10a1297b94e896dd8b621850d"
-dependencies = [
- "predicates-core",
- "termtree",
-]

Cargo.toml

@@ -4,13 +4,11 @@ members = [
   "tokio",
   "tokio-macros",
   "tokio-test",
-  "tokio-stream",
   "tokio-util",
 
   # Internal
   "benches",
   "examples",
-  "stress-test",
   "tests-build",
   "tests-integration",
 ]

Cross.toml

@@ -1,4 +0,0 @@
-[build.env]
-passthrough = [
-    "RUSTFLAGS",
-]

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2022 Tokio Contributors
+Copyright (c) 2019 Tokio Contributors
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

README.md

@@ -14,21 +14,22 @@ the Rust programming language. It is:
 
 [![Crates.io][crates-badge]][crates-url]
 [![MIT licensed][mit-badge]][mit-url]
-[![Build Status][actions-badge]][actions-url]
+[![Build Status][azure-badge]][azure-url]
 [![Discord chat][discord-badge]][discord-url]
 
 [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]: https://github.com/tokio-rs/tokio/blob/master/LICENSE
-[actions-badge]: https://github.com/tokio-rs/tokio/workflows/CI/badge.svg
-[actions-url]: https://github.com/tokio-rs/tokio/actions?query=workflow%3ACI+branch%3Amaster
+[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
 [discord-badge]: https://img.shields.io/discord/500028886025895936.svg?logo=discord&style=flat-square
 [discord-url]: https://discord.gg/tokio
 
 [Website](https://tokio.rs) |
 [Guides](https://tokio.rs/tokio/tutorial) |
 [API Docs](https://docs.rs/tokio/latest/tokio) |
+[Roadmap](https://github.com/tokio-rs/tokio/blob/master/ROADMAP.md) |
 [Chat](https://discord.gg/tokio)
 
 ## Overview
@@ -50,23 +51,15 @@ an asynchronous application.
 
 ## Example
 
-A basic TCP echo server with Tokio.
-
-Make sure you activated the full features of the tokio crate on Cargo.toml:
-
-```toml
-[dependencies]
-tokio = { version = "1.20.5", features = ["full"] }
-```
-Then, on your main.rs:
+A basic TCP echo server with Tokio:
 
 ```rust,no_run
 use tokio::net::TcpListener;
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::prelude::*;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let listener = TcpListener::bind("127.0.0.1:8080").await?;
+    let mut listener = TcpListener::bind("127.0.0.1:8080").await?;
 
     loop {
         let (mut socket, _) = listener.accept().await?;
@@ -140,7 +133,8 @@ several other libraries, including:
 
 * [`tower`]: A library of modular and reusable components for building robust networking clients and servers.
 
-* [`tracing`] (formerly `tokio-trace`): A framework for application-level tracing and async-aware diagnostics.
+* [`tracing`] (formerly `tokio-trace`): A framework for application-level
+  tracing and async-aware diagnostics.
 
 * [`rdbc`]: A Rust database connectivity library for MySQL, Postgres and SQLite.
 
@@ -163,48 +157,9 @@ several other libraries, including:
 
 ## Supported Rust Versions
 
-<!--
-When updating this, also update:
-- .github/workflows/ci.yml
-- CONTRIBUTING.md
-- README.md
-- tokio/README.md
-- tokio/Cargo.toml
-- tokio-util/Cargo.toml
-- tokio-test/Cargo.toml
-- tokio-stream/Cargo.toml
--->
-
-Tokio will keep a rolling MSRV (minimum supported rust version) policy of **at
-least** 6 months. When increasing the MSRV, the new Rust version must have been
-released at least six months ago. The current MSRV is 1.49.0.
-
-## Release schedule
-
-Tokio doesn't follow a fixed release schedule, but we typically make one to two
-new minor releases each month. We make patch releases for bugfixes as necessary.
-
-## Bug patching policy
-
-For the purposes of making patch releases with bugfixes, we have designated
-certain minor releases as LTS (long term support) releases. Whenever a bug
-warrants a patch release with a fix for the bug, it will be backported and
-released as a new patch release for each LTS minor version. Our current LTS
-releases are:
-
- * `1.14.x` - LTS release until June 2022.
- * `1.18.x` - LTS release until January 2023
-
-Each LTS release will continue to receive backported fixes for at least half a
-year. If you wish to use a fixed minor release in your project, we recommend
-that you use an LTS release.
-
-To use a fixed minor version, you can specify the version with a tilde. For
-example, to specify that you wish to use the newest `1.14.x` patch release, you
-can use the following dependency specification:
-```text
-tokio = { version = "~1.14", features = [...] }
-```
+Tokio is built against the latest stable release. The minimum supported version is 1.39.
+The current Tokio version is not guaranteed to build on Rust versions earlier than the
+minimum supported version.
 
 ## License
 

ROADMAP.md

@@ -0,0 +1,67 @@
+# Tokio Roadmap
+
+## A Roadmap to 1.0
+
+The question of "why not 1.0?" has come up a few times. After all, Tokio 0.1 has
+been stable for three years. The short answer: because it isn't time. There is
+nobody who would rather ship a Tokio 1.0 than us. It also isn't something to rush.
+
+After all, `async / await` only landed in the stable Rust channel weeks ago.
+There has been no significant production validation yet, except maybe fuchsia
+and that seems like a fairly specialized use case. This release of Tokio
+includes significant new code and new strategies with feature flags. Also, there
+are still big open questions, such as the [proposed changes][pr-1744] to
+`AsyncRead` and `AsyncWrite`.
+
+Tokio 1.0 will be released as soon as the APIs are proven to handle real-world
+production cases.
+
+### Tokio 1.0 in Q3 2020 with LTS support
+
+The Tokio 1.0 release will be **no later** than Q3 2020. It will also come with
+"long-term support" guarantees:
+
+* A minimum of 5 years of maintenance.
+* A minimum of 3 years before a hypothetical 2.0 release.
+
+When Tokio 1.0 is released in Q3 2020, on-going support, security fixes, and
+critical bug fixes are guaranteed until **at least** Q3 2025. Tokio 2.0 will not
+be released until **at least** Q3 2023 (though, ideally there will never be a
+Tokio 2.0 release).
+
+### How to get there
+
+While Tokio 0.1 probably should have been a 1.0, Tokio 0.2 will be a **true**
+0.2 release. There will be breaking change releases every 2 ~ 3 months until 1.0.
+These changes will be **much** smaller than going from 0.1 -> 0.2. It is
+expected that the 1.0 release will look a lot like 0.2.
+
+### What is expected to change
+
+The biggest change will be the `AsyncRead` and `AsyncWrite` traits. Based on
+experience gained over the past 3 years, there are a couple of issues to
+address:
+
+* Be able to **safely** use uninitialized memory as a read buffer.
+* Practical read vectored and write vectored APIs.
+
+There are a few strategies to solve these problems. These strategies need to be
+investigated and the solution validated. You can see [this comment][pr-1744-comment] for a
+detailed statement of the problem.
+
+The other major change, which has been in the works for a while, is updating
+Mio. Mio 0.6 was first released almost 4 years ago and has not had a breaking
+change since. Mio 0.7 has been in the works for a while. It includes a full
+rewrite of the windows support as well as a refined API. More will be written
+about this shortly.
+
+Finally, now that the API is starting to stabilize, effort will be put into
+documentation. Tokio 0.2 is being released before updating the website and many
+of the old content will no longer be relevant. In the coming weeks, expect to
+see updates there.
+
+So, we have our work cut out for us. We hope you enjoy this 0.2 release and are
+looking forward to your feedback and help.
+
+[pr-1744]: https://github.com/tokio-rs/tokio/pull/1744
+[pr-1744-comment]: https://github.com/tokio-rs/tokio/pull/1744#issuecomment-553575438

benches/Cargo.toml

@@ -5,29 +5,22 @@ publish = false
 edition = "2018"
 
 [dependencies]
-tokio = { version = "1.5.0", path = "../tokio", features = ["full"] }
+tokio = { version = "0.2.0", path = "../tokio", features = ["full"] }
 bencher = "0.1.5"
 
-[dev-dependencies]
-tokio-util = { version = "0.7.0", path = "../tokio-util", features = ["full"] }
-tokio-stream = { path = "../tokio-stream" }
-
-[target.'cfg(unix)'.dependencies]
-libc = "0.2.42"
-
 [[bench]]
 name = "spawn"
 path = "spawn.rs"
 harness = false
 
 [[bench]]
-name = "sync_mpsc"
-path = "sync_mpsc.rs"
+name = "mpsc"
+path = "mpsc.rs"
 harness = false
 
 [[bench]]
-name = "rt_multi_threaded"
-path = "rt_multi_threaded.rs"
+name = "scheduler"
+path = "scheduler.rs"
 harness = false
 
 
@@ -40,13 +33,3 @@ harness = false
 name = "sync_semaphore"
 path = "sync_semaphore.rs"
 harness = false
-
-[[bench]]
-name = "signal"
-path = "signal.rs"
-harness = false
-
-[[bench]]
-name = "fs"
-path = "fs.rs"
-harness = false

benches/fs.rs

@@ -1,103 +0,0 @@
-#![cfg(unix)]
-
-use tokio_stream::StreamExt;
-
-use tokio::fs::File;
-use tokio::io::AsyncReadExt;
-use tokio_util::codec::{BytesCodec, FramedRead /*FramedWrite*/};
-
-use bencher::{benchmark_group, benchmark_main, Bencher};
-
-use std::fs::File as StdFile;
-use std::io::Read as StdRead;
-
-fn rt() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(2)
-        .build()
-        .unwrap()
-}
-
-const BLOCK_COUNT: usize = 1_000;
-
-const BUFFER_SIZE: usize = 4096;
-const DEV_ZERO: &str = "/dev/zero";
-
-fn async_read_codec(b: &mut Bencher) {
-    let rt = rt();
-
-    b.iter(|| {
-        let task = || async {
-            let file = File::open(DEV_ZERO).await.unwrap();
-            let mut input_stream = FramedRead::with_capacity(file, BytesCodec::new(), BUFFER_SIZE);
-
-            for _i in 0..BLOCK_COUNT {
-                let _bytes = input_stream.next().await.unwrap();
-            }
-        };
-
-        rt.block_on(task());
-    });
-}
-
-fn async_read_buf(b: &mut Bencher) {
-    let rt = rt();
-
-    b.iter(|| {
-        let task = || async {
-            let mut file = File::open(DEV_ZERO).await.unwrap();
-            let mut buffer = [0u8; BUFFER_SIZE];
-
-            for _i in 0..BLOCK_COUNT {
-                let count = file.read(&mut buffer).await.unwrap();
-                if count == 0 {
-                    break;
-                }
-            }
-        };
-
-        rt.block_on(task());
-    });
-}
-
-fn async_read_std_file(b: &mut Bencher) {
-    let rt = rt();
-
-    let task = || async {
-        let mut file = tokio::task::block_in_place(|| Box::pin(StdFile::open(DEV_ZERO).unwrap()));
-
-        for _i in 0..BLOCK_COUNT {
-            let mut buffer = [0u8; BUFFER_SIZE];
-            let mut file_ref = file.as_mut();
-
-            tokio::task::block_in_place(move || {
-                file_ref.read_exact(&mut buffer).unwrap();
-            });
-        }
-    };
-
-    b.iter(|| {
-        rt.block_on(task());
-    });
-}
-
-fn sync_read(b: &mut Bencher) {
-    b.iter(|| {
-        let mut file = StdFile::open(DEV_ZERO).unwrap();
-        let mut buffer = [0u8; BUFFER_SIZE];
-
-        for _i in 0..BLOCK_COUNT {
-            file.read_exact(&mut buffer).unwrap();
-        }
-    });
-}
-
-benchmark_group!(
-    file,
-    async_read_std_file,
-    async_read_buf,
-    async_read_codec,
-    sync_read
-);
-
-benchmark_main!(file);

benches/mpsc.rs

@@ -4,13 +4,6 @@ use tokio::sync::mpsc;
 type Medium = [usize; 64];
 type Large = [Medium; 64];
 
-fn rt() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
-        .build()
-        .unwrap()
-}
-
 fn create_1_medium(b: &mut Bencher) {
     b.iter(|| {
         black_box(&mpsc::channel::<Medium>(1));
@@ -30,38 +23,38 @@ fn create_100_000_medium(b: &mut Bencher) {
 }
 
 fn send_medium(b: &mut Bencher) {
-    let rt = rt();
-
     b.iter(|| {
-        let (tx, mut rx) = mpsc::channel::<Medium>(1000);
+        let (mut tx, mut rx) = mpsc::channel::<Medium>(1000);
 
-        let _ = rt.block_on(tx.send([0; 64]));
+        let _ = tx.try_send([0; 64]);
 
-        rt.block_on(rx.recv()).unwrap();
+        rx.try_recv().unwrap();
     });
 }
 
 fn send_large(b: &mut Bencher) {
-    let rt = rt();
-
     b.iter(|| {
-        let (tx, mut rx) = mpsc::channel::<Large>(1000);
+        let (mut tx, mut rx) = mpsc::channel::<Large>(1000);
 
-        let _ = rt.block_on(tx.send([[0; 64]; 64]));
+        let _ = tx.try_send([[0; 64]; 64]);
 
-        rt.block_on(rx.recv()).unwrap();
+        rx.try_recv().unwrap();
     });
 }
 
 fn contention_bounded(b: &mut Bencher) {
-    let rt = rt();
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
+        .build()
+        .unwrap();
 
     b.iter(|| {
         rt.block_on(async move {
             let (tx, mut rx) = mpsc::channel::<usize>(1_000_000);
 
             for _ in 0..5 {
-                let tx = tx.clone();
+                let mut tx = tx.clone();
                 tokio::spawn(async move {
                     for i in 0..1000 {
                         tx.send(i).await.unwrap();
@@ -77,14 +70,18 @@ fn contention_bounded(b: &mut Bencher) {
 }
 
 fn contention_bounded_full(b: &mut Bencher) {
-    let rt = rt();
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
+        .build()
+        .unwrap();
 
     b.iter(|| {
         rt.block_on(async move {
             let (tx, mut rx) = mpsc::channel::<usize>(100);
 
             for _ in 0..5 {
-                let tx = tx.clone();
+                let mut tx = tx.clone();
                 tokio::spawn(async move {
                     for i in 0..1000 {
                         tx.send(i).await.unwrap();
@@ -100,7 +97,11 @@ fn contention_bounded_full(b: &mut Bencher) {
 }
 
 fn contention_unbounded(b: &mut Bencher) {
-    let rt = rt();
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
+        .build()
+        .unwrap();
 
     b.iter(|| {
         rt.block_on(async move {
@@ -123,11 +124,15 @@ fn contention_unbounded(b: &mut Bencher) {
 }
 
 fn uncontented_bounded(b: &mut Bencher) {
-    let rt = rt();
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
+        .build()
+        .unwrap();
 
     b.iter(|| {
         rt.block_on(async move {
-            let (tx, mut rx) = mpsc::channel::<usize>(1_000_000);
+            let (mut tx, mut rx) = mpsc::channel::<usize>(1_000_000);
 
             for i in 0..5000 {
                 tx.send(i).await.unwrap();
@@ -141,7 +146,11 @@ fn uncontented_bounded(b: &mut Bencher) {
 }
 
 fn uncontented_unbounded(b: &mut Bencher) {
-    let rt = rt();
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
+        .build()
+        .unwrap();
 
     b.iter(|| {
         rt.block_on(async move {

benches/scheduler.rs

@@ -1,4 +1,4 @@
-//! Benchmark implementation details of the threaded scheduler. These benches are
+//! Benchmark implementation details of the theaded scheduler. These benches are
 //! intended to be used as a form of regression testing and not as a general
 //! purpose benchmark demonstrating real-world performance.
 
@@ -13,7 +13,7 @@ use std::sync::{mpsc, Arc};
 fn spawn_many(b: &mut Bencher) {
     const NUM_SPAWN: usize = 10_000;
 
-    let rt = rt();
+    let mut rt = rt();
 
     let (tx, rx) = mpsc::sync_channel(1000);
     let rem = Arc::new(AtomicUsize::new(0));
@@ -68,7 +68,7 @@ fn yield_many(b: &mut Bencher) {
 fn ping_pong(b: &mut Bencher) {
     const NUM_PINGS: usize = 1_000;
 
-    let rt = rt();
+    let mut rt = rt();
 
     let (done_tx, done_rx) = mpsc::sync_channel(1000);
     let rem = Arc::new(AtomicUsize::new(0));
@@ -111,7 +111,7 @@ fn ping_pong(b: &mut Bencher) {
 fn chained_spawn(b: &mut Bencher) {
     const ITER: usize = 1_000;
 
-    let rt = rt();
+    let mut rt = rt();
 
     fn iter(done_tx: mpsc::SyncSender<()>, n: usize) {
         if n == 0 {
@@ -139,8 +139,9 @@ fn chained_spawn(b: &mut Bencher) {
 }
 
 fn rt() -> Runtime {
-    runtime::Builder::new_multi_thread()
-        .worker_threads(4)
+    runtime::Builder::new()
+        .threaded_scheduler()
+        .core_threads(4)
         .enable_all()
         .build()
         .unwrap()

benches/signal.rs

@@ -1,95 +0,0 @@
-//! Benchmark the delay in propagating OS signals to any listeners.
-#![cfg(unix)]
-
-use bencher::{benchmark_group, benchmark_main, Bencher};
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::runtime;
-use tokio::signal::unix::{signal, SignalKind};
-use tokio::sync::mpsc;
-
-struct Spinner {
-    count: usize,
-}
-
-impl Future for Spinner {
-    type Output = ();
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        if self.count > 3 {
-            Poll::Ready(())
-        } else {
-            self.count += 1;
-            cx.waker().wake_by_ref();
-            Poll::Pending
-        }
-    }
-}
-
-impl Spinner {
-    fn new() -> Self {
-        Self { count: 0 }
-    }
-}
-
-pub fn send_signal(signal: libc::c_int) {
-    use libc::{getpid, kill};
-
-    unsafe {
-        assert_eq!(kill(getpid(), signal), 0);
-    }
-}
-
-fn many_signals(bench: &mut Bencher) {
-    let num_signals = 10;
-    let (tx, mut rx) = mpsc::channel(num_signals);
-
-    // Intentionally single threaded to measure delays in propagating wakes
-    let rt = runtime::Builder::new_current_thread()
-        .enable_all()
-        .build()
-        .unwrap();
-
-    let spawn_signal = |kind| {
-        let tx = tx.clone();
-        rt.spawn(async move {
-            let mut signal = signal(kind).expect("failed to create signal");
-
-            while signal.recv().await.is_some() {
-                if tx.send(()).await.is_err() {
-                    break;
-                }
-            }
-        });
-    };
-
-    for _ in 0..num_signals {
-        // Pick some random signals which don't terminate the test harness
-        spawn_signal(SignalKind::child());
-        spawn_signal(SignalKind::io());
-    }
-    drop(tx);
-
-    // Turn the runtime for a while to ensure that all the spawned
-    // tasks have been polled at least once
-    rt.block_on(Spinner::new());
-
-    bench.iter(|| {
-        rt.block_on(async {
-            send_signal(libc::SIGCHLD);
-            for _ in 0..num_signals {
-                rx.recv().await.expect("channel closed");
-            }
-
-            send_signal(libc::SIGIO);
-            for _ in 0..num_signals {
-                rx.recv().await.expect("channel closed");
-            }
-        });
-    });
-}
-
-benchmark_group!(signal_group, many_signals,);
-
-benchmark_main!(signal_group);

benches/spawn.rs

@@ -2,83 +2,69 @@
 //! This essentially measure the time to enqueue a task in the local and remote
 //! case.
 
-#[macro_use]
-extern crate bencher;
-
 use bencher::{black_box, Bencher};
 
 async fn work() -> usize {
     let val = 1 + 1;
-    tokio::task::yield_now().await;
     black_box(val)
 }
 
-fn basic_scheduler_spawn(bench: &mut Bencher) {
-    let runtime = tokio::runtime::Builder::new_current_thread()
+fn basic_scheduler_local_spawn(bench: &mut Bencher) {
+    let mut runtime = tokio::runtime::Builder::new()
+        .basic_scheduler()
         .build()
         .unwrap();
-    bench.iter(|| {
-        runtime.block_on(async {
+    runtime.block_on(async {
+        bench.iter(|| {
             let h = tokio::spawn(work());
-            assert_eq!(h.await.unwrap(), 2);
-        });
+            black_box(h);
+        })
     });
 }
 
-fn basic_scheduler_spawn10(bench: &mut Bencher) {
-    let runtime = tokio::runtime::Builder::new_current_thread()
+fn threaded_scheduler_local_spawn(bench: &mut Bencher) {
+    let mut runtime = tokio::runtime::Builder::new()
+        .threaded_scheduler()
         .build()
         .unwrap();
-    bench.iter(|| {
-        runtime.block_on(async {
-            let mut handles = Vec::with_capacity(10);
-            for _ in 0..10 {
-                handles.push(tokio::spawn(work()));
-            }
-            for handle in handles {
-                assert_eq!(handle.await.unwrap(), 2);
-            }
-        });
-    });
-}
-
-fn threaded_scheduler_spawn(bench: &mut Bencher) {
-    let runtime = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(1)
-        .build()
-        .unwrap();
-    bench.iter(|| {
-        runtime.block_on(async {
+    runtime.block_on(async {
+        bench.iter(|| {
             let h = tokio::spawn(work());
-            assert_eq!(h.await.unwrap(), 2);
-        });
+            black_box(h);
+        })
     });
 }
 
-fn threaded_scheduler_spawn10(bench: &mut Bencher) {
-    let runtime = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(1)
+fn basic_scheduler_remote_spawn(bench: &mut Bencher) {
+    let runtime = tokio::runtime::Builder::new()
+        .basic_scheduler()
         .build()
         .unwrap();
+    let handle = runtime.handle();
     bench.iter(|| {
-        runtime.block_on(async {
-            let mut handles = Vec::with_capacity(10);
-            for _ in 0..10 {
-                handles.push(tokio::spawn(work()));
-            }
-            for handle in handles {
-                assert_eq!(handle.await.unwrap(), 2);
-            }
-        });
+        let h = handle.spawn(work());
+        black_box(h);
+    });
+}
+
+fn threaded_scheduler_remote_spawn(bench: &mut Bencher) {
+    let runtime = tokio::runtime::Builder::new()
+        .threaded_scheduler()
+        .build()
+        .unwrap();
+    let handle = runtime.handle();
+    bench.iter(|| {
+        let h = handle.spawn(work());
+        black_box(h);
     });
 }
 
 bencher::benchmark_group!(
     spawn,
-    basic_scheduler_spawn,
-    basic_scheduler_spawn10,
-    threaded_scheduler_spawn,
-    threaded_scheduler_spawn10,
+    basic_scheduler_local_spawn,
+    threaded_scheduler_local_spawn,
+    basic_scheduler_remote_spawn,
+    threaded_scheduler_remote_spawn
 );
 
 bencher::benchmark_main!(spawn);

benches/sync_rwlock.rs

@@ -3,8 +3,9 @@ use std::sync::Arc;
 use tokio::{sync::RwLock, task};
 
 fn read_uncontended(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
         .build()
         .unwrap();
 
@@ -21,8 +22,9 @@ fn read_uncontended(b: &mut Bencher) {
 }
 
 fn read_concurrent_uncontended_multi(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
         .build()
         .unwrap();
 
@@ -49,7 +51,8 @@ fn read_concurrent_uncontended_multi(b: &mut Bencher) {
 }
 
 fn read_concurrent_uncontended(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_current_thread()
+    let mut rt = tokio::runtime::Builder::new()
+        .basic_scheduler()
         .build()
         .unwrap();
 
@@ -75,8 +78,9 @@ fn read_concurrent_uncontended(b: &mut Bencher) {
 }
 
 fn read_concurrent_contended_multi(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
         .build()
         .unwrap();
 
@@ -104,7 +108,8 @@ fn read_concurrent_contended_multi(b: &mut Bencher) {
 }
 
 fn read_concurrent_contended(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_current_thread()
+    let mut rt = tokio::runtime::Builder::new()
+        .basic_scheduler()
         .build()
         .unwrap();
 

benches/sync_semaphore.rs

@@ -3,8 +3,9 @@ use std::sync::Arc;
 use tokio::{sync::Semaphore, task};
 
 fn uncontended(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
         .build()
         .unwrap();
 
@@ -26,8 +27,9 @@ async fn task(s: Arc<Semaphore>) {
 }
 
 fn uncontended_concurrent_multi(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
         .build()
         .unwrap();
 
@@ -49,7 +51,8 @@ fn uncontended_concurrent_multi(b: &mut Bencher) {
 }
 
 fn uncontended_concurrent_single(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_current_thread()
+    let mut rt = tokio::runtime::Builder::new()
+        .basic_scheduler()
         .build()
         .unwrap();
 
@@ -70,8 +73,9 @@ fn uncontended_concurrent_single(b: &mut Bencher) {
 }
 
 fn contended_concurrent_multi(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
         .build()
         .unwrap();
 
@@ -93,7 +97,8 @@ fn contended_concurrent_multi(b: &mut Bencher) {
 }
 
 fn contended_concurrent_single(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_current_thread()
+    let mut rt = tokio::runtime::Builder::new()
+        .basic_scheduler()
         .build()
         .unwrap();
 

examples/Cargo.toml

@@ -5,26 +5,20 @@ publish = false
 edition = "2018"
 
 # If you copy one of the examples into a new project, you should be using
-# [dependencies] instead, and delete the **path**.
+# [dependencies] instead.
 [dev-dependencies]
-tokio = { version = "1.0.0", path = "../tokio", features = ["full", "tracing"] }
-tokio-util = { version = "0.7.0", path = "../tokio-util", features = ["full"] }
-tokio-stream = { version = "0.1", path = "../tokio-stream" }
-
+tokio = { version = "0.2.0", path = "../tokio", features = ["full", "tracing"] }
 tracing = "0.1"
-tracing-subscriber = { version = "0.3.1", default-features = false, features = ["fmt", "ansi", "env-filter", "tracing-log"] }
-bytes = "1.0.0"
-futures = { version = "0.3.0", features = ["thread-pool"]}
+tracing-subscriber = { version = "0.2.7", default-features = false, features = ["fmt", "ansi", "env-filter", "chrono", "tracing-log"] }
+tokio-util = { version = "0.3.0", path = "../tokio-util", features = ["full"] }
+bytes = "0.5"
+futures = "0.3.0"
 http = "0.2"
 serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"
 httparse = "1.0"
-httpdate = "1.0"
-rand = "0.8.3"
-
-[target.'cfg(windows)'.dev-dependencies.winapi]
-version = "0.3.8"
+time = "0.1"
 
 [[example]]
 name = "chat"
@@ -69,19 +63,3 @@ path = "udp-codec.rs"
 [[example]]
 name = "tinyhttp"
 path = "tinyhttp.rs"
-
-[[example]]
-name = "custom-executor-tokio-context"
-path = "custom-executor-tokio-context.rs"
-
-[[example]]
-name = "named-pipe"
-path = "named-pipe.rs"
-
-[[example]]
-name = "named-pipe-ready"
-path = "named-pipe-ready.rs"
-
-[[example]]
-name = "named-pipe-multi-client"
-path = "named-pipe-multi-client.rs"

examples/chat.rs

@@ -27,9 +27,9 @@
 #![warn(rust_2018_idioms)]
 
 use tokio::net::{TcpListener, TcpStream};
+use tokio::stream::{Stream, StreamExt};
 use tokio::sync::{mpsc, Mutex};
-use tokio_stream::StreamExt;
-use tokio_util::codec::{Framed, LinesCodec};
+use tokio_util::codec::{Framed, LinesCodec, LinesCodecError};
 
 use futures::SinkExt;
 use std::collections::HashMap;
@@ -37,7 +37,9 @@ use std::env;
 use std::error::Error;
 use std::io;
 use std::net::SocketAddr;
+use std::pin::Pin;
 use std::sync::Arc;
+use std::task::{Context, Poll};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
@@ -75,7 +77,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     // Bind a TCP listener to the socket address.
     //
     // Note that this is the Tokio TcpListener, which is fully async.
-    let listener = TcpListener::bind(&addr).await?;
+    let mut listener = TcpListener::bind(&addr).await?;
 
     tracing::info!("server running on {}", addr);
 
@@ -166,6 +168,43 @@ impl Peer {
     }
 }
 
+#[derive(Debug)]
+enum Message {
+    /// A message that should be broadcasted to others.
+    Broadcast(String),
+
+    /// A message that should be received by a client
+    Received(String),
+}
+
+// Peer implements `Stream` in a way that polls both the `Rx`, and `Framed` types.
+// A message is produced whenever an event is ready until the `Framed` stream returns `None`.
+impl Stream for Peer {
+    type Item = Result<Message, LinesCodecError>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        // First poll the `UnboundedReceiver`.
+
+        if let Poll::Ready(Some(v)) = Pin::new(&mut self.rx).poll_next(cx) {
+            return Poll::Ready(Some(Ok(Message::Received(v))));
+        }
+
+        // Secondly poll the `Framed` stream.
+        let result: Option<_> = futures::ready!(Pin::new(&mut self.lines).poll_next(cx));
+
+        Poll::Ready(match result {
+            // We've received a message we should broadcast to others.
+            Some(Ok(message)) => Some(Ok(Message::Broadcast(message))),
+
+            // An error occurred.
+            Some(Err(e)) => Some(Err(e)),
+
+            // The stream has been exhausted.
+            None => None,
+        })
+    }
+}
+
 /// Process an individual chat client
 async fn process(
     state: Arc<Mutex<Shared>>,
@@ -199,32 +238,28 @@ async fn process(
     }
 
     // Process incoming messages until our stream is exhausted by a disconnect.
-    loop {
-        tokio::select! {
-            // A message was received from a peer. Send it to the current user.
-            Some(msg) = peer.rx.recv() => {
+    while let Some(result) = peer.next().await {
+        match result {
+            // A message was received from the current user, we should
+            // broadcast this message to the other users.
+            Ok(Message::Broadcast(msg)) => {
+                let mut state = state.lock().await;
+                let msg = format!("{}: {}", username, msg);
+
+                state.broadcast(addr, &msg).await;
+            }
+            // A message was received from a peer. Send it to the
+            // current user.
+            Ok(Message::Received(msg)) => {
                 peer.lines.send(&msg).await?;
             }
-            result = peer.lines.next() => match result {
-                // A message was received from the current user, we should
-                // broadcast this message to the other users.
-                Some(Ok(msg)) => {
-                    let mut state = state.lock().await;
-                    let msg = format!("{}: {}", username, msg);
-
-                    state.broadcast(addr, &msg).await;
-                }
-                // An error occurred.
-                Some(Err(e)) => {
-                    tracing::error!(
-                        "an error occurred while processing messages for {}; error = {:?}",
-                        username,
-                        e
-                    );
-                }
-                // The stream has been exhausted.
-                None => break,
-            },
+            Err(e) => {
+                tracing::error!(
+                    "an error occurred while processing messages for {}; error = {:?}",
+                    username,
+                    e
+                );
+            }
         }
     }
 

examples/connect.rs

@@ -92,10 +92,11 @@ mod tcp {
 
 mod udp {
     use bytes::Bytes;
-    use futures::{Sink, SinkExt, Stream, StreamExt};
+    use futures::{future, Sink, SinkExt, Stream, StreamExt};
     use std::error::Error;
     use std::io;
     use std::net::SocketAddr;
+    use tokio::net::udp::{RecvHalf, SendHalf};
     use tokio::net::UdpSocket;
 
     pub async fn connect(
@@ -113,15 +114,16 @@ mod udp {
 
         let socket = UdpSocket::bind(&bind_addr).await?;
         socket.connect(addr).await?;
+        let (mut r, mut w) = socket.split();
 
-        tokio::try_join!(send(stdin, &socket), recv(stdout, &socket))?;
+        future::try_join(send(stdin, &mut w), recv(stdout, &mut r)).await?;
 
         Ok(())
     }
 
     async fn send(
         mut stdin: impl Stream<Item = Result<Bytes, io::Error>> + Unpin,
-        writer: &UdpSocket,
+        writer: &mut SendHalf,
     ) -> Result<(), io::Error> {
         while let Some(item) = stdin.next().await {
             let buf = item?;
@@ -133,7 +135,7 @@ mod udp {
 
     async fn recv(
         mut stdout: impl Sink<Bytes, Error = io::Error> + Unpin,
-        reader: &UdpSocket,
+        reader: &mut RecvHalf,
     ) -> Result<(), io::Error> {
         loop {
             let mut buf = vec![0; 1024];

examples/custom-executor-tokio-context.rs

@@ -1,32 +0,0 @@
-// This example shows how to use the tokio runtime with any other executor
-//
-//It takes advantage from RuntimeExt which provides the extension to customize your
-//runtime.
-
-use tokio::net::TcpListener;
-use tokio::runtime::Builder;
-use tokio::sync::oneshot;
-use tokio_util::context::RuntimeExt;
-
-fn main() {
-    let (tx, rx) = oneshot::channel();
-    let rt1 = Builder::new_multi_thread()
-        .worker_threads(1)
-        // no timer!
-        .build()
-        .unwrap();
-    let rt2 = Builder::new_multi_thread()
-        .worker_threads(1)
-        .enable_all()
-        .build()
-        .unwrap();
-
-    // Without the `HandleExt.wrap()` there would be a panic because there is
-    // no timer running, since it would be referencing runtime r1.
-    let _ = rt1.block_on(rt2.wrap(async move {
-        let listener = TcpListener::bind("0.0.0.0:0").await.unwrap();
-        println!("addr: {:?}", listener.local_addr());
-        tx.send(()).unwrap();
-    }));
-    futures::executor::block_on(rx).unwrap();
-}

examples/custom-executor.rs

@@ -1,56 +0,0 @@
-// This example shows how to use the tokio runtime with any other executor
-//
-// The main components are a spawn fn that will wrap futures in a special future
-// that will always enter the tokio context on poll. This only spawns one extra thread
-// to manage and run the tokio drivers in the background.
-
-use tokio::net::TcpListener;
-use tokio::sync::oneshot;
-
-fn main() {
-    let (tx, rx) = oneshot::channel();
-
-    my_custom_runtime::spawn(async move {
-        let listener = TcpListener::bind("0.0.0.0:0").await.unwrap();
-
-        println!("addr: {:?}", listener.local_addr());
-
-        tx.send(()).unwrap();
-    });
-
-    futures::executor::block_on(rx).unwrap();
-}
-
-mod my_custom_runtime {
-    use once_cell::sync::Lazy;
-    use std::future::Future;
-    use tokio_util::context::TokioContext;
-
-    pub fn spawn(f: impl Future<Output = ()> + Send + 'static) {
-        EXECUTOR.spawn(f);
-    }
-
-    struct ThreadPool {
-        inner: futures::executor::ThreadPool,
-        rt: tokio::runtime::Runtime,
-    }
-
-    static EXECUTOR: Lazy<ThreadPool> = Lazy::new(|| {
-        // Spawn tokio runtime on a single background thread
-        // enabling IO and timers.
-        let rt = tokio::runtime::Builder::new_multi_thread()
-            .enable_all()
-            .build()
-            .unwrap();
-        let inner = futures::executor::ThreadPool::builder().create().unwrap();
-
-        ThreadPool { inner, rt }
-    });
-
-    impl ThreadPool {
-        fn spawn(&self, f: impl Future<Output = ()> + Send + 'static) {
-            let handle = self.rt.handle().clone();
-            self.inner.spawn_ok(TokioContext::new(f, handle));
-        }
-    }
-}

examples/echo-udp.rs

@@ -26,7 +26,7 @@ struct Server {
 impl Server {
     async fn run(self) -> Result<(), io::Error> {
         let Server {
-            socket,
+            mut socket,
             mut buf,
             mut to_send,
         } = self;

examples/echo.rs

@@ -39,7 +39,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     // Next up we create a TCP listener which will listen for incoming
     // connections. This TCP listener is bound to the address we determined
     // above and must be associated with an event loop.
-    let listener = TcpListener::bind(&addr).await?;
+    let mut listener = TcpListener::bind(&addr).await?;
     println!("Listening on: {}", addr);
 
     loop {
@@ -55,7 +55,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
         // which will allow all of our clients to be processed concurrently.
 
         tokio::spawn(async move {
-            let mut buf = vec![0; 1024];
+            let mut buf = [0; 1024];
 
             // In a loop, read data from the socket and write the data back.
             loop {

examples/named-pipe-multi-client.rs

@@ -1,98 +0,0 @@
-use std::io;
-
-#[cfg(windows)]
-async fn windows_main() -> io::Result<()> {
-    use std::time::Duration;
-    use tokio::io::{AsyncReadExt, AsyncWriteExt};
-    use tokio::net::windows::named_pipe::{ClientOptions, ServerOptions};
-    use tokio::time;
-    use winapi::shared::winerror;
-
-    const PIPE_NAME: &str = r"\\.\pipe\named-pipe-multi-client";
-    const N: usize = 10;
-
-    // The first server needs to be constructed early so that clients can
-    // be correctly connected. Otherwise a waiting client will error.
-    //
-    // Here we also make use of `first_pipe_instance`, which will ensure
-    // that there are no other servers up and running already.
-    let mut server = ServerOptions::new()
-        .first_pipe_instance(true)
-        .create(PIPE_NAME)?;
-
-    let server = tokio::spawn(async move {
-        // Artificial workload.
-        time::sleep(Duration::from_secs(1)).await;
-
-        for _ in 0..N {
-            // Wait for client to connect.
-            server.connect().await?;
-            let mut inner = server;
-
-            // Construct the next server to be connected before sending the one
-            // we already have of onto a task. This ensures that the server
-            // isn't closed (after it's done in the task) before a new one is
-            // available. Otherwise the client might error with
-            // `io::ErrorKind::NotFound`.
-            server = ServerOptions::new().create(PIPE_NAME)?;
-
-            let _ = tokio::spawn(async move {
-                let mut buf = vec![0u8; 4];
-                inner.read_exact(&mut buf).await?;
-                inner.write_all(b"pong").await?;
-                Ok::<_, io::Error>(())
-            });
-        }
-
-        Ok::<_, io::Error>(())
-    });
-
-    let mut clients = Vec::new();
-
-    for _ in 0..N {
-        clients.push(tokio::spawn(async move {
-            // This showcases a generic connect loop.
-            //
-            // We immediately try to create a client, if it's not found or
-            // the pipe is busy we use the specialized wait function on the
-            // client builder.
-            let mut client = loop {
-                match ClientOptions::new().open(PIPE_NAME) {
-                    Ok(client) => break client,
-                    Err(e) if e.raw_os_error() == Some(winerror::ERROR_PIPE_BUSY as i32) => (),
-                    Err(e) => return Err(e),
-                }
-
-                time::sleep(Duration::from_millis(5)).await;
-            };
-
-            let mut buf = [0u8; 4];
-            client.write_all(b"ping").await?;
-            client.read_exact(&mut buf).await?;
-            Ok::<_, io::Error>(buf)
-        }));
-    }
-
-    for client in clients {
-        let result = client.await?;
-        assert_eq!(&result?[..], b"pong");
-    }
-
-    server.await??;
-    Ok(())
-}
-
-#[tokio::main]
-async fn main() -> io::Result<()> {
-    #[cfg(windows)]
-    {
-        windows_main().await?;
-    }
-
-    #[cfg(not(windows))]
-    {
-        println!("Named pipes are only supported on Windows!");
-    }
-
-    Ok(())
-}

examples/named-pipe-ready.rs

@@ -1,161 +0,0 @@
-use std::io;
-
-#[cfg(windows)]
-async fn windows_main() -> io::Result<()> {
-    use tokio::io::Interest;
-    use tokio::net::windows::named_pipe::{ClientOptions, ServerOptions};
-
-    const PIPE_NAME: &str = r"\\.\pipe\named-pipe-single-client";
-
-    let server = ServerOptions::new().create(PIPE_NAME)?;
-
-    let server = tokio::spawn(async move {
-        // Note: we wait for a client to connect.
-        server.connect().await?;
-
-        let buf = {
-            let mut read_buf = [0u8; 5];
-            let mut read_buf_cursor = 0;
-
-            loop {
-                server.readable().await?;
-
-                let buf = &mut read_buf[read_buf_cursor..];
-
-                match server.try_read(buf) {
-                    Ok(n) => {
-                        read_buf_cursor += n;
-
-                        if read_buf_cursor == read_buf.len() {
-                            break;
-                        }
-                    }
-                    Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
-                        continue;
-                    }
-                    Err(e) => {
-                        return Err(e);
-                    }
-                }
-            }
-
-            read_buf
-        };
-
-        {
-            let write_buf = b"pong\n";
-            let mut write_buf_cursor = 0;
-
-            loop {
-                let buf = &write_buf[write_buf_cursor..];
-
-                if buf.is_empty() {
-                    break;
-                }
-
-                server.writable().await?;
-
-                match server.try_write(buf) {
-                    Ok(n) => {
-                        write_buf_cursor += n;
-                    }
-                    Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
-                        continue;
-                    }
-                    Err(e) => {
-                        return Err(e);
-                    }
-                }
-            }
-        }
-
-        Ok::<_, io::Error>(buf)
-    });
-
-    let client = tokio::spawn(async move {
-        // There's no need to use a connect loop here, since we know that the
-        // server is already up - `open` was called before spawning any of the
-        // tasks.
-        let client = ClientOptions::new().open(PIPE_NAME)?;
-
-        let mut read_buf = [0u8; 5];
-        let mut read_buf_cursor = 0;
-        let write_buf = b"ping\n";
-        let mut write_buf_cursor = 0;
-
-        loop {
-            let mut interest = Interest::READABLE;
-            if write_buf_cursor < write_buf.len() {
-                interest |= Interest::WRITABLE;
-            }
-
-            let ready = client.ready(interest).await?;
-
-            if ready.is_readable() {
-                let buf = &mut read_buf[read_buf_cursor..];
-
-                match client.try_read(buf) {
-                    Ok(n) => {
-                        read_buf_cursor += n;
-
-                        if read_buf_cursor == read_buf.len() {
-                            break;
-                        }
-                    }
-                    Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
-                        continue;
-                    }
-                    Err(e) => {
-                        return Err(e);
-                    }
-                }
-            }
-
-            if ready.is_writable() {
-                let buf = &write_buf[write_buf_cursor..];
-
-                if buf.is_empty() {
-                    continue;
-                }
-
-                match client.try_write(buf) {
-                    Ok(n) => {
-                        write_buf_cursor += n;
-                    }
-                    Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
-                        continue;
-                    }
-                    Err(e) => {
-                        return Err(e);
-                    }
-                }
-            }
-        }
-
-        let buf = String::from_utf8_lossy(&read_buf).into_owned();
-
-        Ok::<_, io::Error>(buf)
-    });
-
-    let (server, client) = tokio::try_join!(server, client)?;
-
-    assert_eq!(server?, *b"ping\n");
-    assert_eq!(client?, "pong\n");
-
-    Ok(())
-}
-
-#[tokio::main]
-async fn main() -> io::Result<()> {
-    #[cfg(windows)]
-    {
-        windows_main().await?;
-    }
-
-    #[cfg(not(windows))]
-    {
-        println!("Named pipes are only supported on Windows!");
-    }
-
-    Ok(())
-}

examples/named-pipe.rs

@@ -1,60 +0,0 @@
-use std::io;
-
-#[cfg(windows)]
-async fn windows_main() -> io::Result<()> {
-    use tokio::io::AsyncWriteExt;
-    use tokio::io::{AsyncBufReadExt, BufReader};
-    use tokio::net::windows::named_pipe::{ClientOptions, ServerOptions};
-
-    const PIPE_NAME: &str = r"\\.\pipe\named-pipe-single-client";
-
-    let server = ServerOptions::new().create(PIPE_NAME)?;
-
-    let server = tokio::spawn(async move {
-        // Note: we wait for a client to connect.
-        server.connect().await?;
-
-        let mut server = BufReader::new(server);
-
-        let mut buf = String::new();
-        server.read_line(&mut buf).await?;
-        server.write_all(b"pong\n").await?;
-        Ok::<_, io::Error>(buf)
-    });
-
-    let client = tokio::spawn(async move {
-        // There's no need to use a connect loop here, since we know that the
-        // server is already up - `open` was called before spawning any of the
-        // tasks.
-        let client = ClientOptions::new().open(PIPE_NAME)?;
-
-        let mut client = BufReader::new(client);
-
-        let mut buf = String::new();
-        client.write_all(b"ping\n").await?;
-        client.read_line(&mut buf).await?;
-        Ok::<_, io::Error>(buf)
-    });
-
-    let (server, client) = tokio::try_join!(server, client)?;
-
-    assert_eq!(server?, "ping\n");
-    assert_eq!(client?, "pong\n");
-
-    Ok(())
-}
-
-#[tokio::main]
-async fn main() -> io::Result<()> {
-    #[cfg(windows)]
-    {
-        windows_main().await?;
-    }
-
-    #[cfg(not(windows))]
-    {
-        println!("Named pipes are only supported on Windows!");
-    }
-
-    Ok(())
-}

examples/print_each_packet.rs

@@ -55,7 +55,7 @@
 #![warn(rust_2018_idioms)]
 
 use tokio::net::TcpListener;
-use tokio_stream::StreamExt;
+use tokio::stream::StreamExt;
 use tokio_util::codec::{BytesCodec, Decoder};
 
 use std::env;
@@ -74,7 +74,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // above and must be associated with an event loop, so we pass in a handle
     // to our event loop. After the socket's created we inform that we're ready
     // to go and start accepting connections.
-    let listener = TcpListener::bind(&addr).await?;
+    let mut listener = TcpListener::bind(&addr).await?;
     println!("Listening on: {}", addr);
 
     loop {

examples/proxy.rs

@@ -26,6 +26,7 @@ use tokio::io;
 use tokio::io::AsyncWriteExt;
 use tokio::net::{TcpListener, TcpStream};
 
+use futures::future::try_join;
 use futures::FutureExt;
 use std::env;
 use std::error::Error;
@@ -42,7 +43,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     println!("Listening on: {}", listen_addr);
     println!("Proxying to: {}", server_addr);
 
-    let listener = TcpListener::bind(listen_addr).await?;
+    let mut listener = TcpListener::bind(listen_addr).await?;
 
     while let Ok((inbound, _)) = listener.accept().await {
         let transfer = transfer(inbound, server_addr.clone()).map(|r| {
@@ -73,7 +74,7 @@ async fn transfer(mut inbound: TcpStream, proxy_addr: String) -> Result<(), Box<
         wi.shutdown().await
     };
 
-    tokio::try_join!(client_to_server, server_to_client)?;
+    try_join(client_to_server, server_to_client).await?;
 
     Ok(())
 }

examples/tinydb.rs

@@ -42,7 +42,7 @@
 #![warn(rust_2018_idioms)]
 
 use tokio::net::TcpListener;
-use tokio_stream::StreamExt;
+use tokio::stream::StreamExt;
 use tokio_util::codec::{Framed, LinesCodec};
 
 use futures::SinkExt;
@@ -89,7 +89,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
         .nth(1)
         .unwrap_or_else(|| "127.0.0.1:8080".to_string());
 
-    let listener = TcpListener::bind(&addr).await?;
+    let mut listener = TcpListener::bind(&addr).await?;
     println!("Listening on: {}", addr);
 
     // Create the shared state of this server that will be shared amongst all
@@ -149,7 +149,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 }
 
 fn handle_request(line: &str, db: &Arc<Database>) -> Response {
-    let request = match Request::parse(line) {
+    let request = match Request::parse(&line) {
         Ok(req) => req,
         Err(e) => return Response::Error { msg: e },
     };

examples/tinyhttp.rs

@@ -20,7 +20,7 @@ use http::{header::HeaderValue, Request, Response, StatusCode};
 extern crate serde_derive;
 use std::{env, error::Error, fmt, io};
 use tokio::net::{TcpListener, TcpStream};
-use tokio_stream::StreamExt;
+use tokio::stream::StreamExt;
 use tokio_util::codec::{Decoder, Encoder, Framed};
 
 #[tokio::main]
@@ -30,17 +30,19 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let addr = env::args()
         .nth(1)
         .unwrap_or_else(|| "127.0.0.1:8080".to_string());
-    let server = TcpListener::bind(&addr).await?;
+    let mut server = TcpListener::bind(&addr).await?;
+    let mut incoming = server.incoming();
     println!("Listening on: {}", addr);
 
-    loop {
-        let (stream, _) = server.accept().await?;
+    while let Some(Ok(stream)) = incoming.next().await {
         tokio::spawn(async move {
             if let Err(e) = process(stream).await {
                 println!("failed to process connection; error = {}", e);
             }
         });
     }
+
+    Ok(())
 }
 
 async fn process(stream: TcpStream) -> Result<(), Box<dyn Error>> {
@@ -221,9 +223,8 @@ mod date {
     use std::cell::RefCell;
     use std::fmt::{self, Write};
     use std::str;
-    use std::time::SystemTime;
 
-    use httpdate::HttpDate;
+    use time::{self, Duration};
 
     pub struct Now(());
 
@@ -253,26 +254,22 @@ mod date {
     struct LastRenderedNow {
         bytes: [u8; 128],
         amt: usize,
-        unix_date: u64,
+        next_update: time::Timespec,
     }
 
     thread_local!(static LAST: RefCell<LastRenderedNow> = RefCell::new(LastRenderedNow {
         bytes: [0; 128],
         amt: 0,
-        unix_date: 0,
+        next_update: time::Timespec::new(0, 0),
     }));
 
     impl fmt::Display for Now {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             LAST.with(|cache| {
                 let mut cache = cache.borrow_mut();
-                let now = SystemTime::now();
-                let now_unix = now
-                    .duration_since(SystemTime::UNIX_EPOCH)
-                    .map(|since_epoch| since_epoch.as_secs())
-                    .unwrap_or(0);
-                if cache.unix_date != now_unix {
-                    cache.update(now, now_unix);
+                let now = time::get_time();
+                if now >= cache.next_update {
+                    cache.update(now);
                 }
                 f.write_str(cache.buffer())
             })
@@ -284,10 +281,11 @@ mod date {
             str::from_utf8(&self.bytes[..self.amt]).unwrap()
         }
 
-        fn update(&mut self, now: SystemTime, now_unix: u64) {
+        fn update(&mut self, now: time::Timespec) {
             self.amt = 0;
-            self.unix_date = now_unix;
-            write!(LocalBuffer(self), "{}", HttpDate::from(now)).unwrap();
+            write!(LocalBuffer(self), "{}", time::at(now).rfc822()).unwrap();
+            self.next_update = now + Duration::seconds(1);
+            self.next_update.nsec = 0;
         }
     }
 

examples/udp-client.rs

@@ -55,7 +55,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     }
     .parse()?;
 
-    let socket = UdpSocket::bind(local_addr).await?;
+    let mut socket = UdpSocket::bind(local_addr).await?;
     const MAX_DATAGRAM_SIZE: usize = 65_507;
     socket.connect(&remote_addr).await?;
     let data = get_stdin_data()?;

examples/udp-codec.rs

@@ -9,8 +9,8 @@
 #![warn(rust_2018_idioms)]
 
 use tokio::net::UdpSocket;
+use tokio::stream::StreamExt;
 use tokio::{io, time};
-use tokio_stream::StreamExt;
 use tokio_util::codec::BytesCodec;
 use tokio_util::udp::UdpFramed;
 
@@ -45,7 +45,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let b = pong(&mut b);
 
     // Run both futures simultaneously of `a` and `b` sending messages back and forth.
-    match tokio::try_join!(a, b) {
+    match futures::future::try_join(a, b).await {
         Err(e) => println!("an error occurred; error = {:?}", e),
         _ => println!("done!"),
     }

netlify.toml

@@ -1,16 +0,0 @@
-[build]
-  command = """
-    rustup install nightly --profile minimal && cargo doc --no-deps --all-features
-    """
-  publish = "target/doc"
-
-[build.environment]
-  RUSTDOCFLAGS="""
-    --cfg docsrs \
-    --cfg tokio_unstable \
-    """
-  RUSTFLAGS="--cfg tokio_unstable --cfg docsrs"
-
-[[redirects]]
-  from = "/"
-  to = "/tokio"

stress-test/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "stress-test"
-version = "0.1.0"
-authors = ["Tokio Contributors <[email protected]>"]
-edition = "2018"
-publish = false
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-tokio = { path = "../tokio/", features = ["full"] }
-
-[dev-dependencies]
-rand = "0.8"

stress-test/examples/simple_echo_tcp.rs

@@ -1,58 +0,0 @@
-//! Simple TCP echo server to check memory leaks using Valgrind.
-use std::{thread::sleep, time::Duration};
-
-use tokio::{
-    io::{AsyncReadExt, AsyncWriteExt},
-    net::{TcpListener, TcpSocket},
-    runtime::Builder,
-    sync::oneshot,
-};
-
-const TCP_ENDPOINT: &str = "127.0.0.1:8080";
-const NUM_MSGS: usize = 100;
-const MSG_SIZE: usize = 1024;
-
-fn main() {
-    let rt = Builder::new_multi_thread().enable_io().build().unwrap();
-    let rt2 = Builder::new_multi_thread().enable_io().build().unwrap();
-
-    rt.spawn(async {
-        let listener = TcpListener::bind(TCP_ENDPOINT).await.unwrap();
-        let (mut socket, _) = listener.accept().await.unwrap();
-        let (mut rd, mut wr) = socket.split();
-        while tokio::io::copy(&mut rd, &mut wr).await.is_ok() {}
-    });
-
-    // wait a bit so that the listener binds.
-    sleep(Duration::from_millis(100));
-
-    // create a channel to let the main thread know that all the messages were sent and received.
-    let (tx, mut rx) = oneshot::channel();
-
-    rt2.spawn(async {
-        let addr = TCP_ENDPOINT.parse().unwrap();
-        let socket = TcpSocket::new_v4().unwrap();
-        let mut stream = socket.connect(addr).await.unwrap();
-
-        let mut buff = [0; MSG_SIZE];
-        for _ in 0..NUM_MSGS {
-            let one_mega_random_bytes: Vec<u8> =
-                (0..MSG_SIZE).map(|_| rand::random::<u8>()).collect();
-            stream
-                .write_all(one_mega_random_bytes.as_slice())
-                .await
-                .unwrap();
-            stream.read(&mut buff).await.unwrap();
-        }
-        tx.send(()).unwrap();
-    });
-
-    loop {
-        // check that we're done.
-        match rx.try_recv() {
-            Err(oneshot::error::TryRecvError::Empty) => (),
-            Err(oneshot::error::TryRecvError::Closed) => panic!("channel got closed..."),
-            Ok(()) => break,
-        }
-    }
-}

tests-build/Cargo.toml

@@ -7,7 +7,6 @@ publish = false
 
 [features]
 full = ["tokio/full"]
-rt = ["tokio/rt", "tokio/macros"]
 
 [dependencies]
 tokio = { path = "../tokio", optional = true }

tests-build/tests/fail/macros_core_no_default.rs

@@ -1,6 +0,0 @@
-use tests_build::tokio;
-
-#[tokio::main]
-async fn my_fn() {}
-
-fn main() {}

tests-build/tests/fail/macros_core_no_default.stderr

@@ -1,7 +0,0 @@
-error: The default runtime flavor is `multi_thread`, but the `rt-multi-thread` feature is disabled.
- --> tests/fail/macros_core_no_default.rs:3:1
-  |
-3 | #[tokio::main]
-  | ^^^^^^^^^^^^^^
-  |
-  = note: this error originates in the attribute macro `tokio::main` (in Nightly builds, run with -Z macro-backtrace for more info)

tests-build/tests/fail/macros_dead_code.rs

@@ -1,8 +0,0 @@
-#![deny(dead_code)]
-
-use tests_build::tokio;
-
-#[tokio::main]
-async fn f() {}
-
-fn main() {}

tests-build/tests/fail/macros_dead_code.stderr

@@ -1,11 +0,0 @@
-error: function is never used: `f`
- --> $DIR/macros_dead_code.rs:6:10
-  |
-6 | async fn f() {}
-  |          ^
-  |
-note: the lint level is defined here
- --> $DIR/macros_dead_code.rs:1:9
-  |
-1 | #![deny(dead_code)]
-  |         ^^^^^^^^^

tests-build/tests/fail/macros_invalid_input.rs

@@ -1,5 +1,3 @@
-#![deny(duplicate_macro_attributes)]
-
 use tests_build::tokio;
 
 #[tokio::main]
@@ -14,36 +12,12 @@ async fn main_attr_has_path_args() {}
 #[tokio::test]
 fn test_is_not_async() {}
 
+#[tokio::test]
+async fn test_fn_has_args(_x: u8) {}
+
 #[tokio::test(foo)]
 async fn test_attr_has_args() {}
 
-#[tokio::test(foo = 123)]
-async fn test_unexpected_attr() {}
-
-#[tokio::test(flavor = 123)]
-async fn test_flavor_not_string() {}
-
-#[tokio::test(flavor = "foo")]
-async fn test_unknown_flavor() {}
-
-#[tokio::test(flavor = "multi_thread", start_paused = false)]
-async fn test_multi_thread_with_start_paused() {}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = "foo")]
-async fn test_worker_threads_not_int() {}
-
-#[tokio::test(flavor = "current_thread", worker_threads = 4)]
-async fn test_worker_threads_and_current_thread() {}
-
-#[tokio::test(crate = 456)]
-async fn test_crate_not_ident_int() {}
-
-#[tokio::test(crate = "456")]
-async fn test_crate_not_ident_invalid() {}
-
-#[tokio::test(crate = "abc::edf")]
-async fn test_crate_not_ident_path() {}
-
 #[tokio::test]
 #[test]
 async fn test_has_second_test_attr() {}

tests-build/tests/fail/macros_invalid_input.stderr

@@ -1,101 +1,41 @@
-error: the `async` keyword is missing from the function declaration
- --> $DIR/macros_invalid_input.rs:6:1
+error: the async keyword is missing from the function declaration
+ --> $DIR/macros_invalid_input.rs:4:1
   |
-6 | fn main_is_not_async() {}
+4 | fn main_is_not_async() {}
   | ^^
 
-error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`
- --> $DIR/macros_invalid_input.rs:8:15
+error: Unknown attribute foo is specified; expected `basic_scheduler` or `threaded_scheduler`
+ --> $DIR/macros_invalid_input.rs:6:15
   |
-8 | #[tokio::main(foo)]
+6 | #[tokio::main(foo)]
   |               ^^^
 
 error: Must have specified ident
-  --> $DIR/macros_invalid_input.rs:11:15
-   |
-11 | #[tokio::main(threadpool::bar)]
-   |               ^^^^^^^^^^^^^^^
+ --> $DIR/macros_invalid_input.rs:9:15
+  |
+9 | #[tokio::main(threadpool::bar)]
+  |               ^^^^^^^^^^^^^^^
 
-error: the `async` keyword is missing from the function declaration
-  --> $DIR/macros_invalid_input.rs:15:1
+error: the async keyword is missing from the function declaration
+  --> $DIR/macros_invalid_input.rs:13:1
    |
-15 | fn test_is_not_async() {}
+13 | fn test_is_not_async() {}
    | ^^
 
-error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`
-  --> $DIR/macros_invalid_input.rs:17:15
+error: the test function cannot accept arguments
+  --> $DIR/macros_invalid_input.rs:16:27
    |
-17 | #[tokio::test(foo)]
+16 | async fn test_fn_has_args(_x: u8) {}
+   |                           ^^^^^^
+
+error: Unknown attribute foo is specified; expected `basic_scheduler` or `threaded_scheduler`
+  --> $DIR/macros_invalid_input.rs:18:15
+   |
+18 | #[tokio::test(foo)]
    |               ^^^
 
-error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`
-  --> $DIR/macros_invalid_input.rs:20:15
-   |
-20 | #[tokio::test(foo = 123)]
-   |               ^^^^^^^^^
-
-error: Failed to parse value of `flavor` as string.
-  --> $DIR/macros_invalid_input.rs:23:24
-   |
-23 | #[tokio::test(flavor = 123)]
-   |                        ^^^
-
-error: No such runtime flavor `foo`. The runtime flavors are `current_thread` and `multi_thread`.
-  --> $DIR/macros_invalid_input.rs:26:24
-   |
-26 | #[tokio::test(flavor = "foo")]
-   |                        ^^^^^
-
-error: The `start_paused` option requires the `current_thread` runtime flavor. Use `#[tokio::test(flavor = "current_thread")]`
-  --> $DIR/macros_invalid_input.rs:29:55
-   |
-29 | #[tokio::test(flavor = "multi_thread", start_paused = false)]
-   |                                                       ^^^^^
-
-error: Failed to parse value of `worker_threads` as integer.
-  --> $DIR/macros_invalid_input.rs:32:57
-   |
-32 | #[tokio::test(flavor = "multi_thread", worker_threads = "foo")]
-   |                                                         ^^^^^
-
-error: The `worker_threads` option requires the `multi_thread` runtime flavor. Use `#[tokio::test(flavor = "multi_thread")]`
-  --> $DIR/macros_invalid_input.rs:35:59
-   |
-35 | #[tokio::test(flavor = "current_thread", worker_threads = 4)]
-   |                                                           ^
-
-error: Failed to parse value of `crate` as ident.
-  --> $DIR/macros_invalid_input.rs:38:23
-   |
-38 | #[tokio::test(crate = 456)]
-   |                       ^^^
-
-error: Failed to parse value of `crate` as ident: "456"
-  --> $DIR/macros_invalid_input.rs:41:23
-   |
-41 | #[tokio::test(crate = "456")]
-   |                       ^^^^^
-
-error: Failed to parse value of `crate` as ident: "abc::edf"
-  --> $DIR/macros_invalid_input.rs:44:23
-   |
-44 | #[tokio::test(crate = "abc::edf")]
-   |                       ^^^^^^^^^^
-
 error: second test attribute is supplied
-  --> $DIR/macros_invalid_input.rs:48:1
+  --> $DIR/macros_invalid_input.rs:22:1
    |
-48 | #[test]
+22 | #[test]
    | ^^^^^^^
-
-error: duplicated attribute
-  --> $DIR/macros_invalid_input.rs:48:1
-   |
-48 | #[test]
-   | ^^^^^^^
-   |
-note: the lint level is defined here
-  --> $DIR/macros_invalid_input.rs:1:9
-   |
-1  | #![deny(duplicate_macro_attributes)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^

tests-build/tests/fail/macros_type_mismatch.rs

@@ -1,35 +0,0 @@
-use tests_build::tokio;
-
-#[tokio::main]
-async fn missing_semicolon_or_return_type() {
-    Ok(())
-}
-
-#[tokio::main]
-async fn missing_return_type() {
-    return Ok(());
-}
-
-#[tokio::main]
-async fn extra_semicolon() -> Result<(), ()> {
-    /* TODO(taiki-e): help message still wrong
-    help: try using a variant of the expected enum
-       |
-    23 |     Ok(Ok(());)
-       |
-    23 |     Err(Ok(());)
-       |
-    */
-    Ok(());
-}
-
-// https://github.com/tokio-rs/tokio/issues/4635
-#[allow(redundant_semicolons)]
-#[rustfmt::skip]
-#[tokio::main]
-async fn issue_4635() {
-    return 1;
-    ;
-}
-
-fn main() {}

tests-build/tests/fail/macros_type_mismatch.stderr

@@ -1,47 +0,0 @@
-error[E0308]: mismatched types
- --> $DIR/macros_type_mismatch.rs:5:5
-  |
-4 | async fn missing_semicolon_or_return_type() {
-  |                                             - help: a return type might be missing here: `-> _`
-5 |     Ok(())
-  |     ^^^^^^ expected `()`, found enum `Result`
-  |
-  = note: expected unit type `()`
-                  found enum `Result<(), _>`
-
-error[E0308]: mismatched types
-  --> $DIR/macros_type_mismatch.rs:10:5
-   |
-9  | async fn missing_return_type() {
-   |                                - help: a return type might be missing here: `-> _`
-10 |     return Ok(());
-   |     ^^^^^^^^^^^^^^ expected `()`, found enum `Result`
-   |
-   = note: expected unit type `()`
-                   found enum `Result<(), _>`
-
-error[E0308]: mismatched types
-  --> $DIR/macros_type_mismatch.rs:23:5
-   |
-14 | async fn extra_semicolon() -> Result<(), ()> {
-   |                               -------------- expected `Result<(), ()>` because of return type
-...
-23 |     Ok(());
-   |     ^^^^^^^ expected enum `Result`, found `()`
-   |
-   = note:   expected enum `Result<(), ()>`
-           found unit type `()`
-help: try adding an expression at the end of the block
-   |
-23 ~     Ok(());;
-24 +     Ok(())
-   |
-
-error[E0308]: mismatched types
-  --> $DIR/macros_type_mismatch.rs:32:5
-   |
-30 | async fn issue_4635() {
-   |                       - help: try adding a return type: `-> i32`
-31 |     return 1;
-32 |     ;
-   |     ^ expected `()`, found integer

tests-build/tests/macros.rs

@@ -1,27 +1,9 @@
 #[test]
-fn compile_fail_full() {
+fn compile_fail() {
     let t = trybuild::TestCases::new();
 
-    #[cfg(feature = "full")]
-    t.pass("tests/pass/forward_args_and_output.rs");
-
-    #[cfg(feature = "full")]
-    t.pass("tests/pass/macros_main_return.rs");
-
-    #[cfg(feature = "full")]
-    t.pass("tests/pass/macros_main_loop.rs");
-
     #[cfg(feature = "full")]
     t.compile_fail("tests/fail/macros_invalid_input.rs");
 
-    #[cfg(feature = "full")]
-    t.compile_fail("tests/fail/macros_dead_code.rs");
-
-    #[cfg(feature = "full")]
-    t.compile_fail("tests/fail/macros_type_mismatch.rs");
-
-    #[cfg(all(feature = "rt", not(feature = "full")))]
-    t.compile_fail("tests/fail/macros_core_no_default.rs");
-
     drop(t);
 }

tests-build/tests/macros_clippy.rs

@@ -1,7 +0,0 @@
-#[cfg(feature = "full")]
-#[tokio::test]
-async fn test_with_semicolon_without_return_type() {
-    #![deny(clippy::semicolon_if_nothing_returned)]
-
-    dbg!(0);
-}

tests-build/tests/pass/forward_args_and_output.rs

@@ -1,13 +0,0 @@
-use tests_build::tokio;
-
-fn main() {}
-
-// arguments and output type is forwarded so other macros can access them
-
-#[tokio::test]
-async fn test_fn_has_args(_x: u8) {}
-
-#[tokio::test]
-async fn test_has_output() -> Result<(), Box<dyn std::error::Error>> {
-    Ok(())
-}

tests-build/tests/pass/macros_main_loop.rs

@@ -1,14 +0,0 @@
-use tests_build::tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), ()> {
-    loop {
-        if !never() {
-            return Ok(());
-        }
-    }
-}
-
-fn never() -> bool {
-    std::time::Instant::now() > std::time::Instant::now()
-}

tests-build/tests/pass/macros_main_return.rs

@@ -1,6 +0,0 @@
-use tests_build::tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), ()> {
-    return Ok(());
-}

tests-integration/Cargo.toml

@@ -5,58 +5,24 @@ authors = ["Tokio Contributors <[email protected]>"]
 edition = "2018"
 publish = false
 
-[[bin]]
-name = "test-cat"
-required-features = ["rt-process-io-util"]
-
-[[bin]]
-name = "test-mem"
-required-features = ["rt-net"]
-
-[[bin]]
-name = "test-process-signal"
-required-features = ["rt-process-signal"]
-
-[[test]]
-name = "macros_main"
-
-[[test]]
-name = "macros_pin"
-
-[[test]]
-name = "macros_select"
-
-[[test]]
-name = "rt_yield"
-required-features = ["rt", "macros", "sync"]
-
 [features]
-rt-process-io-util = ["tokio/rt", "tokio/macros", "tokio/process", "tokio/io-util", "tokio/io-std"]
-# For mem check
-rt-net = ["tokio/rt", "tokio/rt-multi-thread", "tokio/net"]
-# For test-process-signal
-rt-process-signal = ["rt-net", "tokio/process", "tokio/signal"]
-# For testing wasi + rt/macros/sync features
-#
-# This is an explicit feature so we can use `cargo hack` testing single features
-# instead of all possible permutations.
-wasi-rt = ["rt", "macros", "sync"]
-
 full = [
     "macros",
-    "rt",
-    "rt-multi-thread",
+    "rt-core",
+    "rt-threaded",
 
     "tokio/full",
     "tokio-test"
 ]
 macros = ["tokio/macros"]
 sync = ["tokio/sync"]
-rt = ["tokio/rt"]
-rt-multi-thread = ["rt", "tokio/rt-multi-thread"]
+rt-core = ["tokio/rt-core"]
+rt-threaded = ["rt-core", "tokio/rt-threaded"]
 
 [dependencies]
 tokio = { path = "../tokio" }
 tokio-test = { path = "../tokio-test", optional = true }
 doc-comment = "0.3.1"
+
+[dev-dependencies]
 futures = { version = "0.3.0", features = ["async-await"] }

tests-integration/src/bin/test-cat.rs

@@ -1,14 +1,20 @@
 //! A cat-like utility that can be used as a subprocess to test I/O
 //! stream communication.
 
-use tokio::io::AsyncWriteExt;
+use std::io;
+use std::io::Write;
 
-#[tokio::main(flavor = "current_thread")]
-async fn main() {
-    let mut stdin = tokio::io::stdin();
-    let mut stdout = tokio::io::stdout();
-
-    tokio::io::copy(&mut stdin, &mut stdout).await.unwrap();
-
-    stdout.flush().await.unwrap();
+fn main() {
+    let stdin = io::stdin();
+    let mut stdout = io::stdout();
+    let mut line = String::new();
+    loop {
+        line.clear();
+        stdin.read_line(&mut line).unwrap();
+        if line.is_empty() {
+            break;
+        }
+        stdout.write_all(line.as_bytes()).unwrap();
+    }
+    stdout.flush().unwrap();
 }

tests-integration/src/bin/test-mem.rs

@@ -1,21 +0,0 @@
-use futures::future::poll_fn;
-
-fn main() {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(1)
-        .enable_io()
-        .build()
-        .unwrap();
-
-    rt.block_on(async {
-        let listener = tokio::net::TcpListener::bind("0.0.0.0:0").await.unwrap();
-        tokio::spawn(async move {
-            loop {
-                poll_fn(|cx| listener.poll_accept(cx)).await.unwrap();
-            }
-        });
-    });
-
-    std::thread::sleep(std::time::Duration::from_millis(50));
-    drop(rt);
-}

tests-integration/src/bin/test-process-signal.rs

@@ -1,11 +0,0 @@
-// https://github.com/tokio-rs/tokio/issues/3550
-fn main() {
-    for _ in 0..1000 {
-        let rt = tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .unwrap();
-
-        drop(rt);
-    }
-}

tests-integration/tests/macros_main.rs

@@ -1,4 +1,4 @@
-#![cfg(all(feature = "macros", feature = "rt-multi-thread"))]
+#![cfg(feature = "macros")]
 
 #[tokio::main]
 async fn basic_main() -> usize {
@@ -10,15 +10,18 @@ async fn generic_fun<T: Default>() -> T {
     T::default()
 }
 
-#[tokio::main]
-async fn spawning() -> usize {
-    let join = tokio::spawn(async { 1 });
-    join.await.unwrap()
-}
+#[cfg(feature = "rt-core")]
+mod spawn {
+    #[tokio::main]
+    async fn spawning() -> usize {
+        let join = tokio::spawn(async { 1 });
+        join.await.unwrap()
+    }
 
-#[test]
-fn main_with_spawn() {
-    assert_eq!(1, spawning());
+    #[test]
+    fn main_with_spawn() {
+        assert_eq!(1, spawning());
+    }
 }
 
 #[test]

tests-integration/tests/process_stdio.rs

@@ -1,29 +1,26 @@
 #![warn(rust_2018_idioms)]
 #![cfg(feature = "full")]
 
-use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
-use tokio::join;
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::process::{Child, Command};
 use tokio_test::assert_ok;
 
 use futures::future::{self, FutureExt};
-use std::convert::TryInto;
+use std::env;
 use std::io;
 use std::process::{ExitStatus, Stdio};
 
-// so, we need to change this back as a test, but for now this doesn't work because of:
-// https://github.com/rust-lang/rust/pull/95469
-//
-// undo when this is closed: https://github.com/tokio-rs/tokio/issues/4802
-
-// fn cat() -> Command {
-//     let mut cmd = Command::new(std::env!("CARGO_BIN_EXE_test-cat"));
-//     cmd.stdin(Stdio::piped()).stdout(Stdio::piped());
-//     cmd
-// }
-
 fn cat() -> Command {
-    let mut cmd = Command::new("cat");
+    let mut me = env::current_exe().unwrap();
+    me.pop();
+
+    if me.ends_with("deps") {
+        me.pop();
+    }
+
+    me.push("test-cat");
+
+    let mut cmd = Command::new(me);
     cmd.stdin(Stdio::piped()).stdout(Stdio::piped());
     cmd
 }
@@ -75,7 +72,7 @@ async fn feed_cat(mut cat: Child, n: usize) -> io::Result<ExitStatus> {
     };
 
     // Compose reading and writing concurrently.
-    future::join3(write, read, cat.wait())
+    future::join3(write, read, cat)
         .map(|(_, _, status)| status)
         .await
 }
@@ -128,75 +125,3 @@ async fn status_closes_any_pipes() {
 
     assert_ok!(child.await);
 }
-
-#[tokio::test]
-async fn try_wait() {
-    let mut child = cat().spawn().unwrap();
-
-    let id = child.id().expect("missing id");
-    assert!(id > 0);
-
-    assert_eq!(None, assert_ok!(child.try_wait()));
-
-    // Drop the child's stdio handles so it can terminate
-    drop(child.stdin.take());
-    drop(child.stderr.take());
-    drop(child.stdout.take());
-
-    assert_ok!(child.wait().await);
-
-    // test that the `.try_wait()` method is fused just like the stdlib
-    assert!(assert_ok!(child.try_wait()).unwrap().success());
-
-    // Can't get id after process has exited
-    assert_eq!(child.id(), None);
-}
-
-#[tokio::test]
-async fn pipe_from_one_command_to_another() {
-    let mut first = cat().spawn().expect("first cmd");
-    let mut third = cat().spawn().expect("third cmd");
-
-    // Convert ChildStdout to Stdio
-    let second_stdin: Stdio = first
-        .stdout
-        .take()
-        .expect("first.stdout")
-        .try_into()
-        .expect("first.stdout into Stdio");
-
-    // Convert ChildStdin to Stdio
-    let second_stdout: Stdio = third
-        .stdin
-        .take()
-        .expect("third.stdin")
-        .try_into()
-        .expect("third.stdin into Stdio");
-
-    let mut second = cat()
-        .stdin(second_stdin)
-        .stdout(second_stdout)
-        .spawn()
-        .expect("first cmd");
-
-    let msg = "hello world! please pipe this message through";
-
-    let mut stdin = first.stdin.take().expect("first.stdin");
-    let write = async move { stdin.write_all(msg.as_bytes()).await };
-
-    let mut stdout = third.stdout.take().expect("third.stdout");
-    let read = async move {
-        let mut data = String::new();
-        stdout.read_to_string(&mut data).await.map(|_| data)
-    };
-
-    let (read, write, first_status, second_status, third_status) =
-        join!(read, write, first.wait(), second.wait(), third.wait());
-
-    assert_eq!(msg, read.expect("read result"));
-    write.expect("write result");
-
-    assert!(first_status.expect("first status").success());
-    assert!(second_status.expect("second status").success());
-    assert!(third_status.expect("third status").success());
-}

tests-integration/tests/rt_shell.rs

@@ -0,0 +1,32 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "sync")]
+
+use tokio::runtime;
+use tokio::sync::oneshot;
+
+use std::sync::mpsc;
+use std::thread;
+
+#[test]
+fn basic_shell_rt() {
+    let (feed_tx, feed_rx) = mpsc::channel::<oneshot::Sender<()>>();
+
+    let th = thread::spawn(move || {
+        for tx in feed_rx.iter() {
+            tx.send(()).unwrap();
+        }
+    });
+
+    for _ in 0..1_000 {
+        let mut rt = runtime::Builder::new().build().unwrap();
+
+        let (tx, rx) = oneshot::channel();
+
+        feed_tx.send(tx).unwrap();
+
+        rt.block_on(rx).unwrap();
+    }
+
+    drop(feed_tx);
+    th.join().unwrap();
+}

tests-integration/tests/rt_yield.rs

@@ -1,41 +0,0 @@
-use tokio::sync::oneshot;
-use tokio::task;
-
-async fn spawn_send() {
-    let (tx, rx) = oneshot::channel();
-
-    let task = tokio::spawn(async {
-        for _ in 0..10 {
-            task::yield_now().await;
-        }
-
-        tx.send("done").unwrap();
-    });
-
-    assert_eq!("done", rx.await.unwrap());
-    task.await.unwrap();
-}
-
-#[tokio::main(flavor = "current_thread")]
-async fn entry_point() {
-    spawn_send().await;
-}
-
-#[tokio::test]
-async fn test_macro() {
-    spawn_send().await;
-}
-
-#[test]
-fn main_macro() {
-    entry_point();
-}
-
-#[test]
-fn manual_rt() {
-    let rt = tokio::runtime::Builder::new_current_thread()
-        .build()
-        .unwrap();
-
-    rt.block_on(async { spawn_send().await });
-}

tokio-macros/CHANGELOG.md

@@ -1,94 +1,3 @@
-# 1.8.0 (June 4th, 2022)
-
-- macros: always emit return statement ([#4636])
-- macros: support setting a custom crate name for `#[tokio::main]` and `#[tokio::test]` ([#4613])
-
-[#4613]: https://github.com/tokio-rs/tokio/pull/4613
-[#4636]: https://github.com/tokio-rs/tokio/pull/4636
-
-# 1.7.0 (December 15th, 2021)
-
-- macros: address remaining `clippy::semicolon_if_nothing_returned` warning ([#4252])
-
-[#4252]: https://github.com/tokio-rs/tokio/pull/4252
-
-# 1.6.0 (November 16th, 2021)
-
-- macros: fix mut patterns in `select!` macro ([#4211])
-
-[#4211]: https://github.com/tokio-rs/tokio/pull/4211
-
-# 1.5.1 (October 29th, 2021)
-
-- macros: fix type resolution error in `#[tokio::main]` ([#4176])
-
-[#4176]: https://github.com/tokio-rs/tokio/pull/4176
-
-# 1.5.0 (October 13th, 2021)
-
-- macros: make tokio-macros attributes more IDE friendly ([#4162])
-
-[#4162]: https://github.com/tokio-rs/tokio/pull/4162
-
-# 1.4.1 (September 30th, 2021)
-
-Reverted: run `current_thread` inside `LocalSet` ([#4027])
-
-# 1.4.0 (September 29th, 2021)
-
-(yanked)
-
-### Changed
-
-- macros: run `current_thread` inside `LocalSet` ([#4027])
-- macros: explicitly relaxed clippy lint for `.expect()` in runtime entry macro ([#4030])
-
-### Fixed
-
-- macros: fix invalid error messages in functions wrapped with `#[main]` or `#[test]` ([#4067])
-
-[#4027]: https://github.com/tokio-rs/tokio/pull/4027
-[#4030]: https://github.com/tokio-rs/tokio/pull/4030
-[#4067]: https://github.com/tokio-rs/tokio/pull/4067
-
-# 1.3.0 (July 7, 2021)
-
-- macros: don't trigger `clippy::unwrap_used` ([#3926])
-
-[#3926]: https://github.com/tokio-rs/tokio/pull/3926
-
-# 1.2.0 (May 14, 2021)
-
-- macros: forward input arguments in `#[tokio::test]` ([#3691])
-- macros: improve diagnostics on type mismatch ([#3766])
-- macros: various error message improvements ([#3677])
-
-[#3677]: https://github.com/tokio-rs/tokio/pull/3677
-[#3691]: https://github.com/tokio-rs/tokio/pull/3691
-[#3766]: https://github.com/tokio-rs/tokio/pull/3766
-
-# 1.1.0 (February 5, 2021)
-
-- add `start_paused` option to macros ([#3492])
-
-# 1.0.0 (December 23, 2020)
-
-- track `tokio` 1.0 release.
-
-# 0.3.1 (October 25, 2020)
-
-### Fixed
-
-- fix incorrect docs regarding `max_threads` option ([#3038])
-
-# 0.3.0 (October 15, 2020)
-
-- Track `tokio` 0.3 release.
-
-### Changed
-- options are renamed to track `tokio` runtime builder fn names.
-- `#[tokio::main]` macro requires `rt-multi-thread` when no `flavor` is specified.
-
 # 0.2.5 (February 27, 2019)
 
 ### Fixed
@@ -121,11 +30,9 @@ Reverted: run `current_thread` inside `LocalSet` ([#4027])
 
 - Initial release
 
-[#1954]: https://github.com/tokio-rs/tokio/pull/1954
-[#2022]: https://github.com/tokio-rs/tokio/pull/2022
-[#2038]: https://github.com/tokio-rs/tokio/pull/2038
-[#2152]: https://github.com/tokio-rs/tokio/pull/2152
-[#2177]: https://github.com/tokio-rs/tokio/pull/2177
 [#2225]: https://github.com/tokio-rs/tokio/pull/2225
-[#3038]: https://github.com/tokio-rs/tokio/pull/3038
-[#3492]: https://github.com/tokio-rs/tokio/pull/3492
+[#2177]: https://github.com/tokio-rs/tokio/pull/2177
+[#2152]: https://github.com/tokio-rs/tokio/pull/2152
+[#2038]: https://github.com/tokio-rs/tokio/pull/2038
+[#2022]: https://github.com/tokio-rs/tokio/pull/2022
+[#1954]: https://github.com/tokio-rs/tokio/pull/1954

tokio-macros/Cargo.toml

@@ -2,15 +2,18 @@
 name = "tokio-macros"
 # When releasing to crates.io:
 # - Remove path dependencies
+# - Update html_root_url.
+# - Update doc url
+#   - Cargo.toml
 # - Update CHANGELOG.md.
-# - Create "tokio-macros-1.0.x" git tag.
-version = "1.8.0"
+# - Create "v0.1.x" git tag.
+version = "0.2.5"
 edition = "2018"
-rust-version = "1.49"
 authors = ["Tokio Contributors <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/tokio-rs/tokio"
 homepage = "https://tokio.rs"
+documentation = "https://docs.rs/tokio-macros/0.2.5/tokio_macros"
 description = """
 Tokio's proc macros.
 """
@@ -24,10 +27,10 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0.7"
 quote = "1"
-syn = { version = "1.0.56", features = ["full"] }
+syn = { version = "1.0.3", features = ["full"] }
 
 [dev-dependencies]
-tokio = { version = "1.0.0", path = "../tokio", features = ["full"] }
+tokio = { version = "0.2.0", path = "../tokio", features = ["full"] }
 
 [package.metadata.docs.rs]
 all-features = true

tokio-macros/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2022 Tokio Contributors
+Copyright (c) 2019 Tokio Contributors
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

tokio-macros/src/entry.rs

@@ -1,325 +1,123 @@
 use proc_macro::TokenStream;
-use proc_macro2::{Ident, Span};
-use quote::{quote, quote_spanned, ToTokens};
-use syn::parse::Parser;
-
-// syn::AttributeArgs does not implement syn::Parse
-type AttributeArgs = syn::punctuated::Punctuated<syn::NestedMeta, syn::Token![,]>;
+use quote::quote;
+use std::num::NonZeroUsize;
 
 #[derive(Clone, Copy, PartialEq)]
-enum RuntimeFlavor {
-    CurrentThread,
+enum Runtime {
+    Basic,
     Threaded,
 }
 
-impl RuntimeFlavor {
-    fn from_str(s: &str) -> Result<RuntimeFlavor, String> {
-        match s {
-            "current_thread" => Ok(RuntimeFlavor::CurrentThread),
-            "multi_thread" => Ok(RuntimeFlavor::Threaded),
-            "single_thread" => Err("The single threaded runtime flavor is called `current_thread`.".to_string()),
-            "basic_scheduler" => Err("The `basic_scheduler` runtime flavor has been renamed to `current_thread`.".to_string()),
-            "threaded_scheduler" => Err("The `threaded_scheduler` runtime flavor has been renamed to `multi_thread`.".to_string()),
-            _ => Err(format!("No such runtime flavor `{}`. The runtime flavors are `current_thread` and `multi_thread`.", s)),
-        }
-    }
-}
-
-struct FinalConfig {
-    flavor: RuntimeFlavor,
-    worker_threads: Option<usize>,
-    start_paused: Option<bool>,
-    crate_name: Option<String>,
-}
-
-/// Config used in case of the attribute not being able to build a valid config
-const DEFAULT_ERROR_CONFIG: FinalConfig = FinalConfig {
-    flavor: RuntimeFlavor::CurrentThread,
-    worker_threads: None,
-    start_paused: None,
-    crate_name: None,
-};
-
-struct Configuration {
-    rt_multi_thread_available: bool,
-    default_flavor: RuntimeFlavor,
-    flavor: Option<RuntimeFlavor>,
-    worker_threads: Option<(usize, Span)>,
-    start_paused: Option<(bool, Span)>,
+fn parse_knobs(
+    mut input: syn::ItemFn,
+    args: syn::AttributeArgs,
     is_test: bool,
-    crate_name: Option<String>,
-}
+    rt_threaded: bool,
+) -> Result<TokenStream, syn::Error> {
+    let sig = &mut input.sig;
+    let body = &input.block;
+    let attrs = &input.attrs;
+    let vis = input.vis;
 
-impl Configuration {
-    fn new(is_test: bool, rt_multi_thread: bool) -> Self {
-        Configuration {
-            rt_multi_thread_available: rt_multi_thread,
-            default_flavor: match is_test {
-                true => RuntimeFlavor::CurrentThread,
-                false => RuntimeFlavor::Threaded,
-            },
-            flavor: None,
-            worker_threads: None,
-            start_paused: None,
-            is_test,
-            crate_name: None,
-        }
+    if sig.asyncness.is_none() {
+        let msg = "the async keyword is missing from the function declaration";
+        return Err(syn::Error::new_spanned(sig.fn_token, msg));
     }
 
-    fn set_flavor(&mut self, runtime: syn::Lit, span: Span) -> Result<(), syn::Error> {
-        if self.flavor.is_some() {
-            return Err(syn::Error::new(span, "`flavor` set multiple times."));
-        }
+    sig.asyncness = None;
 
-        let runtime_str = parse_string(runtime, span, "flavor")?;
-        let runtime =
-            RuntimeFlavor::from_str(&runtime_str).map_err(|err| syn::Error::new(span, err))?;
-        self.flavor = Some(runtime);
-        Ok(())
-    }
-
-    fn set_worker_threads(
-        &mut self,
-        worker_threads: syn::Lit,
-        span: Span,
-    ) -> Result<(), syn::Error> {
-        if self.worker_threads.is_some() {
-            return Err(syn::Error::new(
-                span,
-                "`worker_threads` set multiple times.",
-            ));
-        }
-
-        let worker_threads = parse_int(worker_threads, span, "worker_threads")?;
-        if worker_threads == 0 {
-            return Err(syn::Error::new(span, "`worker_threads` may not be 0."));
-        }
-        self.worker_threads = Some((worker_threads, span));
-        Ok(())
-    }
-
-    fn set_start_paused(&mut self, start_paused: syn::Lit, span: Span) -> Result<(), syn::Error> {
-        if self.start_paused.is_some() {
-            return Err(syn::Error::new(span, "`start_paused` set multiple times."));
-        }
-
-        let start_paused = parse_bool(start_paused, span, "start_paused")?;
-        self.start_paused = Some((start_paused, span));
-        Ok(())
-    }
-
-    fn set_crate_name(&mut self, name: syn::Lit, span: Span) -> Result<(), syn::Error> {
-        if self.crate_name.is_some() {
-            return Err(syn::Error::new(span, "`crate` set multiple times."));
-        }
-        let name_ident = parse_ident(name, span, "crate")?;
-        self.crate_name = Some(name_ident.to_string());
-        Ok(())
-    }
-
-    fn macro_name(&self) -> &'static str {
-        if self.is_test {
-            "tokio::test"
-        } else {
-            "tokio::main"
-        }
-    }
-
-    fn build(&self) -> Result<FinalConfig, syn::Error> {
-        let flavor = self.flavor.unwrap_or(self.default_flavor);
-        use RuntimeFlavor::*;
-
-        let worker_threads = match (flavor, self.worker_threads) {
-            (CurrentThread, Some((_, worker_threads_span))) => {
-                let msg = format!(
-                    "The `worker_threads` option requires the `multi_thread` runtime flavor. Use `#[{}(flavor = \"multi_thread\")]`",
-                    self.macro_name(),
-                );
-                return Err(syn::Error::new(worker_threads_span, msg));
-            }
-            (CurrentThread, None) => None,
-            (Threaded, worker_threads) if self.rt_multi_thread_available => {
-                worker_threads.map(|(val, _span)| val)
-            }
-            (Threaded, _) => {
-                let msg = if self.flavor.is_none() {
-                    "The default runtime flavor is `multi_thread`, but the `rt-multi-thread` feature is disabled."
-                } else {
-                    "The runtime flavor `multi_thread` requires the `rt-multi-thread` feature."
-                };
-                return Err(syn::Error::new(Span::call_site(), msg));
-            }
-        };
-
-        let start_paused = match (flavor, self.start_paused) {
-            (Threaded, Some((_, start_paused_span))) => {
-                let msg = format!(
-                    "The `start_paused` option requires the `current_thread` runtime flavor. Use `#[{}(flavor = \"current_thread\")]`",
-                    self.macro_name(),
-                );
-                return Err(syn::Error::new(start_paused_span, msg));
-            }
-            (CurrentThread, Some((start_paused, _))) => Some(start_paused),
-            (_, None) => None,
-        };
-
-        Ok(FinalConfig {
-            crate_name: self.crate_name.clone(),
-            flavor,
-            worker_threads,
-            start_paused,
-        })
-    }
-}
-
-fn parse_int(int: syn::Lit, span: Span, field: &str) -> Result<usize, syn::Error> {
-    match int {
-        syn::Lit::Int(lit) => match lit.base10_parse::<usize>() {
-            Ok(value) => Ok(value),
-            Err(e) => Err(syn::Error::new(
-                span,
-                format!("Failed to parse value of `{}` as integer: {}", field, e),
-            )),
-        },
-        _ => Err(syn::Error::new(
-            span,
-            format!("Failed to parse value of `{}` as integer.", field),
-        )),
-    }
-}
-
-fn parse_string(int: syn::Lit, span: Span, field: &str) -> Result<String, syn::Error> {
-    match int {
-        syn::Lit::Str(s) => Ok(s.value()),
-        syn::Lit::Verbatim(s) => Ok(s.to_string()),
-        _ => Err(syn::Error::new(
-            span,
-            format!("Failed to parse value of `{}` as string.", field),
-        )),
-    }
-}
-
-fn parse_ident(lit: syn::Lit, span: Span, field: &str) -> Result<Ident, syn::Error> {
-    match lit {
-        syn::Lit::Str(s) => {
-            let err = syn::Error::new(
-                span,
-                format!(
-                    "Failed to parse value of `{}` as ident: \"{}\"",
-                    field,
-                    s.value()
-                ),
-            );
-            let path = s.parse::<syn::Path>().map_err(|_| err.clone())?;
-            path.get_ident().cloned().ok_or(err)
-        }
-        _ => Err(syn::Error::new(
-            span,
-            format!("Failed to parse value of `{}` as ident.", field),
-        )),
-    }
-}
-
-fn parse_bool(bool: syn::Lit, span: Span, field: &str) -> Result<bool, syn::Error> {
-    match bool {
-        syn::Lit::Bool(b) => Ok(b.value),
-        _ => Err(syn::Error::new(
-            span,
-            format!("Failed to parse value of `{}` as bool.", field),
-        )),
-    }
-}
-
-fn build_config(
-    input: syn::ItemFn,
-    args: AttributeArgs,
-    is_test: bool,
-    rt_multi_thread: bool,
-) -> Result<FinalConfig, syn::Error> {
-    if input.sig.asyncness.is_none() {
-        let msg = "the `async` keyword is missing from the function declaration";
-        return Err(syn::Error::new_spanned(input.sig.fn_token, msg));
-    }
-
-    let mut config = Configuration::new(is_test, rt_multi_thread);
-    let macro_name = config.macro_name();
+    let mut runtime = None;
+    let mut core_threads = None;
+    let mut max_threads = None;
 
     for arg in args {
         match arg {
             syn::NestedMeta::Meta(syn::Meta::NameValue(namevalue)) => {
-                let ident = namevalue
-                    .path
-                    .get_ident()
-                    .ok_or_else(|| {
-                        syn::Error::new_spanned(&namevalue, "Must have specified ident")
-                    })?
-                    .to_string()
-                    .to_lowercase();
-                match ident.as_str() {
-                    "worker_threads" => {
-                        config.set_worker_threads(
-                            namevalue.lit.clone(),
-                            syn::spanned::Spanned::span(&namevalue.lit),
-                        )?;
-                    }
-                    "flavor" => {
-                        config.set_flavor(
-                            namevalue.lit.clone(),
-                            syn::spanned::Spanned::span(&namevalue.lit),
-                        )?;
-                    }
-                    "start_paused" => {
-                        config.set_start_paused(
-                            namevalue.lit.clone(),
-                            syn::spanned::Spanned::span(&namevalue.lit),
-                        )?;
-                    }
+                let ident = namevalue.path.get_ident();
+                if ident.is_none() {
+                    let msg = "Must have specified ident";
+                    return Err(syn::Error::new_spanned(namevalue, msg));
+                }
+                match ident.unwrap().to_string().to_lowercase().as_str() {
                     "core_threads" => {
-                        let msg = "Attribute `core_threads` is renamed to `worker_threads`";
-                        return Err(syn::Error::new_spanned(namevalue, msg));
-                    }
-                    "crate" => {
-                        config.set_crate_name(
-                            namevalue.lit.clone(),
-                            syn::spanned::Spanned::span(&namevalue.lit),
-                        )?;
+                        if rt_threaded {
+                            match &namevalue.lit {
+                                syn::Lit::Int(expr) => {
+                                    let num = expr.base10_parse::<NonZeroUsize>().unwrap();
+                                    if num.get() > 1 {
+                                        runtime = Some(Runtime::Threaded);
+                                    } else {
+                                        runtime = Some(Runtime::Basic);
+                                    }
+
+                                    if let Some(v) = max_threads {
+                                        if v < num {
+                                            return Err(syn::Error::new_spanned(
+                                                namevalue,
+                                                "max_threads cannot be less than core_threads",
+                                            ));
+                                        }
+                                    }
+
+                                    core_threads = Some(num);
+                                }
+                                _ => {
+                                    return Err(syn::Error::new_spanned(
+                                        namevalue,
+                                        "core_threads argument must be an int",
+                                    ))
+                                }
+                            }
+                        } else {
+                            return Err(syn::Error::new_spanned(
+                                namevalue,
+                                "core_threads can only be set with rt-threaded feature flag enabled",
+                            ));
+                        }
                     }
+                    "max_threads" => match &namevalue.lit {
+                        syn::Lit::Int(expr) => {
+                            let num = expr.base10_parse::<NonZeroUsize>().unwrap();
+
+                            if let Some(v) = core_threads {
+                                if num < v {
+                                    return Err(syn::Error::new_spanned(
+                                        namevalue,
+                                        "max_threads cannot be less than core_threads",
+                                    ));
+                                }
+                            }
+                            max_threads = Some(num);
+                        }
+                        _ => {
+                            return Err(syn::Error::new_spanned(
+                                namevalue,
+                                "max_threads argument must be an int",
+                            ))
+                        }
+                    },
                     name => {
-                        let msg = format!(
-                            "Unknown attribute {} is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`",
-                            name,
-                        );
+                        let msg = format!("Unknown attribute pair {} is specified; expected one of: `core_threads`, `max_threads`", name);
                         return Err(syn::Error::new_spanned(namevalue, msg));
                     }
                 }
             }
             syn::NestedMeta::Meta(syn::Meta::Path(path)) => {
-                let name = path
-                    .get_ident()
-                    .ok_or_else(|| syn::Error::new_spanned(&path, "Must have specified ident"))?
-                    .to_string()
-                    .to_lowercase();
-                let msg = match name.as_str() {
-                    "threaded_scheduler" | "multi_thread" => {
-                        format!(
-                            "Set the runtime flavor with #[{}(flavor = \"multi_thread\")].",
-                            macro_name
-                        )
-                    }
-                    "basic_scheduler" | "current_thread" | "single_threaded" => {
-                        format!(
-                            "Set the runtime flavor with #[{}(flavor = \"current_thread\")].",
-                            macro_name
-                        )
-                    }
-                    "flavor" | "worker_threads" | "start_paused" => {
-                        format!("The `{}` attribute requires an argument.", name)
+                let ident = path.get_ident();
+                if ident.is_none() {
+                    let msg = "Must have specified ident";
+                    return Err(syn::Error::new_spanned(path, msg));
+                }
+                match ident.unwrap().to_string().to_lowercase().as_str() {
+                    "threaded_scheduler" => {
+                        runtime = Some(runtime.unwrap_or_else(|| Runtime::Threaded))
                     }
+                    "basic_scheduler" => runtime = Some(runtime.unwrap_or_else(|| Runtime::Basic)),
                     name => {
-                        format!("Unknown attribute {} is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`", name)
+                        let msg = format!("Unknown attribute {} is specified; expected `basic_scheduler` or `threaded_scheduler`", name);
+                        return Err(syn::Error::new_spanned(path, msg));
                     }
-                };
-                return Err(syn::Error::new_spanned(path, msg));
+                }
             }
             other => {
                 return Err(syn::Error::new_spanned(
@@ -330,132 +128,232 @@ fn build_config(
         }
     }
 
-    config.build()
-}
-
-fn parse_knobs(mut input: syn::ItemFn, is_test: bool, config: FinalConfig) -> TokenStream {
-    input.sig.asyncness = None;
-
-    // If type mismatch occurs, the current rustc points to the last statement.
-    let (last_stmt_start_span, last_stmt_end_span) = {
-        let mut last_stmt = input
-            .block
-            .stmts
-            .last()
-            .map(ToTokens::into_token_stream)
-            .unwrap_or_default()
-            .into_iter();
-        // `Span` on stable Rust has a limitation that only points to the first
-        // token, not the whole tokens. We can work around this limitation by
-        // using the first/last span of the tokens like
-        // `syn::Error::new_spanned` does.
-        let start = last_stmt.next().map_or_else(Span::call_site, |t| t.span());
-        let end = last_stmt.last().map_or(start, |t| t.span());
-        (start, end)
-    };
-
-    let crate_name = config.crate_name.as_deref().unwrap_or("tokio");
-
-    let crate_ident = Ident::new(crate_name, last_stmt_start_span);
-
-    let mut rt = match config.flavor {
-        RuntimeFlavor::CurrentThread => quote_spanned! {last_stmt_start_span=>
-            #crate_ident::runtime::Builder::new_current_thread()
-        },
-        RuntimeFlavor::Threaded => quote_spanned! {last_stmt_start_span=>
-            #crate_ident::runtime::Builder::new_multi_thread()
-        },
-    };
-    if let Some(v) = config.worker_threads {
-        rt = quote! { #rt.worker_threads(#v) };
+    let mut rt = quote! { tokio::runtime::Builder::new().basic_scheduler() };
+    if rt_threaded && (runtime == Some(Runtime::Threaded) || (runtime.is_none() && !is_test)) {
+        rt = quote! { #rt.threaded_scheduler() };
     }
-    if let Some(v) = config.start_paused {
-        rt = quote! { #rt.start_paused(#v) };
+    if let Some(v) = core_threads.map(|v| v.get()) {
+        rt = quote! { #rt.core_threads(#v) };
+    }
+    if let Some(v) = max_threads.map(|v| v.get()) {
+        rt = quote! { #rt.max_threads(#v) };
     }
 
-    let header = if is_test {
-        quote! {
-            #[::core::prelude::v1::test]
-        }
-    } else {
-        quote! {}
-    };
-
-    let body = &input.block;
-    let brace_token = input.block.brace_token;
-    input.block = syn::parse2(quote_spanned! {last_stmt_end_span=>
-        {
-            let body = async #body;
-            #[allow(clippy::expect_used, clippy::diverging_sub_expression)]
-            {
-                return #rt
-                    .enable_all()
-                    .build()
-                    .expect("Failed building the Runtime")
-                    .block_on(body);
+    let header = {
+        if is_test {
+            quote! {
+                #[::core::prelude::v1::test]
             }
+        } else {
+            quote! {}
         }
-    })
-    .expect("Parsing failure");
-    input.block.brace_token = brace_token;
+    };
 
     let result = quote! {
         #header
-        #input
+        #(#attrs)*
+        #vis #sig {
+            #rt
+                .enable_all()
+                .build()
+                .unwrap()
+                .block_on(async { #body })
+        }
     };
 
-    result.into()
-}
-
-fn token_stream_with_error(mut tokens: TokenStream, error: syn::Error) -> TokenStream {
-    tokens.extend(TokenStream::from(error.into_compile_error()));
-    tokens
+    Ok(result.into())
 }
 
 #[cfg(not(test))] // Work around for rust-lang/rust#62127
-pub(crate) fn main(args: TokenStream, item: TokenStream, rt_multi_thread: bool) -> TokenStream {
-    // If any of the steps for this macro fail, we still want to expand to an item that is as close
-    // to the expected output as possible. This helps out IDEs such that completions and other
-    // related features keep working.
-    let input: syn::ItemFn = match syn::parse(item.clone()) {
-        Ok(it) => it,
-        Err(e) => return token_stream_with_error(item, e),
-    };
+pub(crate) fn main(args: TokenStream, item: TokenStream, rt_threaded: bool) -> TokenStream {
+    let input = syn::parse_macro_input!(item as syn::ItemFn);
+    let args = syn::parse_macro_input!(args as syn::AttributeArgs);
 
-    let config = if input.sig.ident == "main" && !input.sig.inputs.is_empty() {
+    if input.sig.ident == "main" && !input.sig.inputs.is_empty() {
         let msg = "the main function cannot accept arguments";
-        Err(syn::Error::new_spanned(&input.sig.ident, msg))
-    } else {
-        AttributeArgs::parse_terminated
-            .parse(args)
-            .and_then(|args| build_config(input.clone(), args, false, rt_multi_thread))
-    };
-
-    match config {
-        Ok(config) => parse_knobs(input, false, config),
-        Err(e) => token_stream_with_error(parse_knobs(input, false, DEFAULT_ERROR_CONFIG), e),
+        return syn::Error::new_spanned(&input.sig.inputs, msg)
+            .to_compile_error()
+            .into();
     }
+
+    parse_knobs(input, args, false, rt_threaded).unwrap_or_else(|e| e.to_compile_error().into())
 }
 
-pub(crate) fn test(args: TokenStream, item: TokenStream, rt_multi_thread: bool) -> TokenStream {
-    // If any of the steps for this macro fail, we still want to expand to an item that is as close
-    // to the expected output as possible. This helps out IDEs such that completions and other
-    // related features keep working.
-    let input: syn::ItemFn = match syn::parse(item.clone()) {
-        Ok(it) => it,
-        Err(e) => return token_stream_with_error(item, e),
-    };
-    let config = if let Some(attr) = input.attrs.iter().find(|attr| attr.path.is_ident("test")) {
-        let msg = "second test attribute is supplied";
-        Err(syn::Error::new_spanned(&attr, msg))
-    } else {
-        AttributeArgs::parse_terminated
-            .parse(args)
-            .and_then(|args| build_config(input.clone(), args, true, rt_multi_thread))
-    };
+pub(crate) fn test(args: TokenStream, item: TokenStream, rt_threaded: bool) -> TokenStream {
+    let input = syn::parse_macro_input!(item as syn::ItemFn);
+    let args = syn::parse_macro_input!(args as syn::AttributeArgs);
 
-    match config {
-        Ok(config) => parse_knobs(input, true, config),
-        Err(e) => token_stream_with_error(parse_knobs(input, true, DEFAULT_ERROR_CONFIG), e),
+    for attr in &input.attrs {
+        if attr.path.is_ident("test") {
+            let msg = "second test attribute is supplied";
+            return syn::Error::new_spanned(&attr, msg)
+                .to_compile_error()
+                .into();
+        }
+    }
+
+    if !input.sig.inputs.is_empty() {
+        let msg = "the test function cannot accept arguments";
+        return syn::Error::new_spanned(&input.sig.inputs, msg)
+            .to_compile_error()
+            .into();
+    }
+
+    parse_knobs(input, args, true, rt_threaded).unwrap_or_else(|e| e.to_compile_error().into())
+}
+
+pub(crate) mod old {
+    use proc_macro::TokenStream;
+    use quote::quote;
+
+    enum Runtime {
+        Basic,
+        Threaded,
+        Auto,
+    }
+
+    #[cfg(not(test))] // Work around for rust-lang/rust#62127
+    pub(crate) fn main(args: TokenStream, item: TokenStream) -> TokenStream {
+        let mut input = syn::parse_macro_input!(item as syn::ItemFn);
+        let args = syn::parse_macro_input!(args as syn::AttributeArgs);
+
+        let sig = &mut input.sig;
+        let name = &sig.ident;
+        let inputs = &sig.inputs;
+        let body = &input.block;
+        let attrs = &input.attrs;
+        let vis = input.vis;
+
+        if sig.asyncness.is_none() {
+            let msg = "the async keyword is missing from the function declaration";
+            return syn::Error::new_spanned(sig.fn_token, msg)
+                .to_compile_error()
+                .into();
+        } else if name == "main" && !inputs.is_empty() {
+            let msg = "the main function cannot accept arguments";
+            return syn::Error::new_spanned(&sig.inputs, msg)
+                .to_compile_error()
+                .into();
+        }
+
+        sig.asyncness = None;
+
+        let mut runtime = Runtime::Auto;
+
+        for arg in args {
+            if let syn::NestedMeta::Meta(syn::Meta::Path(path)) = arg {
+                let ident = path.get_ident();
+                if ident.is_none() {
+                    let msg = "Must have specified ident";
+                    return syn::Error::new_spanned(path, msg).to_compile_error().into();
+                }
+                match ident.unwrap().to_string().to_lowercase().as_str() {
+                    "threaded_scheduler" => runtime = Runtime::Threaded,
+                    "basic_scheduler" => runtime = Runtime::Basic,
+                    name => {
+                        let msg = format!("Unknown attribute {} is specified; expected `basic_scheduler` or `threaded_scheduler`", name);
+                        return syn::Error::new_spanned(path, msg).to_compile_error().into();
+                    }
+                }
+            }
+        }
+
+        let result = match runtime {
+            Runtime::Threaded | Runtime::Auto => quote! {
+                #(#attrs)*
+                #vis #sig {
+                    tokio::runtime::Runtime::new().unwrap().block_on(async { #body })
+                }
+            },
+            Runtime::Basic => quote! {
+                #(#attrs)*
+                #vis #sig {
+                    tokio::runtime::Builder::new()
+                        .basic_scheduler()
+                        .enable_all()
+                        .build()
+                        .unwrap()
+                        .block_on(async { #body })
+                }
+            },
+        };
+
+        result.into()
+    }
+
+    pub(crate) fn test(args: TokenStream, item: TokenStream) -> TokenStream {
+        let input = syn::parse_macro_input!(item as syn::ItemFn);
+        let args = syn::parse_macro_input!(args as syn::AttributeArgs);
+
+        let ret = &input.sig.output;
+        let name = &input.sig.ident;
+        let body = &input.block;
+        let attrs = &input.attrs;
+        let vis = input.vis;
+
+        for attr in attrs {
+            if attr.path.is_ident("test") {
+                let msg = "second test attribute is supplied";
+                return syn::Error::new_spanned(&attr, msg)
+                    .to_compile_error()
+                    .into();
+            }
+        }
+
+        if input.sig.asyncness.is_none() {
+            let msg = "the async keyword is missing from the function declaration";
+            return syn::Error::new_spanned(&input.sig.fn_token, msg)
+                .to_compile_error()
+                .into();
+        } else if !input.sig.inputs.is_empty() {
+            let msg = "the test function cannot accept arguments";
+            return syn::Error::new_spanned(&input.sig.inputs, msg)
+                .to_compile_error()
+                .into();
+        }
+
+        let mut runtime = Runtime::Auto;
+
+        for arg in args {
+            if let syn::NestedMeta::Meta(syn::Meta::Path(path)) = arg {
+                let ident = path.get_ident();
+                if ident.is_none() {
+                    let msg = "Must have specified ident";
+                    return syn::Error::new_spanned(path, msg).to_compile_error().into();
+                }
+                match ident.unwrap().to_string().to_lowercase().as_str() {
+                    "threaded_scheduler" => runtime = Runtime::Threaded,
+                    "basic_scheduler" => runtime = Runtime::Basic,
+                    name => {
+                        let msg = format!("Unknown attribute {} is specified; expected `basic_scheduler` or `threaded_scheduler`", name);
+                        return syn::Error::new_spanned(path, msg).to_compile_error().into();
+                    }
+                }
+            }
+        }
+
+        let result = match runtime {
+            Runtime::Threaded => quote! {
+                #[::core::prelude::v1::test]
+                #(#attrs)*
+                #vis fn #name() #ret {
+                    tokio::runtime::Runtime::new().unwrap().block_on(async { #body })
+                }
+            },
+            Runtime::Basic | Runtime::Auto => quote! {
+                #[::core::prelude::v1::test]
+                #(#attrs)*
+                #vis fn #name() #ret {
+                    tokio::runtime::Builder::new()
+                        .basic_scheduler()
+                        .enable_all()
+                        .build()
+                        .unwrap()
+                        .block_on(async { #body })
+                }
+            },
+        };
+
+        result.into()
     }
 }

tokio-macros/src/lib.rs

@@ -1,3 +1,4 @@
+#![doc(html_root_url = "https://docs.rs/tokio-macros/0.2.5")]
 #![allow(clippy::needless_doctest_main)]
 #![warn(
     missing_debug_implementations,
@@ -5,6 +6,7 @@
     rust_2018_idioms,
     unreachable_pub
 )]
+#![cfg_attr(docsrs, deny(broken_intra_doc_links))]
 #![doc(test(
     no_crate_inject,
     attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
@@ -22,47 +24,18 @@ mod select;
 
 use proc_macro::TokenStream;
 
-/// Marks async function to be executed by the selected runtime. This macro
-/// helps set up a `Runtime` without requiring the user to use
-/// [Runtime](../tokio/runtime/struct.Runtime.html) or
-/// [Builder](../tokio/runtime/struct.Builder.html) directly.
+/// Marks async function to be executed by selected runtime. This macro helps set up a `Runtime`
+/// without requiring the user to use [Runtime](../tokio/runtime/struct.Runtime.html) or
+/// [Builder](../tokio/runtime/struct.builder.html) directly.
 ///
-/// Note: This macro is designed to be simplistic and targets applications that
-/// do not require a complex setup. If the provided functionality is not
-/// sufficient, you may be interested in using
-/// [Builder](../tokio/runtime/struct.Builder.html), which provides a more
-/// powerful interface.
+/// ## Options:
 ///
-/// Note: This macro can be used on any function and not just the `main`
-/// function. Using it on a non-main function makes the function behave as if it
-/// was synchronous by starting a new runtime each time it is called. If the
-/// function is called often, it is preferable to create the runtime using the
-/// runtime builder so the runtime can be reused across calls.
+/// If you want to set the number of worker threads used for asynchronous code, use the
+/// `core_threads` option.
 ///
-/// # Multi-threaded runtime
-///
-/// To use the multi-threaded runtime, the macro can be configured using
-///
-/// ```
-/// #[tokio::main(flavor = "multi_thread", worker_threads = 10)]
-/// # async fn main() {}
-/// ```
-///
-/// The `worker_threads` option configures the number of worker threads, and
-/// defaults to the number of cpus on the system. This is the default flavor.
-///
-/// Note: The multi-threaded runtime requires the `rt-multi-thread` feature
-/// flag.
-///
-/// # Current thread runtime
-///
-/// To use the single-threaded runtime known as the `current_thread` runtime,
-/// the macro can be configured using
-///
-/// ```
-/// #[tokio::main(flavor = "current_thread")]
-/// # async fn main() {}
-/// ```
+/// - `core_threads=n` - Sets core threads to `n` (requires `rt-threaded` feature).
+/// - `max_threads=n` - Sets max threads to `n` (requires `rt-core` or `rt-threaded` feature).
+/// - `basic_scheduler` - Use the basic schduler (requires `rt-core`).
 ///
 /// ## Function arguments:
 ///
@@ -70,7 +43,7 @@ use proc_macro::TokenStream;
 ///
 /// ## Usage
 ///
-/// ### Using the multi-thread runtime
+/// ### Using default
 ///
 /// ```rust
 /// #[tokio::main]
@@ -83,7 +56,8 @@ use proc_macro::TokenStream;
 ///
 /// ```rust
 /// fn main() {
-///     tokio::runtime::Builder::new_multi_thread()
+///     tokio::runtime::Builder::new()
+///         .threaded_scheduler()
 ///         .enable_all()
 ///         .build()
 ///         .unwrap()
@@ -93,12 +67,12 @@ use proc_macro::TokenStream;
 /// }
 /// ```
 ///
-/// ### Using current thread runtime
+/// ### Using basic scheduler
 ///
 /// The basic scheduler is single-threaded.
 ///
 /// ```rust
-/// #[tokio::main(flavor = "current_thread")]
+/// #[tokio::main(basic_scheduler)]
 /// async fn main() {
 ///     println!("Hello world");
 /// }
@@ -108,7 +82,8 @@ use proc_macro::TokenStream;
 ///
 /// ```rust
 /// fn main() {
-///     tokio::runtime::Builder::new_current_thread()
+///     tokio::runtime::Builder::new()
+///         .basic_scheduler()
 ///         .enable_all()
 ///         .build()
 ///         .unwrap()
@@ -118,10 +93,10 @@ use proc_macro::TokenStream;
 /// }
 /// ```
 ///
-/// ### Set number of worker threads
+/// ### Set number of core threads
 ///
 /// ```rust
-/// #[tokio::main(worker_threads = 2)]
+/// #[tokio::main(core_threads = 2)]
 /// async fn main() {
 ///     println!("Hello world");
 /// }
@@ -131,8 +106,9 @@ use proc_macro::TokenStream;
 ///
 /// ```rust
 /// fn main() {
-///     tokio::runtime::Builder::new_multi_thread()
-///         .worker_threads(2)
+///     tokio::runtime::Builder::new()
+///         .threaded_scheduler()
+///         .core_threads(2)
 ///         .enable_all()
 ///         .build()
 ///         .unwrap()
@@ -142,61 +118,16 @@ use proc_macro::TokenStream;
 /// }
 /// ```
 ///
-/// ### Configure the runtime to start with time paused
+/// ### NOTE:
 ///
-/// ```rust
-/// #[tokio::main(flavor = "current_thread", start_paused = true)]
-/// async fn main() {
-///     println!("Hello world");
-/// }
-/// ```
-///
-/// Equivalent code not using `#[tokio::main]`
-///
-/// ```rust
-/// fn main() {
-///     tokio::runtime::Builder::new_current_thread()
-///         .enable_all()
-///         .start_paused(true)
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             println!("Hello world");
-///         })
-/// }
-/// ```
-///
-/// Note that `start_paused` requires the `test-util` feature to be enabled.
-///
-/// ### Rename package
-///
-/// ```rust
-/// use tokio as tokio1;
-///
-/// #[tokio1::main(crate = "tokio1")]
-/// async fn main() {
-///     println!("Hello world");
-/// }
-/// ```
-///
-/// Equivalent code not using `#[tokio::main]`
-///
-/// ```rust
-/// use tokio as tokio1;
-///
-/// fn main() {
-///     tokio1::runtime::Builder::new_multi_thread()
-///         .enable_all()
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             println!("Hello world");
-///         })
-/// }
-/// ```
+/// If you rename the tokio crate in your dependencies this macro
+/// will not work. If you must rename the 0.2 version of tokio because
+/// you're also using the 0.1 version of tokio, you _must_ make the
+/// tokio 0.2 crate available as `tokio` in the module where this
+/// macro is expanded.
 #[proc_macro_attribute]
 #[cfg(not(test))] // Work around for rust-lang/rust#62127
-pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
+pub fn main_threaded(args: TokenStream, item: TokenStream) -> TokenStream {
     entry::main(args, item, true)
 }
 
@@ -204,6 +135,11 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
 /// without requiring the user to use [Runtime](../tokio/runtime/struct.Runtime.html) or
 /// [Builder](../tokio/runtime/struct.builder.html) directly.
 ///
+/// ## Options:
+///
+/// - `basic_scheduler` - All tasks are executed on the current thread.
+/// - `threaded_scheduler` - Uses the multi-threaded scheduler. Used by default (requires `rt-threaded` feature).
+///
 /// ## Function arguments:
 ///
 /// Arguments are allowed for any functions aside from `main` which is special
@@ -213,7 +149,7 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
 /// ### Using default
 ///
 /// ```rust
-/// #[tokio::main(flavor = "current_thread")]
+/// #[tokio::main]
 /// async fn main() {
 ///     println!("Hello world");
 /// }
@@ -223,9 +159,7 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
 ///
 /// ```rust
 /// fn main() {
-///     tokio::runtime::Builder::new_current_thread()
-///         .enable_all()
-///         .build()
+///     tokio::runtime::Runtime::new()
 ///         .unwrap()
 ///         .block_on(async {
 ///             println!("Hello world");
@@ -233,12 +167,10 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
 /// }
 /// ```
 ///
-/// ### Rename package
+/// ### Select runtime
 ///
 /// ```rust
-/// use tokio as tokio1;
-///
-/// #[tokio1::main(crate = "tokio1")]
+/// #[tokio::main(basic_scheduler)]
 /// async fn main() {
 ///     println!("Hello world");
 /// }
@@ -247,10 +179,9 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
 /// Equivalent code not using `#[tokio::main]`
 ///
 /// ```rust
-/// use tokio as tokio1;
-///
 /// fn main() {
-///     tokio1::runtime::Builder::new_multi_thread()
+///     tokio::runtime::Builder::new()
+///         .basic_scheduler()
 ///         .enable_all()
 ///         .build()
 ///         .unwrap()
@@ -259,80 +190,90 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
 ///         })
 /// }
 /// ```
+///
+/// ### NOTE:
+///
+/// If you rename the tokio crate in your dependencies this macro
+/// will not work. If you must rename the 0.2 version of tokio because
+/// you're also using the 0.1 version of tokio, you _must_ make the
+/// tokio 0.2 crate available as `tokio` in the module where this
+/// macro is expanded.
 #[proc_macro_attribute]
 #[cfg(not(test))] // Work around for rust-lang/rust#62127
-pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream {
-    entry::main(args, item, false)
+pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
+    entry::old::main(args, item)
 }
 
-/// Marks async function to be executed by runtime, suitable to test environment.
-/// This macro helps set up a `Runtime` without requiring the user to use
-/// [Runtime](../tokio/runtime/struct.Runtime.html) or
-/// [Builder](../tokio/runtime/struct.Builder.html) directly.
+/// Marks async function to be executed by selected runtime. This macro helps set up a `Runtime`
+/// without requiring the user to use [Runtime](../tokio/runtime/struct.Runtime.html) or
+/// [Builder](../tokio/runtime/struct.builder.html) directly.
 ///
-/// Note: This macro is designed to be simplistic and targets applications that
-/// do not require a complex setup. If the provided functionality is not
-/// sufficient, you may be interested in using
-/// [Builder](../tokio/runtime/struct.Builder.html), which provides a more
-/// powerful interface.
+/// ## Options:
 ///
-/// # Multi-threaded runtime
+/// - `max_threads=n` - Sets max threads to `n`.
 ///
-/// To use the multi-threaded runtime, the macro can be configured using
+/// ## Function arguments:
 ///
-/// ```no_run
-/// #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
-/// async fn my_test() {
-///     assert!(true);
-/// }
-/// ```
-///
-/// The `worker_threads` option configures the number of worker threads, and
-/// defaults to the number of cpus on the system. This is the default
-/// flavor.
-///
-/// Note: The multi-threaded runtime requires the `rt-multi-thread` feature
-/// flag.
-///
-/// # Current thread runtime
-///
-/// The default test runtime is single-threaded. Each test gets a
-/// separate current-thread runtime.
-///
-/// ```no_run
-/// #[tokio::test]
-/// async fn my_test() {
-///     assert!(true);
-/// }
-/// ```
+/// Arguments are allowed for any functions aside from `main` which is special
 ///
 /// ## Usage
 ///
-/// ### Using the multi-thread runtime
+/// ### Using default
+///
+/// ```rust
+/// #[tokio::main]
+/// async fn main() {
+///     println!("Hello world");
+/// }
+/// ```
+///
+/// Equivalent code not using `#[tokio::main]`
+///
+/// ```rust
+/// fn main() {
+///     tokio::runtime::Builder::new()
+///         .basic_scheduler()
+///         .enable_all()
+///         .build()
+///         .unwrap()
+///         .block_on(async {
+///             println!("Hello world");
+///         })
+/// }
+/// ```
+///
+/// ### NOTE:
+///
+/// If you rename the tokio crate in your dependencies this macro
+/// will not work. If you must rename the 0.2 version of tokio because
+/// you're also using the 0.1 version of tokio, you _must_ make the
+/// tokio 0.2 crate available as `tokio` in the module where this
+/// macro is expanded.
+#[proc_macro_attribute]
+#[cfg(not(test))] // Work around for rust-lang/rust#62127
+pub fn main_basic(args: TokenStream, item: TokenStream) -> TokenStream {
+    entry::main(args, item, false)
+}
+
+/// Marks async function to be executed by runtime, suitable to test environment
+///
+/// ## Options:
+///
+/// - `core_threads=n` - Sets core threads to `n` (requires `rt-threaded` feature).
+/// - `max_threads=n` - Sets max threads to `n` (requires `rt-core` or `rt-threaded` feature).
+///
+/// ## Usage
+///
+/// ### Select runtime
 ///
 /// ```no_run
-/// #[tokio::test(flavor = "multi_thread")]
+/// #[tokio::test(core_threads = 1)]
 /// async fn my_test() {
 ///     assert!(true);
 /// }
 /// ```
 ///
-/// Equivalent code not using `#[tokio::test]`
-///
-/// ```no_run
-/// #[test]
-/// fn my_test() {
-///     tokio::runtime::Builder::new_multi_thread()
-///         .enable_all()
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             assert!(true);
-///         })
-/// }
-/// ```
-///
-/// ### Using current thread runtime
+/// ### Using default
 ///
 /// ```no_run
 /// #[tokio::test]
@@ -341,90 +282,63 @@ pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream {
 /// }
 /// ```
 ///
-/// Equivalent code not using `#[tokio::test]`
+/// ### NOTE:
 ///
-/// ```no_run
-/// #[test]
-/// fn my_test() {
-///     tokio::runtime::Builder::new_current_thread()
-///         .enable_all()
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             assert!(true);
-///         })
-/// }
-/// ```
-///
-/// ### Set number of worker threads
-///
-/// ```no_run
-/// #[tokio::test(flavor ="multi_thread", worker_threads = 2)]
-/// async fn my_test() {
-///     assert!(true);
-/// }
-/// ```
-///
-/// Equivalent code not using `#[tokio::test]`
-///
-/// ```no_run
-/// #[test]
-/// fn my_test() {
-///     tokio::runtime::Builder::new_multi_thread()
-///         .worker_threads(2)
-///         .enable_all()
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             assert!(true);
-///         })
-/// }
-/// ```
-///
-/// ### Configure the runtime to start with time paused
-///
-/// ```no_run
-/// #[tokio::test(start_paused = true)]
-/// async fn my_test() {
-///     assert!(true);
-/// }
-/// ```
-///
-/// Equivalent code not using `#[tokio::test]`
-///
-/// ```no_run
-/// #[test]
-/// fn my_test() {
-///     tokio::runtime::Builder::new_current_thread()
-///         .enable_all()
-///         .start_paused(true)
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             assert!(true);
-///         })
-/// }
-/// ```
-///
-/// Note that `start_paused` requires the `test-util` feature to be enabled.
-///
-/// ### Rename package
-///
-/// ```rust
-/// use tokio as tokio1;
-///
-/// #[tokio1::test(crate = "tokio1")]
-/// async fn my_test() {
-///     println!("Hello world");
-/// }
-/// ```
+/// If you rename the tokio crate in your dependencies this macro
+/// will not work. If you must rename the 0.2 version of tokio because
+/// you're also using the 0.1 version of tokio, you _must_ make the
+/// tokio 0.2 crate available as `tokio` in the module where this
+/// macro is expanded.
 #[proc_macro_attribute]
-pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
+pub fn test_threaded(args: TokenStream, item: TokenStream) -> TokenStream {
     entry::test(args, item, true)
 }
 
 /// Marks async function to be executed by runtime, suitable to test environment
 ///
+/// ## Options:
+///
+/// - `basic_scheduler` - All tasks are executed on the current thread. Used by default.
+/// - `threaded_scheduler` - Use multi-threaded scheduler (requires `rt-threaded` feature).
+///
+/// ## Usage
+///
+/// ### Select runtime
+///
+/// ```no_run
+/// #[tokio::test(threaded_scheduler)]
+/// async fn my_test() {
+///     assert!(true);
+/// }
+/// ```
+///
+/// ### Using default
+///
+/// ```no_run
+/// #[tokio::test]
+/// async fn my_test() {
+///     assert!(true);
+/// }
+/// ```
+///
+/// ### NOTE:
+///
+/// If you rename the tokio crate in your dependencies this macro
+/// will not work. If you must rename the 0.2 version of tokio because
+/// you're also using the 0.1 version of tokio, you _must_ make the
+/// tokio 0.2 crate available as `tokio` in the module where this
+/// macro is expanded.
+#[proc_macro_attribute]
+pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
+    entry::old::test(args, item)
+}
+
+/// Marks async function to be executed by runtime, suitable to test environment
+///
+/// ## Options:
+///
+/// - `max_threads=n` - Sets max threads to `n`.
+///
 /// ## Usage
 ///
 /// ```no_run
@@ -433,39 +347,19 @@ pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
 ///     assert!(true);
 /// }
 /// ```
+///
+/// ### NOTE:
+///
+/// If you rename the tokio crate in your dependencies this macro
+/// will not work. If you must rename the 0.2 version of tokio because
+/// you're also using the 0.1 version of tokio, you _must_ make the
+/// tokio 0.2 crate available as `tokio` in the module where this
+/// macro is expanded.
 #[proc_macro_attribute]
-pub fn test_rt(args: TokenStream, item: TokenStream) -> TokenStream {
+pub fn test_basic(args: TokenStream, item: TokenStream) -> TokenStream {
     entry::test(args, item, false)
 }
 
-/// Always fails with the error message below.
-/// ```text
-/// The #[tokio::main] macro requires rt or rt-multi-thread.
-/// ```
-#[proc_macro_attribute]
-pub fn main_fail(_args: TokenStream, _item: TokenStream) -> TokenStream {
-    syn::Error::new(
-        proc_macro2::Span::call_site(),
-        "The #[tokio::main] macro requires rt or rt-multi-thread.",
-    )
-    .to_compile_error()
-    .into()
-}
-
-/// Always fails with the error message below.
-/// ```text
-/// The #[tokio::test] macro requires rt or rt-multi-thread.
-/// ```
-#[proc_macro_attribute]
-pub fn test_fail(_args: TokenStream, _item: TokenStream) -> TokenStream {
-    syn::Error::new(
-        proc_macro2::Span::call_site(),
-        "The #[tokio::test] macro requires rt or rt-multi-thread.",
-    )
-    .to_compile_error()
-    .into()
-}
-
 /// Implementation detail of the `select!` macro. This macro is **not** intended
 /// to be used as part of the public API and is permitted to change.
 #[proc_macro]
@@ -473,11 +367,3 @@ pub fn test_fail(_args: TokenStream, _item: TokenStream) -> TokenStream {
 pub fn select_priv_declare_output_enum(input: TokenStream) -> TokenStream {
     select::declare_output_enum(input)
 }
-
-/// Implementation detail of the `select!` macro. This macro is **not** intended
-/// to be used as part of the public API and is permitted to change.
-#[proc_macro]
-#[doc(hidden)]
-pub fn select_priv_clean_pattern(input: TokenStream) -> TokenStream {
-    select::clean_pattern_macro(input)
-}

tokio-macros/src/select.rs

@@ -41,70 +41,3 @@ pub(crate) fn declare_output_enum(input: TokenStream) -> TokenStream {
         pub(super) type Mask = #mask;
     })
 }
-
-pub(crate) fn clean_pattern_macro(input: TokenStream) -> TokenStream {
-    // If this isn't a pattern, we return the token stream as-is. The select!
-    // macro is using it in a location requiring a pattern, so an error will be
-    // emitted there.
-    let mut input: syn::Pat = match syn::parse(input.clone()) {
-        Ok(it) => it,
-        Err(_) => return input,
-    };
-
-    clean_pattern(&mut input);
-    quote::ToTokens::into_token_stream(input).into()
-}
-
-// Removes any occurrences of ref or mut in the provided pattern.
-fn clean_pattern(pat: &mut syn::Pat) {
-    match pat {
-        syn::Pat::Box(_box) => {}
-        syn::Pat::Lit(_literal) => {}
-        syn::Pat::Macro(_macro) => {}
-        syn::Pat::Path(_path) => {}
-        syn::Pat::Range(_range) => {}
-        syn::Pat::Rest(_rest) => {}
-        syn::Pat::Verbatim(_tokens) => {}
-        syn::Pat::Wild(_underscore) => {}
-        syn::Pat::Ident(ident) => {
-            ident.by_ref = None;
-            ident.mutability = None;
-            if let Some((_at, pat)) = &mut ident.subpat {
-                clean_pattern(&mut *pat);
-            }
-        }
-        syn::Pat::Or(or) => {
-            for case in or.cases.iter_mut() {
-                clean_pattern(case);
-            }
-        }
-        syn::Pat::Slice(slice) => {
-            for elem in slice.elems.iter_mut() {
-                clean_pattern(elem);
-            }
-        }
-        syn::Pat::Struct(struct_pat) => {
-            for field in struct_pat.fields.iter_mut() {
-                clean_pattern(&mut field.pat);
-            }
-        }
-        syn::Pat::Tuple(tuple) => {
-            for elem in tuple.elems.iter_mut() {
-                clean_pattern(elem);
-            }
-        }
-        syn::Pat::TupleStruct(tuple) => {
-            for elem in tuple.pat.elems.iter_mut() {
-                clean_pattern(elem);
-            }
-        }
-        syn::Pat::Reference(reference) => {
-            reference.mutability = None;
-            clean_pattern(&mut *reference.pat);
-        }
-        syn::Pat::Type(type_pat) => {
-            clean_pattern(&mut *type_pat.pat);
-        }
-        _ => {}
-    }
-}

tokio-stream/CHANGELOG.md

@@ -1,109 +0,0 @@
-# 0.1.9 (June 4, 2022)
-
-- deps: upgrade `tokio-util` dependency to `0.7.x` ([#3762])
-- stream: add `StreamExt::map_while` ([#4351])
-- stream: add `StreamExt::then` ([#4355])
-- stream: add cancel-safety docs to `StreamExt::next` and `try_next` ([#4715])
-- stream: expose `Elapsed` error ([#4502])
-- stream: expose `Timeout` ([#4601])
-- stream: implement `Extend` for `StreamMap` ([#4272])
-- sync: add `Clone` to `RecvError` types ([#4560])
-
-[#3762]: https://github.com/tokio-rs/tokio/pull/3762
-[#4272]: https://github.com/tokio-rs/tokio/pull/4272
-[#4351]: https://github.com/tokio-rs/tokio/pull/4351
-[#4355]: https://github.com/tokio-rs/tokio/pull/4355
-[#4502]: https://github.com/tokio-rs/tokio/pull/4502
-[#4560]: https://github.com/tokio-rs/tokio/pull/4560
-[#4601]: https://github.com/tokio-rs/tokio/pull/4601
-[#4715]: https://github.com/tokio-rs/tokio/pull/4715
-
-# 0.1.8 (October 29, 2021)
-
-- stream: add `From<Receiver<T>>` impl for receiver streams ([#4080])
-- stream: impl `FromIterator` for `StreamMap` ([#4052])
-- signal: make windows docs for signal module show up on unix builds ([#3770])
-
-[#3770]: https://github.com/tokio-rs/tokio/pull/3770
-[#4052]: https://github.com/tokio-rs/tokio/pull/4052
-[#4080]: https://github.com/tokio-rs/tokio/pull/4080
-
-# 0.1.7 (July 7, 2021)
-
-### Fixed
-
-- sync: fix watch wrapper ([#3914])
-- time: fix `Timeout::size_hint` ([#3902])
-
-[#3902]: https://github.com/tokio-rs/tokio/pull/3902
-[#3914]: https://github.com/tokio-rs/tokio/pull/3914
-
-# 0.1.6 (May 14, 2021)
-
-### Added
-
-- stream: implement `Error` and `Display` for `BroadcastStreamRecvError` ([#3745])
-
-### Fixed
-
-- stream: avoid yielding in `AllFuture` and `AnyFuture` ([#3625])
-
-[#3745]: https://github.com/tokio-rs/tokio/pull/3745
-[#3625]: https://github.com/tokio-rs/tokio/pull/3625
-
-# 0.1.5 (March 20, 2021)
-
-### Fixed
-
-- stream: documentation note for throttle `Unpin` ([#3600])
-
-[#3600]: https://github.com/tokio-rs/tokio/pull/3600
-
-# 0.1.4 (March 9, 2021)
-
-Added
-
-- signal: add `Signal` wrapper ([#3510])
-
-Fixed
-
-- stream: remove duplicate `doc_cfg` declaration ([#3561])
-- sync: yield initial value in `WatchStream` ([#3576])
-
-[#3510]: https://github.com/tokio-rs/tokio/pull/3510
-[#3561]: https://github.com/tokio-rs/tokio/pull/3561
-[#3576]: https://github.com/tokio-rs/tokio/pull/3576
-
-# 0.1.3 (February 5, 2021)
-
-Added
-
- - sync: add wrapper for broadcast and watch ([#3384], [#3504])
-
-[#3384]: https://github.com/tokio-rs/tokio/pull/3384
-[#3504]: https://github.com/tokio-rs/tokio/pull/3504
-
-# 0.1.2 (January 12, 2021)
-
-Fixed
-
- - docs: fix some wrappers missing in documentation ([#3378])
-
-[#3378]: https://github.com/tokio-rs/tokio/pull/3378
-
-# 0.1.1 (January 4, 2021)
-
-Added
-
- - add `Stream` wrappers ([#3343])
-
-Fixed
-
- - move `async-stream` to `dev-dependencies` ([#3366])
-
-[#3366]: https://github.com/tokio-rs/tokio/pull/3366
-[#3343]: https://github.com/tokio-rs/tokio/pull/3343
-
-# 0.1.0 (December 23, 2020)
-
- - Initial release

tokio-stream/Cargo.toml

@@ -1,50 +0,0 @@
-[package]
-name = "tokio-stream"
-# When releasing to crates.io:
-# - Remove path dependencies
-# - Update CHANGELOG.md.
-# - Create "tokio-stream-0.1.x" git tag.
-version = "0.1.9"
-edition = "2018"
-rust-version = "1.49"
-authors = ["Tokio Contributors <[email protected]>"]
-license = "MIT"
-repository = "https://github.com/tokio-rs/tokio"
-homepage = "https://tokio.rs"
-description = """
-Utilities to work with `Stream` and `tokio`.
-"""
-categories = ["asynchronous"]
-
-[features]
-default = ["time"]
-time = ["tokio/time"]
-net = ["tokio/net"]
-io-util = ["tokio/io-util"]
-fs = ["tokio/fs"]
-sync = ["tokio/sync", "tokio-util"]
-signal = ["tokio/signal"]
-
-[dependencies]
-futures-core = { version = "0.3.0" }
-pin-project-lite = "0.2.0"
-tokio = { version = "1.8.0", path = "../tokio", features = ["sync"] }
-tokio-util = { version = "0.7.0", path = "../tokio-util", optional = true }
-
-[dev-dependencies]
-tokio = { version = "1.2.0", path = "../tokio", features = ["full", "test-util"] }
-async-stream = "0.3"
-parking_lot = "0.12.0"
-tokio-test = { path = "../tokio-test" }
-futures = { version = "0.3", default-features = false }
-
-proptest = "1"
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
-# Issue #3770
-#
-# This should allow `docsrs` to be read across projects, so that `tokio-stream`
-# can pick up stubbed types exported by `tokio`.
-rustc-args = ["--cfg", "docsrs"]

tokio-stream/LICENSE

@@ -1,25 +0,0 @@
-Copyright (c) 2022 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.

tokio-stream/src/lib.rs

@@ -1,100 +0,0 @@
-#![allow(
-    clippy::cognitive_complexity,
-    clippy::large_enum_variant,
-    clippy::needless_doctest_main
-)]
-#![warn(
-    missing_debug_implementations,
-    missing_docs,
-    rust_2018_idioms,
-    unreachable_pub
-)]
-#![cfg_attr(docsrs, feature(doc_cfg))]
-#![doc(test(
-    no_crate_inject,
-    attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
-))]
-
-//! Stream utilities for Tokio.
-//!
-//! A `Stream` is an asynchronous sequence of values. It can be thought of as
-//! an asynchronous version of the standard library's `Iterator` trait.
-//!
-//! This crate provides helpers to work with them. For examples of usage and a more in-depth
-//! description of streams you can also refer to the [streams
-//! tutorial](https://tokio.rs/tokio/tutorial/streams) on the tokio website.
-//!
-//! # Iterating over a Stream
-//!
-//! Due to similarities with the standard library's `Iterator` trait, some new
-//! users may assume that they can use `for in` syntax to iterate over a
-//! `Stream`, but this is unfortunately not possible. Instead, you can use a
-//! `while let` loop as follows:
-//!
-//! ```rust
-//! use tokio_stream::{self as stream, StreamExt};
-//!
-//! #[tokio::main]
-//! async fn main() {
-//!     let mut stream = stream::iter(vec![0, 1, 2]);
-//!
-//!     while let Some(value) = stream.next().await {
-//!         println!("Got {}", value);
-//!     }
-//! }
-//! ```
-//!
-//! # Returning a Stream from a function
-//!
-//! A common way to stream values from a function is to pass in the sender
-//! half of a channel and use the receiver as the stream. This requires awaiting
-//! both futures to ensure progress is made. Another alternative is the
-//! [async-stream] crate, which contains macros that provide a `yield` keyword
-//! and allow you to return an `impl Stream`.
-//!
-//! [async-stream]: https://docs.rs/async-stream
-//!
-//! # Conversion to and from AsyncRead/AsyncWrite
-//!
-//! It is often desirable to convert a `Stream` into an [`AsyncRead`],
-//! especially when dealing with plaintext formats streamed over the network.
-//! The opposite conversion from an [`AsyncRead`] into a `Stream` is also
-//! another commonly required feature. To enable these conversions,
-//! [`tokio-util`] provides the [`StreamReader`] and [`ReaderStream`]
-//! types when the io feature is enabled.
-//!
-//! [`tokio-util`]: https://docs.rs/tokio-util/0.4/tokio_util/codec/index.html
-//! [`tokio::io`]: https://docs.rs/tokio/1.0/tokio/io/index.html
-//! [`AsyncRead`]: https://docs.rs/tokio/1.0/tokio/io/trait.AsyncRead.html
-//! [`AsyncWrite`]: https://docs.rs/tokio/1.0/tokio/io/trait.AsyncWrite.html
-//! [`ReaderStream`]: https://docs.rs/tokio-util/0.4/tokio_util/io/struct.ReaderStream.html
-//! [`StreamReader`]: https://docs.rs/tokio-util/0.4/tokio_util/io/struct.StreamReader.html
-
-#[macro_use]
-mod macros;
-
-pub mod wrappers;
-
-mod stream_ext;
-pub use stream_ext::{collect::FromStream, StreamExt};
-cfg_time! {
-    pub use stream_ext::timeout::{Elapsed, Timeout};
-}
-
-mod empty;
-pub use empty::{empty, Empty};
-
-mod iter;
-pub use iter::{iter, Iter};
-
-mod once;
-pub use once::{once, Once};
-
-mod pending;
-pub use pending::{pending, Pending};
-
-mod stream_map;
-pub use stream_map::StreamMap;
-
-#[doc(no_inline)]
-pub use futures_core::Stream;

tokio-stream/src/macros.rs

@@ -1,68 +0,0 @@
-macro_rules! cfg_fs {
-    ($($item:item)*) => {
-        $(
-            #[cfg(feature = "fs")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "fs")))]
-            $item
-        )*
-    }
-}
-
-macro_rules! cfg_io_util {
-    ($($item:item)*) => {
-        $(
-            #[cfg(feature = "io-util")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "io-util")))]
-            $item
-        )*
-    }
-}
-
-macro_rules! cfg_net {
-    ($($item:item)*) => {
-        $(
-            #[cfg(feature = "net")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
-            $item
-        )*
-    }
-}
-
-macro_rules! cfg_time {
-    ($($item:item)*) => {
-        $(
-            #[cfg(feature = "time")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "time")))]
-            $item
-        )*
-    }
-}
-
-macro_rules! cfg_sync {
-    ($($item:item)*) => {
-        $(
-            #[cfg(feature = "sync")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "sync")))]
-            $item
-        )*
-    }
-}
-
-macro_rules! cfg_signal {
-    ($($item:item)*) => {
-        $(
-            #[cfg(feature = "signal")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "signal")))]
-            $item
-        )*
-    }
-}
-
-macro_rules! ready {
-    ($e:expr $(,)?) => {
-        match $e {
-            std::task::Poll::Ready(t) => t,
-            std::task::Poll::Pending => return std::task::Poll::Pending,
-        }
-    };
-}

tokio-stream/src/stream_ext/all.rs

@@ -1,58 +0,0 @@
-use crate::Stream;
-
-use core::future::Future;
-use core::marker::PhantomPinned;
-use core::pin::Pin;
-use core::task::{Context, Poll};
-use pin_project_lite::pin_project;
-
-pin_project! {
-    /// Future for the [`all`](super::StreamExt::all) method.
-    #[derive(Debug)]
-    #[must_use = "futures do nothing unless you `.await` or poll them"]
-    pub struct AllFuture<'a, St: ?Sized, F> {
-        stream: &'a mut St,
-        f: F,
-        // Make this future `!Unpin` for compatibility with async trait methods.
-        #[pin]
-        _pin: PhantomPinned,
-    }
-}
-
-impl<'a, St: ?Sized, F> AllFuture<'a, St, F> {
-    pub(super) fn new(stream: &'a mut St, f: F) -> Self {
-        Self {
-            stream,
-            f,
-            _pin: PhantomPinned,
-        }
-    }
-}
-
-impl<St, F> Future for AllFuture<'_, St, F>
-where
-    St: ?Sized + Stream + Unpin,
-    F: FnMut(St::Item) -> bool,
-{
-    type Output = bool;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let me = self.project();
-        let mut stream = Pin::new(me.stream);
-
-        // Take a maximum of 32 items from the stream before yielding.
-        for _ in 0..32 {
-            match futures_core::ready!(stream.as_mut().poll_next(cx)) {
-                Some(v) => {
-                    if !(me.f)(v) {
-                        return Poll::Ready(false);
-                    }
-                }
-                None => return Poll::Ready(true),
-            }
-        }
-
-        cx.waker().wake_by_ref();
-        Poll::Pending
-    }
-}

tokio-stream/src/stream_ext/any.rs

@@ -1,58 +0,0 @@
-use crate::Stream;
-
-use core::future::Future;
-use core::marker::PhantomPinned;
-use core::pin::Pin;
-use core::task::{Context, Poll};
-use pin_project_lite::pin_project;
-
-pin_project! {
-    /// Future for the [`any`](super::StreamExt::any) method.
-    #[derive(Debug)]
-    #[must_use = "futures do nothing unless you `.await` or poll them"]
-    pub struct AnyFuture<'a, St: ?Sized, F> {
-        stream: &'a mut St,
-        f: F,
-        // Make this future `!Unpin` for compatibility with async trait methods.
-        #[pin]
-        _pin: PhantomPinned,
-    }
-}
-
-impl<'a, St: ?Sized, F> AnyFuture<'a, St, F> {
-    pub(super) fn new(stream: &'a mut St, f: F) -> Self {
-        Self {
-            stream,
-            f,
-            _pin: PhantomPinned,
-        }
-    }
-}
-
-impl<St, F> Future for AnyFuture<'_, St, F>
-where
-    St: ?Sized + Stream + Unpin,
-    F: FnMut(St::Item) -> bool,
-{
-    type Output = bool;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let me = self.project();
-        let mut stream = Pin::new(me.stream);
-
-        // Take a maximum of 32 items from the stream before yielding.
-        for _ in 0..32 {
-            match futures_core::ready!(stream.as_mut().poll_next(cx)) {
-                Some(v) => {
-                    if (me.f)(v) {
-                        return Poll::Ready(true);
-                    }
-                }
-                None => return Poll::Ready(false),
-            }
-        }
-
-        cx.waker().wake_by_ref();
-        Poll::Pending
-    }
-}

tokio-stream/src/stream_ext/chunks_timeout.rs

@@ -1,84 +0,0 @@
-use crate::stream_ext::Fuse;
-use crate::Stream;
-use tokio::time::{sleep, Instant, Sleep};
-
-use core::future::Future;
-use core::pin::Pin;
-use core::task::{Context, Poll};
-use pin_project_lite::pin_project;
-use std::time::Duration;
-
-pin_project! {
-    /// Stream returned by the [`chunks_timeout`](super::StreamExt::chunks_timeout) method.
-    #[must_use = "streams do nothing unless polled"]
-    #[derive(Debug)]
-    pub struct ChunksTimeout<S: Stream> {
-        #[pin]
-        stream: Fuse<S>,
-        #[pin]
-        deadline: Sleep,
-        duration: Duration,
-        items: Vec<S::Item>,
-        cap: usize, // https://github.com/rust-lang/futures-rs/issues/1475
-    }
-}
-
-impl<S: Stream> ChunksTimeout<S> {
-    pub(super) fn new(stream: S, max_size: usize, duration: Duration) -> Self {
-        ChunksTimeout {
-            stream: Fuse::new(stream),
-            deadline: sleep(duration),
-            duration,
-            items: Vec::with_capacity(max_size),
-            cap: max_size,
-        }
-    }
-}
-
-impl<S: Stream> Stream for ChunksTimeout<S> {
-    type Item = Vec<S::Item>;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let mut me = self.as_mut().project();
-        loop {
-            match me.stream.as_mut().poll_next(cx) {
-                Poll::Pending => break,
-                Poll::Ready(Some(item)) => {
-                    if me.items.is_empty() {
-                        me.deadline.as_mut().reset(Instant::now() + *me.duration);
-                        me.items.reserve_exact(*me.cap);
-                    }
-                    me.items.push(item);
-                    if me.items.len() >= *me.cap {
-                        return Poll::Ready(Some(std::mem::take(me.items)));
-                    }
-                }
-                Poll::Ready(None) => {
-                    // Returning Some here is only correct because we fuse the inner stream.
-                    let last = if me.items.is_empty() {
-                        None
-                    } else {
-                        Some(std::mem::take(me.items))
-                    };
-
-                    return Poll::Ready(last);
-                }
-            }
-        }
-
-        if !me.items.is_empty() {
-            ready!(me.deadline.poll(cx));
-            return Poll::Ready(Some(std::mem::take(me.items)));
-        }
-
-        Poll::Pending
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let chunk_len = if self.items.is_empty() { 0 } else { 1 };
-        let (lower, upper) = self.stream.size_hint();
-        let lower = (lower / self.cap).saturating_add(chunk_len);
-        let upper = upper.and_then(|x| x.checked_add(chunk_len));
-        (lower, upper)
-    }
-}

tokio-stream/src/stream_ext/collect.rs

@@ -1,233 +0,0 @@
-use crate::Stream;
-
-use core::future::Future;
-use core::marker::PhantomPinned;
-use core::mem;
-use core::pin::Pin;
-use core::task::{Context, Poll};
-use pin_project_lite::pin_project;
-
-// Do not export this struct until `FromStream` can be unsealed.
-pin_project! {
-    /// Future returned by the [`collect`](super::StreamExt::collect) method.
-    #[must_use = "futures do nothing unless you `.await` or poll them"]
-    #[derive(Debug)]
-    pub struct Collect<T, U>
-    where
-        T: Stream,
-        U: FromStream<T::Item>,
-    {
-        #[pin]
-        stream: T,
-        collection: U::InternalCollection,
-        // Make this future `!Unpin` for compatibility with async trait methods.
-        #[pin]
-        _pin: PhantomPinned,
-    }
-}
-
-/// Convert from a [`Stream`](crate::Stream).
-///
-/// This trait is not intended to be used directly. Instead, call
-/// [`StreamExt::collect()`](super::StreamExt::collect).
-///
-/// # Implementing
-///
-/// Currently, this trait may not be implemented by third parties. The trait is
-/// sealed in order to make changes in the future. Stabilization is pending
-/// enhancements to the Rust language.
-pub trait FromStream<T>: sealed::FromStreamPriv<T> {}
-
-impl<T, U> Collect<T, U>
-where
-    T: Stream,
-    U: FromStream<T::Item>,
-{
-    pub(super) fn new(stream: T) -> Collect<T, U> {
-        let (lower, upper) = stream.size_hint();
-        let collection = U::initialize(sealed::Internal, lower, upper);
-
-        Collect {
-            stream,
-            collection,
-            _pin: PhantomPinned,
-        }
-    }
-}
-
-impl<T, U> Future for Collect<T, U>
-where
-    T: Stream,
-    U: FromStream<T::Item>,
-{
-    type Output = U;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<U> {
-        use Poll::Ready;
-
-        loop {
-            let me = self.as_mut().project();
-
-            let item = match ready!(me.stream.poll_next(cx)) {
-                Some(item) => item,
-                None => {
-                    return Ready(U::finalize(sealed::Internal, me.collection));
-                }
-            };
-
-            if !U::extend(sealed::Internal, me.collection, item) {
-                return Ready(U::finalize(sealed::Internal, me.collection));
-            }
-        }
-    }
-}
-
-// ===== FromStream implementations
-
-impl FromStream<()> for () {}
-
-impl sealed::FromStreamPriv<()> for () {
-    type InternalCollection = ();
-
-    fn initialize(_: sealed::Internal, _lower: usize, _upper: Option<usize>) {}
-
-    fn extend(_: sealed::Internal, _collection: &mut (), _item: ()) -> bool {
-        true
-    }
-
-    fn finalize(_: sealed::Internal, _collection: &mut ()) {}
-}
-
-impl<T: AsRef<str>> FromStream<T> for String {}
-
-impl<T: AsRef<str>> sealed::FromStreamPriv<T> for String {
-    type InternalCollection = String;
-
-    fn initialize(_: sealed::Internal, _lower: usize, _upper: Option<usize>) -> String {
-        String::new()
-    }
-
-    fn extend(_: sealed::Internal, collection: &mut String, item: T) -> bool {
-        collection.push_str(item.as_ref());
-        true
-    }
-
-    fn finalize(_: sealed::Internal, collection: &mut String) -> String {
-        mem::take(collection)
-    }
-}
-
-impl<T> FromStream<T> for Vec<T> {}
-
-impl<T> sealed::FromStreamPriv<T> for Vec<T> {
-    type InternalCollection = Vec<T>;
-
-    fn initialize(_: sealed::Internal, lower: usize, _upper: Option<usize>) -> Vec<T> {
-        Vec::with_capacity(lower)
-    }
-
-    fn extend(_: sealed::Internal, collection: &mut Vec<T>, item: T) -> bool {
-        collection.push(item);
-        true
-    }
-
-    fn finalize(_: sealed::Internal, collection: &mut Vec<T>) -> Vec<T> {
-        mem::take(collection)
-    }
-}
-
-impl<T> FromStream<T> for Box<[T]> {}
-
-impl<T> sealed::FromStreamPriv<T> for Box<[T]> {
-    type InternalCollection = Vec<T>;
-
-    fn initialize(_: sealed::Internal, lower: usize, upper: Option<usize>) -> Vec<T> {
-        <Vec<T> as sealed::FromStreamPriv<T>>::initialize(sealed::Internal, lower, upper)
-    }
-
-    fn extend(_: sealed::Internal, collection: &mut Vec<T>, item: T) -> bool {
-        <Vec<T> as sealed::FromStreamPriv<T>>::extend(sealed::Internal, collection, item)
-    }
-
-    fn finalize(_: sealed::Internal, collection: &mut Vec<T>) -> Box<[T]> {
-        <Vec<T> as sealed::FromStreamPriv<T>>::finalize(sealed::Internal, collection)
-            .into_boxed_slice()
-    }
-}
-
-impl<T, U, E> FromStream<Result<T, E>> for Result<U, E> where U: FromStream<T> {}
-
-impl<T, U, E> sealed::FromStreamPriv<Result<T, E>> for Result<U, E>
-where
-    U: FromStream<T>,
-{
-    type InternalCollection = Result<U::InternalCollection, E>;
-
-    fn initialize(
-        _: sealed::Internal,
-        lower: usize,
-        upper: Option<usize>,
-    ) -> Result<U::InternalCollection, E> {
-        Ok(U::initialize(sealed::Internal, lower, upper))
-    }
-
-    fn extend(
-        _: sealed::Internal,
-        collection: &mut Self::InternalCollection,
-        item: Result<T, E>,
-    ) -> bool {
-        assert!(collection.is_ok());
-        match item {
-            Ok(item) => {
-                let collection = collection.as_mut().ok().expect("invalid state");
-                U::extend(sealed::Internal, collection, item)
-            }
-            Err(err) => {
-                *collection = Err(err);
-                false
-            }
-        }
-    }
-
-    fn finalize(_: sealed::Internal, collection: &mut Self::InternalCollection) -> Result<U, E> {
-        if let Ok(collection) = collection.as_mut() {
-            Ok(U::finalize(sealed::Internal, collection))
-        } else {
-            let res = mem::replace(collection, Ok(U::initialize(sealed::Internal, 0, Some(0))));
-
-            if let Err(err) = res {
-                Err(err)
-            } else {
-                unreachable!();
-            }
-        }
-    }
-}
-
-pub(crate) mod sealed {
-    #[doc(hidden)]
-    pub trait FromStreamPriv<T> {
-        /// Intermediate type used during collection process
-        ///
-        /// The name of this type is internal and cannot be relied upon.
-        type InternalCollection;
-
-        /// Initialize the collection
-        fn initialize(
-            internal: Internal,
-            lower: usize,
-            upper: Option<usize>,
-        ) -> Self::InternalCollection;
-
-        /// Extend the collection with the received item
-        ///
-        /// Return `true` to continue streaming, `false` complete collection.
-        fn extend(internal: Internal, collection: &mut Self::InternalCollection, item: T) -> bool;
-
-        /// Finalize collection into target type.
-        fn finalize(internal: Internal, collection: &mut Self::InternalCollection) -> Self;
-    }
-
-    #[allow(missing_debug_implementations)]
-    pub struct Internal;
-}

tokio-stream/src/stream_ext/map_while.rs

@@ -1,52 +0,0 @@
-use crate::Stream;
-
-use core::fmt;
-use core::pin::Pin;
-use core::task::{Context, Poll};
-use pin_project_lite::pin_project;
-
-pin_project! {
-    /// Stream for the [`map_while`](super::StreamExt::map_while) method.
-    #[must_use = "streams do nothing unless polled"]
-    pub struct MapWhile<St, F> {
-        #[pin]
-        stream: St,
-        f: F,
-    }
-}
-
-impl<St, F> fmt::Debug for MapWhile<St, F>
-where
-    St: fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("MapWhile")
-            .field("stream", &self.stream)
-            .finish()
-    }
-}
-
-impl<St, F> MapWhile<St, F> {
-    pub(super) fn new(stream: St, f: F) -> Self {
-        MapWhile { stream, f }
-    }
-}
-
-impl<St, F, T> Stream for MapWhile<St, F>
-where
-    St: Stream,
-    F: FnMut(St::Item) -> Option<T>,
-{
-    type Item = T;
-
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<T>> {
-        let me = self.project();
-        let f = me.f;
-        me.stream.poll_next(cx).map(|opt| opt.and_then(f))
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let (_, upper) = self.stream.size_hint();
-        (0, upper)
-    }
-}

tokio-stream/src/stream_ext/next.rs

@@ -1,44 +0,0 @@
-use crate::Stream;
-
-use core::future::Future;
-use core::marker::PhantomPinned;
-use core::pin::Pin;
-use core::task::{Context, Poll};
-use pin_project_lite::pin_project;
-
-pin_project! {
-    /// Future for the [`next`](super::StreamExt::next) method.
-    ///
-    /// # Cancel safety
-    ///
-    /// This method is cancel safe. It only
-    /// holds onto a reference to the underlying stream,
-    /// so dropping it will never lose a value.
-    ///
-    #[derive(Debug)]
-    #[must_use = "futures do nothing unless you `.await` or poll them"]
-    pub struct Next<'a, St: ?Sized> {
-        stream: &'a mut St,
-        // Make this future `!Unpin` for compatibility with async trait methods.
-        #[pin]
-        _pin: PhantomPinned,
-    }
-}
-
-impl<'a, St: ?Sized> Next<'a, St> {
-    pub(super) fn new(stream: &'a mut St) -> Self {
-        Next {
-            stream,
-            _pin: PhantomPinned,
-        }
-    }
-}
-
-impl<St: ?Sized + Stream + Unpin> Future for Next<'_, St> {
-    type Output = Option<St::Item>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let me = self.project();
-        Pin::new(me.stream).poll_next(cx)
-    }
-}

tokio-stream/src/stream_ext/then.rs

@@ -1,83 +0,0 @@
-use crate::Stream;
-
-use core::fmt;
-use core::future::Future;
-use core::pin::Pin;
-use core::task::{Context, Poll};
-use pin_project_lite::pin_project;
-
-pin_project! {
-    /// Stream for the [`then`](super::StreamExt::then) method.
-    #[must_use = "streams do nothing unless polled"]
-    pub struct Then<St, Fut, F> {
-        #[pin]
-        stream: St,
-        #[pin]
-        future: Option<Fut>,
-        f: F,
-    }
-}
-
-impl<St, Fut, F> fmt::Debug for Then<St, Fut, F>
-where
-    St: fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Then")
-            .field("stream", &self.stream)
-            .finish()
-    }
-}
-
-impl<St, Fut, F> Then<St, Fut, F> {
-    pub(super) fn new(stream: St, f: F) -> Self {
-        Then {
-            stream,
-            future: None,
-            f,
-        }
-    }
-}
-
-impl<St, F, Fut> Stream for Then<St, Fut, F>
-where
-    St: Stream,
-    Fut: Future,
-    F: FnMut(St::Item) -> Fut,
-{
-    type Item = Fut::Output;
-
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Fut::Output>> {
-        let mut me = self.project();
-
-        loop {
-            if let Some(future) = me.future.as_mut().as_pin_mut() {
-                match future.poll(cx) {
-                    Poll::Ready(item) => {
-                        me.future.set(None);
-                        return Poll::Ready(Some(item));
-                    }
-                    Poll::Pending => return Poll::Pending,
-                }
-            }
-
-            match me.stream.as_mut().poll_next(cx) {
-                Poll::Ready(Some(item)) => {
-                    me.future.set(Some((me.f)(item)));
-                }
-                Poll::Ready(None) => return Poll::Ready(None),
-                Poll::Pending => return Poll::Pending,
-            }
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let future_len = if self.future.is_some() { 1 } else { 0 };
-        let (lower, upper) = self.stream.size_hint();
-
-        let lower = lower.saturating_add(future_len);
-        let upper = upper.and_then(|upper| upper.checked_add(future_len));
-
-        (lower, upper)
-    }
-}

tokio-stream/src/stream_ext/timeout.rs

@@ -1,107 +0,0 @@
-use crate::stream_ext::Fuse;
-use crate::Stream;
-use tokio::time::{Instant, Sleep};
-
-use core::future::Future;
-use core::pin::Pin;
-use core::task::{Context, Poll};
-use pin_project_lite::pin_project;
-use std::fmt;
-use std::time::Duration;
-
-pin_project! {
-    /// Stream returned by the [`timeout`](super::StreamExt::timeout) method.
-    #[must_use = "streams do nothing unless polled"]
-    #[derive(Debug)]
-    pub struct Timeout<S> {
-        #[pin]
-        stream: Fuse<S>,
-        #[pin]
-        deadline: Sleep,
-        duration: Duration,
-        poll_deadline: bool,
-    }
-}
-
-/// Error returned by `Timeout`.
-#[derive(Debug, PartialEq)]
-pub struct Elapsed(());
-
-impl<S: Stream> Timeout<S> {
-    pub(super) fn new(stream: S, duration: Duration) -> Self {
-        let next = Instant::now() + duration;
-        let deadline = tokio::time::sleep_until(next);
-
-        Timeout {
-            stream: Fuse::new(stream),
-            deadline,
-            duration,
-            poll_deadline: true,
-        }
-    }
-}
-
-impl<S: Stream> Stream for Timeout<S> {
-    type Item = Result<S::Item, Elapsed>;
-
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let me = self.project();
-
-        match me.stream.poll_next(cx) {
-            Poll::Ready(v) => {
-                if v.is_some() {
-                    let next = Instant::now() + *me.duration;
-                    me.deadline.reset(next);
-                    *me.poll_deadline = true;
-                }
-                return Poll::Ready(v.map(Ok));
-            }
-            Poll::Pending => {}
-        };
-
-        if *me.poll_deadline {
-            ready!(me.deadline.poll(cx));
-            *me.poll_deadline = false;
-            return Poll::Ready(Some(Err(Elapsed::new())));
-        }
-
-        Poll::Pending
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let (lower, upper) = self.stream.size_hint();
-
-        // The timeout stream may insert an error before and after each message
-        // from the underlying stream, but no more than one error between each
-        // message. Hence the upper bound is computed as 2x+1.
-
-        // Using a helper function to enable use of question mark operator.
-        fn twice_plus_one(value: Option<usize>) -> Option<usize> {
-            value?.checked_mul(2)?.checked_add(1)
-        }
-
-        (lower, twice_plus_one(upper))
-    }
-}
-
-// ===== impl Elapsed =====
-
-impl Elapsed {
-    pub(crate) fn new() -> Self {
-        Elapsed(())
-    }
-}
-
-impl fmt::Display for Elapsed {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        "deadline has elapsed".fmt(fmt)
-    }
-}
-
-impl std::error::Error for Elapsed {}
-
-impl From<Elapsed> for std::io::Error {
-    fn from(_err: Elapsed) -> std::io::Error {
-        std::io::ErrorKind::TimedOut.into()
-    }
-}

tokio-stream/src/stream_ext/try_next.rs

@@ -1,45 +0,0 @@
-use crate::stream_ext::Next;
-use crate::Stream;
-
-use core::future::Future;
-use core::marker::PhantomPinned;
-use core::pin::Pin;
-use core::task::{Context, Poll};
-use pin_project_lite::pin_project;
-
-pin_project! {
-    /// Future for the [`try_next`](super::StreamExt::try_next) method.
-    ///
-    /// # Cancel safety
-    ///
-    /// This method is cancel safe. It only
-    /// holds onto a reference to the underlying stream,
-    /// so dropping it will never lose a value.
-    #[derive(Debug)]
-    #[must_use = "futures do nothing unless you `.await` or poll them"]
-    pub struct TryNext<'a, St: ?Sized> {
-        #[pin]
-        inner: Next<'a, St>,
-        // Make this future `!Unpin` for compatibility with async trait methods.
-        #[pin]
-        _pin: PhantomPinned,
-    }
-}
-
-impl<'a, St: ?Sized> TryNext<'a, St> {
-    pub(super) fn new(stream: &'a mut St) -> Self {
-        Self {
-            inner: Next::new(stream),
-            _pin: PhantomPinned,
-        }
-    }
-}
-
-impl<T, E, St: ?Sized + Stream<Item = Result<T, E>> + Unpin> Future for TryNext<'_, St> {
-    type Output = Result<Option<T>, E>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let me = self.project();
-        me.inner.poll(cx).map(Option::transpose)
-    }
-}

tokio-stream/src/wrappers.rs

@@ -1,62 +0,0 @@
-//! Wrappers for Tokio types that implement `Stream`.
-
-/// Error types for the wrappers.
-pub mod errors {
-    cfg_sync! {
-        pub use crate::wrappers::broadcast::BroadcastStreamRecvError;
-    }
-}
-
-mod mpsc_bounded;
-pub use mpsc_bounded::ReceiverStream;
-
-mod mpsc_unbounded;
-pub use mpsc_unbounded::UnboundedReceiverStream;
-
-cfg_sync! {
-    mod broadcast;
-    pub use broadcast::BroadcastStream;
-
-    mod watch;
-    pub use watch::WatchStream;
-}
-
-cfg_signal! {
-    #[cfg(unix)]
-    mod signal_unix;
-    #[cfg(unix)]
-    pub use signal_unix::SignalStream;
-
-    #[cfg(any(windows, docsrs))]
-    mod signal_windows;
-    #[cfg(any(windows, docsrs))]
-    pub use signal_windows::{CtrlCStream, CtrlBreakStream};
-}
-
-cfg_time! {
-    mod interval;
-    pub use interval::IntervalStream;
-}
-
-cfg_net! {
-    mod tcp_listener;
-    pub use tcp_listener::TcpListenerStream;
-
-    #[cfg(unix)]
-    mod unix_listener;
-    #[cfg(unix)]
-    pub use unix_listener::UnixListenerStream;
-}
-
-cfg_io_util! {
-    mod split;
-    pub use split::SplitStream;
-
-    mod lines;
-    pub use lines::LinesStream;
-}
-
-cfg_fs! {
-    mod read_dir;
-    pub use read_dir::ReadDirStream;
-}

tokio-stream/src/wrappers/broadcast.rs

@@ -1,79 +0,0 @@
-use std::pin::Pin;
-use tokio::sync::broadcast::error::RecvError;
-use tokio::sync::broadcast::Receiver;
-
-use futures_core::Stream;
-use tokio_util::sync::ReusableBoxFuture;
-
-use std::fmt;
-use std::task::{Context, Poll};
-
-/// A wrapper around [`tokio::sync::broadcast::Receiver`] that implements [`Stream`].
-///
-/// [`tokio::sync::broadcast::Receiver`]: struct@tokio::sync::broadcast::Receiver
-/// [`Stream`]: trait@crate::Stream
-#[cfg_attr(docsrs, doc(cfg(feature = "sync")))]
-pub struct BroadcastStream<T> {
-    inner: ReusableBoxFuture<'static, (Result<T, RecvError>, Receiver<T>)>,
-}
-
-/// An error returned from the inner stream of a [`BroadcastStream`].
-#[derive(Debug, PartialEq, Clone)]
-pub enum BroadcastStreamRecvError {
-    /// The receiver lagged too far behind. Attempting to receive again will
-    /// return the oldest message still retained by the channel.
-    ///
-    /// Includes the number of skipped messages.
-    Lagged(u64),
-}
-
-impl fmt::Display for BroadcastStreamRecvError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            BroadcastStreamRecvError::Lagged(amt) => write!(f, "channel lagged by {}", amt),
-        }
-    }
-}
-
-impl std::error::Error for BroadcastStreamRecvError {}
-
-async fn make_future<T: Clone>(mut rx: Receiver<T>) -> (Result<T, RecvError>, Receiver<T>) {
-    let result = rx.recv().await;
-    (result, rx)
-}
-
-impl<T: 'static + Clone + Send> BroadcastStream<T> {
-    /// Create a new `BroadcastStream`.
-    pub fn new(rx: Receiver<T>) -> Self {
-        Self {
-            inner: ReusableBoxFuture::new(make_future(rx)),
-        }
-    }
-}
-
-impl<T: 'static + Clone + Send> Stream for BroadcastStream<T> {
-    type Item = Result<T, BroadcastStreamRecvError>;
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let (result, rx) = ready!(self.inner.poll(cx));
-        self.inner.set(make_future(rx));
-        match result {
-            Ok(item) => Poll::Ready(Some(Ok(item))),
-            Err(RecvError::Closed) => Poll::Ready(None),
-            Err(RecvError::Lagged(n)) => {
-                Poll::Ready(Some(Err(BroadcastStreamRecvError::Lagged(n))))
-            }
-        }
-    }
-}
-
-impl<T> fmt::Debug for BroadcastStream<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("BroadcastStream").finish()
-    }
-}
-
-impl<T: 'static + Clone + Send> From<Receiver<T>> for BroadcastStream<T> {
-    fn from(recv: Receiver<T>) -> Self {
-        Self::new(recv)
-    }
-}

tokio-stream/src/wrappers/interval.rs

@@ -1,50 +0,0 @@
-use crate::Stream;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::time::{Instant, Interval};
-
-/// A wrapper around [`Interval`] that implements [`Stream`].
-///
-/// [`Interval`]: struct@tokio::time::Interval
-/// [`Stream`]: trait@crate::Stream
-#[derive(Debug)]
-#[cfg_attr(docsrs, doc(cfg(feature = "time")))]
-pub struct IntervalStream {
-    inner: Interval,
-}
-
-impl IntervalStream {
-    /// Create a new `IntervalStream`.
-    pub fn new(interval: Interval) -> Self {
-        Self { inner: interval }
-    }
-
-    /// Get back the inner `Interval`.
-    pub fn into_inner(self) -> Interval {
-        self.inner
-    }
-}
-
-impl Stream for IntervalStream {
-    type Item = Instant;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Instant>> {
-        self.inner.poll_tick(cx).map(Some)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (std::usize::MAX, None)
-    }
-}
-
-impl AsRef<Interval> for IntervalStream {
-    fn as_ref(&self) -> &Interval {
-        &self.inner
-    }
-}
-
-impl AsMut<Interval> for IntervalStream {
-    fn as_mut(&mut self) -> &mut Interval {
-        &mut self.inner
-    }
-}

tokio-stream/src/wrappers/lines.rs

@@ -1,60 +0,0 @@
-use crate::Stream;
-use pin_project_lite::pin_project;
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::io::{AsyncBufRead, Lines};
-
-pin_project! {
-    /// A wrapper around [`tokio::io::Lines`] that implements [`Stream`].
-    ///
-    /// [`tokio::io::Lines`]: struct@tokio::io::Lines
-    /// [`Stream`]: trait@crate::Stream
-    #[derive(Debug)]
-    #[cfg_attr(docsrs, doc(cfg(feature = "io-util")))]
-    pub struct LinesStream<R> {
-        #[pin]
-        inner: Lines<R>,
-    }
-}
-
-impl<R> LinesStream<R> {
-    /// Create a new `LinesStream`.
-    pub fn new(lines: Lines<R>) -> Self {
-        Self { inner: lines }
-    }
-
-    /// Get back the inner `Lines`.
-    pub fn into_inner(self) -> Lines<R> {
-        self.inner
-    }
-
-    /// Obtain a pinned reference to the inner `Lines<R>`.
-    #[allow(clippy::wrong_self_convention)] // https://github.com/rust-lang/rust-clippy/issues/4546
-    pub fn as_pin_mut(self: Pin<&mut Self>) -> Pin<&mut Lines<R>> {
-        self.project().inner
-    }
-}
-
-impl<R: AsyncBufRead> Stream for LinesStream<R> {
-    type Item = io::Result<String>;
-
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self.project()
-            .inner
-            .poll_next_line(cx)
-            .map(Result::transpose)
-    }
-}
-
-impl<R> AsRef<Lines<R>> for LinesStream<R> {
-    fn as_ref(&self) -> &Lines<R> {
-        &self.inner
-    }
-}
-
-impl<R> AsMut<Lines<R>> for LinesStream<R> {
-    fn as_mut(&mut self) -> &mut Lines<R> {
-        &mut self.inner
-    }
-}

tokio-stream/src/wrappers/mpsc_bounded.rs

@@ -1,65 +0,0 @@
-use crate::Stream;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::sync::mpsc::Receiver;
-
-/// A wrapper around [`tokio::sync::mpsc::Receiver`] that implements [`Stream`].
-///
-/// [`tokio::sync::mpsc::Receiver`]: struct@tokio::sync::mpsc::Receiver
-/// [`Stream`]: trait@crate::Stream
-#[derive(Debug)]
-pub struct ReceiverStream<T> {
-    inner: Receiver<T>,
-}
-
-impl<T> ReceiverStream<T> {
-    /// Create a new `ReceiverStream`.
-    pub fn new(recv: Receiver<T>) -> Self {
-        Self { inner: recv }
-    }
-
-    /// Get back the inner `Receiver`.
-    pub fn into_inner(self) -> Receiver<T> {
-        self.inner
-    }
-
-    /// Closes the receiving half of a channel without dropping it.
-    ///
-    /// This prevents any further messages from being sent on the channel while
-    /// still enabling the receiver to drain messages that are buffered. Any
-    /// outstanding [`Permit`] values will still be able to send messages.
-    ///
-    /// To guarantee no messages are dropped, after calling `close()`, you must
-    /// receive all items from the stream until `None` is returned.
-    ///
-    /// [`Permit`]: struct@tokio::sync::mpsc::Permit
-    pub fn close(&mut self) {
-        self.inner.close()
-    }
-}
-
-impl<T> Stream for ReceiverStream<T> {
-    type Item = T;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self.inner.poll_recv(cx)
-    }
-}
-
-impl<T> AsRef<Receiver<T>> for ReceiverStream<T> {
-    fn as_ref(&self) -> &Receiver<T> {
-        &self.inner
-    }
-}
-
-impl<T> AsMut<Receiver<T>> for ReceiverStream<T> {
-    fn as_mut(&mut self) -> &mut Receiver<T> {
-        &mut self.inner
-    }
-}
-
-impl<T> From<Receiver<T>> for ReceiverStream<T> {
-    fn from(recv: Receiver<T>) -> Self {
-        Self::new(recv)
-    }
-}

tokio-stream/src/wrappers/mpsc_unbounded.rs

@@ -1,59 +0,0 @@
-use crate::Stream;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::sync::mpsc::UnboundedReceiver;
-
-/// A wrapper around [`tokio::sync::mpsc::UnboundedReceiver`] that implements [`Stream`].
-///
-/// [`tokio::sync::mpsc::UnboundedReceiver`]: struct@tokio::sync::mpsc::UnboundedReceiver
-/// [`Stream`]: trait@crate::Stream
-#[derive(Debug)]
-pub struct UnboundedReceiverStream<T> {
-    inner: UnboundedReceiver<T>,
-}
-
-impl<T> UnboundedReceiverStream<T> {
-    /// Create a new `UnboundedReceiverStream`.
-    pub fn new(recv: UnboundedReceiver<T>) -> Self {
-        Self { inner: recv }
-    }
-
-    /// Get back the inner `UnboundedReceiver`.
-    pub fn into_inner(self) -> UnboundedReceiver<T> {
-        self.inner
-    }
-
-    /// Closes the receiving half of a channel without dropping it.
-    ///
-    /// This prevents any further messages from being sent on the channel while
-    /// still enabling the receiver to drain messages that are buffered.
-    pub fn close(&mut self) {
-        self.inner.close()
-    }
-}
-
-impl<T> Stream for UnboundedReceiverStream<T> {
-    type Item = T;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self.inner.poll_recv(cx)
-    }
-}
-
-impl<T> AsRef<UnboundedReceiver<T>> for UnboundedReceiverStream<T> {
-    fn as_ref(&self) -> &UnboundedReceiver<T> {
-        &self.inner
-    }
-}
-
-impl<T> AsMut<UnboundedReceiver<T>> for UnboundedReceiverStream<T> {
-    fn as_mut(&mut self) -> &mut UnboundedReceiver<T> {
-        &mut self.inner
-    }
-}
-
-impl<T> From<UnboundedReceiver<T>> for UnboundedReceiverStream<T> {
-    fn from(recv: UnboundedReceiver<T>) -> Self {
-        Self::new(recv)
-    }
-}

tokio-stream/src/wrappers/read_dir.rs

@@ -1,47 +0,0 @@
-use crate::Stream;
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::fs::{DirEntry, ReadDir};
-
-/// A wrapper around [`tokio::fs::ReadDir`] that implements [`Stream`].
-///
-/// [`tokio::fs::ReadDir`]: struct@tokio::fs::ReadDir
-/// [`Stream`]: trait@crate::Stream
-#[derive(Debug)]
-#[cfg_attr(docsrs, doc(cfg(feature = "fs")))]
-pub struct ReadDirStream {
-    inner: ReadDir,
-}
-
-impl ReadDirStream {
-    /// Create a new `ReadDirStream`.
-    pub fn new(read_dir: ReadDir) -> Self {
-        Self { inner: read_dir }
-    }
-
-    /// Get back the inner `ReadDir`.
-    pub fn into_inner(self) -> ReadDir {
-        self.inner
-    }
-}
-
-impl Stream for ReadDirStream {
-    type Item = io::Result<DirEntry>;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self.inner.poll_next_entry(cx).map(Result::transpose)
-    }
-}
-
-impl AsRef<ReadDir> for ReadDirStream {
-    fn as_ref(&self) -> &ReadDir {
-        &self.inner
-    }
-}
-
-impl AsMut<ReadDir> for ReadDirStream {
-    fn as_mut(&mut self) -> &mut ReadDir {
-        &mut self.inner
-    }
-}

tokio-stream/src/wrappers/signal_unix.rs

@@ -1,46 +0,0 @@
-use crate::Stream;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::signal::unix::Signal;
-
-/// A wrapper around [`Signal`] that implements [`Stream`].
-///
-/// [`Signal`]: struct@tokio::signal::unix::Signal
-/// [`Stream`]: trait@crate::Stream
-#[derive(Debug)]
-#[cfg_attr(docsrs, doc(cfg(all(unix, feature = "signal"))))]
-pub struct SignalStream {
-    inner: Signal,
-}
-
-impl SignalStream {
-    /// Create a new `SignalStream`.
-    pub fn new(interval: Signal) -> Self {
-        Self { inner: interval }
-    }
-
-    /// Get back the inner `Signal`.
-    pub fn into_inner(self) -> Signal {
-        self.inner
-    }
-}
-
-impl Stream for SignalStream {
-    type Item = ();
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<()>> {
-        self.inner.poll_recv(cx)
-    }
-}
-
-impl AsRef<Signal> for SignalStream {
-    fn as_ref(&self) -> &Signal {
-        &self.inner
-    }
-}
-
-impl AsMut<Signal> for SignalStream {
-    fn as_mut(&mut self) -> &mut Signal {
-        &mut self.inner
-    }
-}

tokio-stream/src/wrappers/signal_windows.rs

@@ -1,88 +0,0 @@
-use crate::Stream;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::signal::windows::{CtrlBreak, CtrlC};
-
-/// A wrapper around [`CtrlC`] that implements [`Stream`].
-///
-/// [`CtrlC`]: struct@tokio::signal::windows::CtrlC
-/// [`Stream`]: trait@crate::Stream
-#[derive(Debug)]
-#[cfg_attr(docsrs, doc(cfg(all(windows, feature = "signal"))))]
-pub struct CtrlCStream {
-    inner: CtrlC,
-}
-
-impl CtrlCStream {
-    /// Create a new `CtrlCStream`.
-    pub fn new(interval: CtrlC) -> Self {
-        Self { inner: interval }
-    }
-
-    /// Get back the inner `CtrlC`.
-    pub fn into_inner(self) -> CtrlC {
-        self.inner
-    }
-}
-
-impl Stream for CtrlCStream {
-    type Item = ();
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<()>> {
-        self.inner.poll_recv(cx)
-    }
-}
-
-impl AsRef<CtrlC> for CtrlCStream {
-    fn as_ref(&self) -> &CtrlC {
-        &self.inner
-    }
-}
-
-impl AsMut<CtrlC> for CtrlCStream {
-    fn as_mut(&mut self) -> &mut CtrlC {
-        &mut self.inner
-    }
-}
-
-/// A wrapper around [`CtrlBreak`] that implements [`Stream`].
-///
-/// [`CtrlBreak`]: struct@tokio::signal::windows::CtrlBreak
-/// [`Stream`]: trait@crate::Stream
-#[derive(Debug)]
-#[cfg_attr(docsrs, doc(cfg(all(windows, feature = "signal"))))]
-pub struct CtrlBreakStream {
-    inner: CtrlBreak,
-}
-
-impl CtrlBreakStream {
-    /// Create a new `CtrlBreakStream`.
-    pub fn new(interval: CtrlBreak) -> Self {
-        Self { inner: interval }
-    }
-
-    /// Get back the inner `CtrlBreak`.
-    pub fn into_inner(self) -> CtrlBreak {
-        self.inner
-    }
-}
-
-impl Stream for CtrlBreakStream {
-    type Item = ();
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<()>> {
-        self.inner.poll_recv(cx)
-    }
-}
-
-impl AsRef<CtrlBreak> for CtrlBreakStream {
-    fn as_ref(&self) -> &CtrlBreak {
-        &self.inner
-    }
-}
-
-impl AsMut<CtrlBreak> for CtrlBreakStream {
-    fn as_mut(&mut self) -> &mut CtrlBreak {
-        &mut self.inner
-    }
-}