Add time to supported wasm features

.circleci/config.yml

@@ -22,4 +22,4 @@ jobs:
 workflows:
   ci:
     jobs:
-      - test-arm
+      - test-arm

.cirrus.yml

@@ -1,10 +1,8 @@
-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-12-4
+  image: freebsd-12-3-release-amd64
 env:
   RUST_STABLE: stable
-  RUST_NIGHTLY: nightly-2022-10-25
+  RUST_NIGHTLY: nightly-2022-03-21
   RUSTFLAGS: -D warnings
 
 # Test FreeBSD in a full VM on cirrus-ci.com.  Test the i686 target too, in the

.github/workflows/audit.yml

@@ -9,22 +9,14 @@ on:
   schedule:
     - cron: '0 2 * * *' # run at 2 AM UTC
 
-permissions:
-  contents: read
-
 jobs:
   security-audit:
-    permissions:
-      checks: write  # for rustsec/audit-check to create check
-      contents: read  # for actions/checkout to fetch code
-      issues: write  # for rustsec/audit-check to create issues
     runs-on: ubuntu-latest
     if: "!contains(github.event.head_commit.message, 'ci skip')"
     steps:
       - uses: actions/checkout@v3
 
       - name: Audit Check
-        # https://github.com/rustsec/audit-check/issues/2
-        uses: rustsec/audit-check@master
+        uses: actions-rs/audit-check@v1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/ci.yml

@@ -11,8 +11,8 @@ env:
   RUST_BACKTRACE: 1
   # Change to specific Rust release to pin
   rust_stable: stable
-  rust_nightly: nightly-2022-11-03
-  rust_clippy: 1.65.0
+  rust_nightly: nightly-2022-07-26
+  rust_clippy: 1.52.0
   # When updating this, also update:
   # - README.md
   # - tokio/README.md
@@ -27,9 +27,6 @@ defaults:
   run:
     shell: bash
 
-permissions:
-  contents: read
-
 jobs:
   # Depends on all action sthat are required for a "successful" CI run.
   tests-pass:
@@ -42,10 +39,7 @@ jobs:
       - test-unstable
       - miri
       - asan
-      - semver
-      - cross-check
-      - cross-test
-      - no-atomic-u64
+      - cross
       - features
       - minrust
       - minimal-versions
@@ -55,7 +49,6 @@ jobs:
       - loom-compile
       - check-readme
       - test-hyper
-      - x86_64-fortanix-unknown-sgx
       - wasm32-unknown-unknown
       - wasm32-wasi
       - check-external-types
@@ -74,14 +67,15 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
             toolchain: ${{ env.rust_stable }}
+            override: true
       - name: Install Rust
         run: rustup update stable
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@v1
       - name: Install cargo-hack
-        uses: taiki-e/install-action@cargo-hack
+        run: cargo install cargo-hack
 
       # Run `tokio` with `full` features. This excludes testing utilities which
       # can alter the runtime behavior of Tokio.
@@ -123,10 +117,11 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
             toolchain: ${{ env.rust_stable }}
-      - uses: Swatinem/rust-cache@v2
+            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
@@ -139,13 +134,16 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
             toolchain: ${{ env.rust_stable }}
-      - uses: Swatinem/rust-cache@v2
+            override: true
+      - uses: Swatinem/rust-cache@v1
 
       - name: Install Valgrind
-        uses: taiki-e/install-action@valgrind
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y valgrind
 
       # Compile tests
       - name: cargo build test-mem
@@ -177,10 +175,11 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
             toolchain: ${{ env.rust_stable }}
-      - uses: Swatinem/rust-cache@v2
+            override: true
+      - uses: Swatinem/rust-cache@v1
       # Run `tokio` with "unstable" cfg flag.
       - name: test tokio full --cfg unstable
         run: cargo test --all-features
@@ -197,18 +196,20 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_nightly }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_nightly }}
           components: miri
-      - uses: Swatinem/rust-cache@v2
+          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-strict-provenance -Zmiri-retag-fields
+          MIRIFLAGS: -Zmiri-disable-isolation -Zmiri-tag-raw-pointers
+          PROPTEST_CASES: 10
 
   asan:
     name: asan
@@ -219,10 +220,11 @@ jobs:
         # Required to resolve symbols in sanitizer output
         run: sudo apt-get install -y llvm
       - name: Install Rust ${{ env.rust_nightly }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_nightly }}
-      - uses: Swatinem/rust-cache@v2
+          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:
@@ -230,35 +232,13 @@ jobs:
           # Ignore `trybuild` errors as they are irrelevant and flaky on nightly
           TRYBUILD: overwrite
 
-  semver:
-    name: semver
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.rust_stable }}
-      - name: Install cargo-semver-checks
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-semver-checks
-      - name: Check semver compatibility
-        run: |
-          cargo semver-checks check-release \
-              --release-type minor \
-              --exclude benches \
-              --exclude examples \
-              --exclude stress-test \
-              --exclude tests-build \
-              --exclude tests-integration
-
-  cross-check:
-    name: cross-check
+  cross:
+    name: cross
     runs-on: ubuntu-latest
     strategy:
       matrix:
         target:
+          - i686-unknown-linux-gnu
           - powerpc-unknown-linux-gnu
           - powerpc64-unknown-linux-gnu
           - mips-unknown-linux-gnu
@@ -267,98 +247,43 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_stable }}
           target: ${{ matrix.target }}
-      - name: Install cross
-        uses: taiki-e/install-action@cross
-      - run: cross check --workspace --all-features --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
 
-  cross-test:
-    name: cross-test
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        include:
-          - target: i686-unknown-linux-gnu
-          - target: arm-unknown-linux-gnueabihf
-          - target: armv7-unknown-linux-gnueabihf
-          - target: aarch64-unknown-linux-gnu
-
-          # Run a platform without AtomicU64 and no const Mutex::new
-          - target: arm-unknown-linux-gnueabihf
-            rustflags: --cfg tokio_no_const_mutex_new
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.rust_stable }}
-          target: ${{ matrix.target }}
-      - name: Install cross
-        uses: taiki-e/install-action@cross
-      # First run with all features (including parking_lot)
-      - run: cross test -p tokio --all-features --target ${{ matrix.target }} --tests
-        env:
-          RUSTFLAGS: --cfg tokio_unstable -Dwarnings --cfg tokio_no_ipv6 ${{ matrix.rustflags }}
-      # Now run without parking_lot
-      - name: Remove `parking_lot` from `full` feature
-        run: sed -i '0,/parking_lot/{/parking_lot/d;}' tokio/Cargo.toml
-      # The `tokio_no_parking_lot` cfg is here to ensure the `sed` above does not silently break.
-      - run: cross test -p tokio --features full,test-util --target ${{ matrix.target }} --tests
-        env:
-          RUSTFLAGS: --cfg tokio_unstable -Dwarnings --cfg tokio_no_ipv6 --cfg tokio_no_parking_lot ${{ matrix.rustflags }}
-
-  # See https://github.com/tokio-rs/tokio/issues/5187
-  no-atomic-u64:
-    name: Test i686-unknown-linux-gnu without AtomicU64
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_nightly }}
-        uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.rust_nightly }}
-          components: rust-src
-      - name: Install cargo-hack
-        uses: taiki-e/install-action@cargo-hack
-      # Install linker and libraries for i686-unknown-linux-gnu
-      - uses: taiki-e/setup-cross-toolchain-action@v1
-        with:
-          target: i686-unknown-linux-gnu
-      - run: cargo test -Zbuild-std --target target-specs/i686-unknown-linux-gnu.json -p tokio --all-features
-        env:
-          RUSTFLAGS: --cfg tokio_unstable -Dwarnings --cfg tokio_no_atomic_u64
-      # https://github.com/tokio-rs/tokio/pull/5356
-      # https://github.com/tokio-rs/tokio/issues/5373
-      - run: cargo hack build -p tokio --feature-powerset --depth 2 -Z avoid-dev-deps --keep-going
-        env:
-          RUSTFLAGS: --cfg tokio_unstable -Dwarnings --cfg tokio_no_atomic_u64 --cfg tokio_no_const_mutex_new
-      - run: cargo hack build -p tokio --feature-powerset --depth 2 -Z avoid-dev-deps --keep-going
-        env:
-          RUSTFLAGS: --cfg tokio_unstable -Dwarnings --cfg tokio_no_atomic_u64
-
   features:
     name: features
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_nightly }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_nightly }}
           target: ${{ matrix.target }}
-      - uses: Swatinem/rust-cache@v2
+          override: true
+      - uses: Swatinem/rust-cache@v1
       - name: Install cargo-hack
-        uses: taiki-e/install-action@cargo-hack
-      - name: check --feature-powerset
-        run: cargo hack check --all --feature-powerset --depth 2 -Z avoid-dev-deps --keep-going
+        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 --feature-powerset --unstable
-        run: cargo hack check --all --feature-powerset --depth 2 -Z avoid-dev-deps --keep-going
+      - name: check --each-feature --unstable
+        run: cargo hack check --all --each-feature -Z avoid-dev-deps
         env:
           RUSTFLAGS: --cfg tokio_unstable -Dwarnings
 
@@ -368,27 +293,13 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_min }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_min }}
-      - uses: Swatinem/rust-cache@v2
-      # First compile just the main tokio crate with minrust and newest version
-      # of all dependencies, then pin once_cell and compile the rest of the
-      # crates with the pinned once_cell version.
-      #
-      # This is necessary because tokio-util transitively depends on once_cell,
-      # which is not compatible with the current minrust after the 1.15.0
-      # release.
-      - name: "check -p tokio --all-features"
-        run: cargo check -p tokio --all-features
-        env:
-          RUSTFLAGS: "" # remove -Dwarnings
-      - name: "pin once_cell version"
-        run: cargo update -p once_cell --precise 1.14.0
-      - name: "check --workspace --all-features"
+          override: true
+      - uses: Swatinem/rust-cache@v1
+      - name: "test --workspace --all-features"
         run: cargo check --workspace --all-features
-        env:
-          RUSTFLAGS: "" # remove -Dwarnings
 
   minimal-versions:
     name: minimal-versions
@@ -396,12 +307,13 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_nightly }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_nightly }}
-      - uses: Swatinem/rust-cache@v2
+          override: true
+      - uses: Swatinem/rust-cache@v1
       - name: Install cargo-hack
-        uses: taiki-e/install-action@cargo-hack
+        run: cargo install cargo-hack
       - name: "check --all-features -Z minimal-versions"
         run: |
           # Remove dev-dependencies from Cargo.toml to prevent the next `cargo update`
@@ -427,11 +339,12 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_stable }}
+          override: true
           components: rustfmt
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@v1
       # Check fmt
       - name: "rustfmt --check"
         # Workaround for rust-lang/cargo#7732
@@ -447,11 +360,12 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_clippy }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_clippy }}
+          override: true
           components: clippy
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@v1
       # Run clippy
       - name: "clippy --all"
         run: cargo clippy --all --tests --all-features
@@ -462,10 +376,11 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_nightly }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_nightly }}
-      - uses: Swatinem/rust-cache@v2
+          override: true
+      - uses: Swatinem/rust-cache@v1
       - name: "doc --lib --all-features"
         run: cargo doc --lib --no-deps --all-features --document-private-items
         env:
@@ -478,10 +393,11 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_stable }}
-      - uses: Swatinem/rust-cache@v2
+          override: true
+      - uses: Swatinem/rust-cache@v1
       - name: build --cfg loom
         run: cargo test --no-run --lib --features full
         working-directory: tokio
@@ -512,10 +428,11 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_stable }}
-      - uses: Swatinem/rust-cache@v2
+          override: true
+      - uses: Swatinem/rust-cache@v1
       - name: Test hyper
         run: |
           set -x
@@ -533,32 +450,17 @@ jobs:
           git diff
           cargo test --features full
 
-  x86_64-fortanix-unknown-sgx:
-    name: build tokio for x86_64-fortanix-unknown-sgx
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_nightly }}
-        uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.rust_nightly }}
-          target: x86_64-fortanix-unknown-sgx
-      - uses: Swatinem/rust-cache@v2
-      # NOTE: Currently the only test we can run is to build tokio with rt and sync features.
-      - name: build tokio
-        run: cargo build --target x86_64-fortanix-unknown-sgx --features rt,sync
-        working-directory: tokio
-
   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: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_stable }}
-      - uses: Swatinem/rust-cache@v2
+          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
@@ -571,20 +473,21 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_stable }}
-      - uses: Swatinem/rust-cache@v2
+          override: true
+      - uses: Swatinem/rust-cache@v1
 
       # Install dependencies
       - name: Install cargo-hack
-        uses: taiki-e/install-action@cargo-hack
+        run: cargo install cargo-hack
 
       - name: Install wasm32-wasi target
         run: rustup target add wasm32-wasi
 
       - name: Install wasmtime
-        uses: taiki-e/install-action@wasmtime
+        run: cargo install wasmtime-cli
 
       - name: Install cargo-wasi
         run: cargo install cargo-wasi
@@ -622,16 +525,16 @@ jobs:
           - ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - name: Install Rust nightly-2022-11-16
-        uses: dtolnay/rust-toolchain@master
+      - name: Install Rust ${{ env.rust_nightly }}
+        uses: actions-rs/toolchain@v1
         with:
-          # `check-external-types` requires a specific Rust nightly version. See
-          # the README for details: https://github.com/awslabs/cargo-check-external-types
-          toolchain: nightly-2022-11-16
-      - uses: Swatinem/rust-cache@v2
+          toolchain: ${{ env.rust_nightly }}
+          override: true
+      - uses: Swatinem/rust-cache@v1
       - name: check-external-types
         run: |
           set -x
-          cargo install cargo-check-external-types --locked --version 0.1.6
+          cargo install cargo-check-external-types --locked --version 0.1.3
           cargo check-external-types --all-features --config external-types.toml
         working-directory: tokio
+

.github/workflows/labeler.yml

@@ -4,14 +4,8 @@ on:
 
 # See .github/labeler.yml file
 
-permissions:
-  contents: read
-
 jobs:
   triage:
-    permissions:
-      contents: read  # for actions/labeler to determine modified files
-      pull-requests: write  # for actions/labeler to add labels to PRs
     runs-on: ubuntu-latest
     if: github.repository_owner == 'tokio-rs'
     steps:

.github/workflows/loom.yml

@@ -13,9 +13,6 @@ env:
   # Change to specific Rust release to pin
   rust_stable: stable
 
-permissions:
-  contents: read
-
 jobs:
   loom:
     name: loom
@@ -34,15 +31,15 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
             toolchain: ${{ env.rust_stable }}
-      - uses: Swatinem/rust-cache@v2
+            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
-          LOOM_MAX_BRANCHES: 10000
           SCOPE: ${{ matrix.scope }}

.github/workflows/pr-audit.yml

@@ -8,9 +8,6 @@ on:
     paths:
       - '**/Cargo.toml'
 
-permissions:
-  contents: read
-
 jobs:
   security-audit:
     runs-on: ubuntu-latest
@@ -19,10 +16,17 @@ jobs:
       - uses: actions/checkout@v3
 
       - name: Install cargo-audit
-        run: cargo install cargo-audit
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: cargo-audit
 
       - name: Generate lockfile
-        run: cargo generate-lockfile
+        uses: actions-rs/cargo@v1
+        with:
+          command: generate-lockfile
 
       - name: Audit dependencies
-        run: cargo audit
+        uses: actions-rs/cargo@v1
+        with:
+          command: audit

.github/workflows/stress-test.yml

@@ -11,9 +11,6 @@ env:
   # Change to specific Rust release to pin
   rust_stable: stable
 
-permissions:
-  contents: read
-
 jobs:
   stress-test:
     name: Stress Test
@@ -25,12 +22,15 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
             toolchain: ${{ env.rust_stable }}
-      - uses: Swatinem/rust-cache@v2
+            override: true
+      - uses: Swatinem/rust-cache@v1
       - name: Install Valgrind
-        uses: taiki-e/install-action@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
@@ -38,4 +38,4 @@ jobs:
 
       # Runs each of the examples using Valgrind. Detects leaks and displays them.
       - name: Run valgrind
-        run: valgrind --error-exitcode=1 --leak-check=full --show-leak-kinds=all ./target/release/examples/${{ matrix.stress-test }}
+        run: valgrind  --leak-check=full --show-leak-kinds=all ./target/release/examples/${{ matrix.stress-test }}

CONTRIBUTING.md

@@ -187,7 +187,7 @@ LOOM_MAX_PREEMPTIONS=1 RUSTFLAGS="--cfg loom" \
 
 You can run miri tests with
 ```
-MIRIFLAGS="-Zmiri-disable-isolation -Zmiri-tag-raw-pointers" \
+MIRIFLAGS="-Zmiri-disable-isolation -Zmiri-tag-raw-pointers" PROPTEST_CASES=10 \
     cargo +nightly miri test --features full --lib
 ```
 
@@ -209,31 +209,6 @@ utilities available to use in tests, no matter the crate being tested.
 The best strategy for writing a new integration test is to look at existing
 integration tests in the crate and follow the style.
 
-#### Fuzz tests
-
-Some of our crates include a set of fuzz tests, this will be marked by a
-directory `fuzz`. It is a good idea to run fuzz tests after each change.
-To get started with fuzz testing you'll need to install 
-[cargo-fuzz](https://github.com/rust-fuzz/cargo-fuzz).
-
-`cargo install cargo-fuzz`
-
-To list the available fuzzing harnesses you can run;
-
-```bash
-$ cd tokio
-$ cargo fuzz list
-fuzz_linked_list
-````
-
-Running a fuzz test is as simple as;
-
-`cargo fuzz run fuzz_linked_list`
-
-**NOTE**: Keep in mind that by default when running a fuzz test the fuzz
-harness will run forever and will only exit if you `ctrl-c` or it finds
-a bug.
-
 #### Documentation tests
 
 Ideally, every API has at least one [documentation test] that demonstrates how to

Cross.toml

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

LICENSE

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

README.md

@@ -56,7 +56,7 @@ Make sure you activated the full features of the tokio crate on Cargo.toml:
 
 ```toml
 [dependencies]
-tokio = { version = "1.25.0", features = ["full"] }
+tokio = { version = "1.20.1", features = ["full"] }
 ```
 Then, on your main.rs:
 
@@ -202,12 +202,12 @@ 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.18.x` - LTS release until June 2023
- * `1.20.x` - LTS release until September 2023.
+ * `1.18.x` - LTS release until January 2023
+ * `1.20.x` - LTS release until April 2023.
 
-Each LTS release will continue to receive backported fixes for at least a year.
-If you wish to use a fixed minor release in your project, we recommend that you
-use an LTS release.
+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.18.x` patch release, you

benches/Cargo.toml

@@ -7,8 +7,6 @@ edition = "2018"
 [dependencies]
 tokio = { version = "1.5.0", path = "../tokio", features = ["full"] }
 bencher = "0.1.5"
-rand = "0.8"
-rand_chacha = "0.3"
 
 [dev-dependencies]
 tokio-util = { version = "0.7.0", path = "../tokio-util", features = ["full"] }
@@ -27,16 +25,6 @@ name = "sync_mpsc"
 path = "sync_mpsc.rs"
 harness = false
 
-[[bench]]
-name = "sync_mpsc_oneshot"
-path = "sync_mpsc_oneshot.rs"
-harness = false
-
-[[bench]]
-name = "sync_watch"
-path = "sync_watch.rs"
-harness = false
-
 [[bench]]
 name = "rt_multi_threaded"
 path = "rt_multi_threaded.rs"
@@ -62,8 +50,3 @@ harness = false
 name = "fs"
 path = "fs.rs"
 harness = false
-
-[[bench]]
-name = "copy"
-path = "copy.rs"
-harness = false

benches/copy.rs

@@ -1,238 +0,0 @@
-use bencher::{benchmark_group, benchmark_main, Bencher};
-
-use rand::{Rng, SeedableRng};
-use rand_chacha::ChaCha20Rng;
-
-use tokio::io::{copy, repeat, AsyncRead, AsyncReadExt, AsyncWrite};
-use tokio::time::{interval, Interval, MissedTickBehavior};
-
-use std::task::Poll;
-use std::time::Duration;
-
-const KILO: usize = 1024;
-
-// Tunable parameters if you want to change this benchmark. If reader and writer
-// are matched in kilobytes per second, then this only exposes buffering to the
-// benchmark.
-const RNG_SEED: u64 = 0;
-// How much data to copy in a single benchmark run
-const SOURCE_SIZE: u64 = 256 * KILO as u64;
-// Read side provides CHUNK_SIZE every READ_SERVICE_PERIOD. If it's not called
-// frequently, it'll burst to catch up (representing OS buffers draining)
-const CHUNK_SIZE: usize = 2 * KILO;
-const READ_SERVICE_PERIOD: Duration = Duration::from_millis(1);
-// Write side buffers up to WRITE_BUFFER, and flushes to disk every
-// WRITE_SERVICE_PERIOD.
-const WRITE_BUFFER: usize = 40 * KILO;
-const WRITE_SERVICE_PERIOD: Duration = Duration::from_millis(20);
-// How likely you are to have to wait for previously written data to be flushed
-// because another writer claimed the buffer space
-const PROBABILITY_FLUSH_WAIT: f64 = 0.1;
-
-/// A slow writer that aims to simulate HDD behaviour under heavy load.
-///
-/// There is a limited buffer, which is fully drained on the next write after
-/// a time limit is reached. Flush waits for the time limit to be reached
-/// and then drains the buffer.
-///
-/// At random, the HDD will stall writers while it flushes out all buffers. If
-/// this happens to you, you will be unable to write until the next time the
-/// buffer is drained.
-struct SlowHddWriter {
-    service_intervals: Interval,
-    blocking_rng: ChaCha20Rng,
-    buffer_size: usize,
-    buffer_used: usize,
-}
-
-impl SlowHddWriter {
-    fn new(service_interval: Duration, buffer_size: usize) -> Self {
-        let blocking_rng = ChaCha20Rng::seed_from_u64(RNG_SEED);
-        let mut service_intervals = interval(service_interval);
-        service_intervals.set_missed_tick_behavior(MissedTickBehavior::Delay);
-        Self {
-            service_intervals,
-            blocking_rng,
-            buffer_size,
-            buffer_used: 0,
-        }
-    }
-
-    fn service_write(
-        mut self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Result<(), std::io::Error>> {
-        // If we hit a service interval, the buffer can be cleared
-        let res = self.service_intervals.poll_tick(cx).map(|_| Ok(()));
-        if let Poll::Ready(_) = res {
-            self.buffer_used = 0;
-        }
-        res
-    }
-
-    fn write_bytes(
-        mut self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-        writeable: usize,
-    ) -> std::task::Poll<Result<usize, std::io::Error>> {
-        let service_res = self.as_mut().service_write(cx);
-
-        if service_res.is_pending() && self.blocking_rng.gen_bool(PROBABILITY_FLUSH_WAIT) {
-            return Poll::Pending;
-        }
-        let available = self.buffer_size - self.buffer_used;
-
-        if available == 0 {
-            assert!(service_res.is_pending());
-            Poll::Pending
-        } else {
-            let written = available.min(writeable);
-            self.buffer_used += written;
-            Poll::Ready(Ok(written))
-        }
-    }
-}
-
-impl Unpin for SlowHddWriter {}
-
-impl AsyncWrite for SlowHddWriter {
-    fn poll_write(
-        self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-        buf: &[u8],
-    ) -> std::task::Poll<Result<usize, std::io::Error>> {
-        self.write_bytes(cx, buf.len())
-    }
-
-    fn poll_flush(
-        self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Result<(), std::io::Error>> {
-        self.service_write(cx)
-    }
-
-    fn poll_shutdown(
-        self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Result<(), std::io::Error>> {
-        self.service_write(cx)
-    }
-
-    fn poll_write_vectored(
-        self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-        bufs: &[std::io::IoSlice<'_>],
-    ) -> std::task::Poll<Result<usize, std::io::Error>> {
-        let writeable = bufs.into_iter().fold(0, |acc, buf| acc + buf.len());
-        self.write_bytes(cx, writeable)
-    }
-
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-}
-
-/// A reader that limits the maximum chunk it'll give you back
-///
-/// Simulates something reading from a slow link - you get one chunk per call,
-/// and you are offered chunks on a schedule
-struct ChunkReader {
-    data: Vec<u8>,
-    service_intervals: Interval,
-}
-
-impl ChunkReader {
-    fn new(chunk_size: usize, service_interval: Duration) -> Self {
-        let mut service_intervals = interval(service_interval);
-        service_intervals.set_missed_tick_behavior(MissedTickBehavior::Burst);
-        let data: Vec<u8> = std::iter::repeat(0).take(chunk_size).collect();
-        Self {
-            data,
-            service_intervals,
-        }
-    }
-}
-
-impl AsyncRead for ChunkReader {
-    fn poll_read(
-        mut self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-        buf: &mut tokio::io::ReadBuf<'_>,
-    ) -> Poll<std::io::Result<()>> {
-        if self.service_intervals.poll_tick(cx).is_pending() {
-            return Poll::Pending;
-        }
-        buf.put_slice(&self.data[..buf.remaining().min(self.data.len())]);
-        Poll::Ready(Ok(()))
-    }
-}
-
-fn rt() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_current_thread()
-        .enable_time()
-        .build()
-        .unwrap()
-}
-
-fn copy_mem_to_mem(b: &mut Bencher) {
-    let rt = rt();
-
-    b.iter(|| {
-        let task = || async {
-            let mut source = repeat(0).take(SOURCE_SIZE);
-            let mut dest = Vec::new();
-            copy(&mut source, &mut dest).await.unwrap();
-        };
-
-        rt.block_on(task());
-    })
-}
-
-fn copy_mem_to_slow_hdd(b: &mut Bencher) {
-    let rt = rt();
-
-    b.iter(|| {
-        let task = || async {
-            let mut source = repeat(0).take(SOURCE_SIZE);
-            let mut dest = SlowHddWriter::new(WRITE_SERVICE_PERIOD, WRITE_BUFFER);
-            copy(&mut source, &mut dest).await.unwrap();
-        };
-
-        rt.block_on(task());
-    })
-}
-
-fn copy_chunk_to_mem(b: &mut Bencher) {
-    let rt = rt();
-    b.iter(|| {
-        let task = || async {
-            let mut source = ChunkReader::new(CHUNK_SIZE, READ_SERVICE_PERIOD).take(SOURCE_SIZE);
-            let mut dest = Vec::new();
-            copy(&mut source, &mut dest).await.unwrap();
-        };
-
-        rt.block_on(task());
-    })
-}
-
-fn copy_chunk_to_slow_hdd(b: &mut Bencher) {
-    let rt = rt();
-    b.iter(|| {
-        let task = || async {
-            let mut source = ChunkReader::new(CHUNK_SIZE, READ_SERVICE_PERIOD).take(SOURCE_SIZE);
-            let mut dest = SlowHddWriter::new(WRITE_SERVICE_PERIOD, WRITE_BUFFER);
-            copy(&mut source, &mut dest).await.unwrap();
-        };
-
-        rt.block_on(task());
-    })
-}
-
-benchmark_group!(
-    copy_bench,
-    copy_mem_to_mem,
-    copy_mem_to_slow_hdd,
-    copy_chunk_to_mem,
-    copy_chunk_to_slow_hdd,
-);
-benchmark_main!(copy_bench);

benches/sync_mpsc_oneshot.rs

@@ -1,53 +0,0 @@
-use bencher::{benchmark_group, benchmark_main, Bencher};
-use tokio::{
-    runtime::Runtime,
-    sync::{mpsc, oneshot},
-};
-
-fn request_reply_current_thread(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_current_thread()
-        .build()
-        .unwrap();
-
-    request_reply(b, rt);
-}
-
-fn request_reply_multi_threaded(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(1)
-        .build()
-        .unwrap();
-
-    request_reply(b, rt);
-}
-
-fn request_reply(b: &mut Bencher, rt: Runtime) {
-    let tx = rt.block_on(async move {
-        let (tx, mut rx) = mpsc::channel::<oneshot::Sender<()>>(10);
-        tokio::spawn(async move {
-            while let Some(reply) = rx.recv().await {
-                reply.send(()).unwrap();
-            }
-        });
-        tx
-    });
-
-    b.iter(|| {
-        let task_tx = tx.clone();
-        rt.block_on(async move {
-            for _ in 0..1_000 {
-                let (o_tx, o_rx) = oneshot::channel();
-                task_tx.send(o_tx).await.unwrap();
-                let _ = o_rx.await;
-            }
-        })
-    });
-}
-
-benchmark_group!(
-    sync_mpsc_oneshot_group,
-    request_reply_current_thread,
-    request_reply_multi_threaded,
-);
-
-benchmark_main!(sync_mpsc_oneshot_group);

benches/sync_watch.rs

@@ -1,64 +0,0 @@
-use bencher::{black_box, Bencher};
-use rand::prelude::*;
-use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::Arc;
-use tokio::sync::{watch, Notify};
-
-fn rt() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
-        .build()
-        .unwrap()
-}
-
-fn do_work(rng: &mut impl RngCore) -> u32 {
-    use std::fmt::Write;
-    let mut message = String::new();
-    for i in 1..=10 {
-        let _ = write!(&mut message, " {i}={}", rng.gen::<f64>());
-    }
-    message
-        .as_bytes()
-        .iter()
-        .map(|&c| c as u32)
-        .fold(0, u32::wrapping_add)
-}
-
-fn contention_resubscribe(b: &mut Bencher) {
-    const NTASK: u64 = 1000;
-
-    let rt = rt();
-    let (snd, rcv) = watch::channel(0i32);
-    let wg = Arc::new((AtomicU64::new(0), Notify::new()));
-    for n in 0..NTASK {
-        let mut rcv = rcv.clone();
-        let wg = wg.clone();
-        let mut rng = rand::rngs::StdRng::seed_from_u64(n);
-        rt.spawn(async move {
-            while rcv.changed().await.is_ok() {
-                let _ = *rcv.borrow(); // contend on rwlock
-                let r = do_work(&mut rng);
-                let _ = black_box(r);
-                if wg.0.fetch_sub(1, Ordering::Release) == 1 {
-                    wg.1.notify_one();
-                }
-            }
-        });
-    }
-
-    b.iter(|| {
-        rt.block_on(async {
-            for _ in 0..100 {
-                assert_eq!(wg.0.fetch_add(NTASK, Ordering::Relaxed), 0);
-                let _ = snd.send(black_box(42));
-                while wg.0.load(Ordering::Acquire) > 0 {
-                    wg.1.notified().await;
-                }
-            }
-        });
-    });
-}
-
-bencher::benchmark_group!(contention, contention_resubscribe);
-
-bencher::benchmark_main!(contention);

examples/Cargo.toml

@@ -24,8 +24,8 @@ httpdate = "1.0"
 once_cell = "1.5.2"
 rand = "0.8.3"
 
-[target.'cfg(windows)'.dev-dependencies.windows-sys]
-version = "0.45"
+[target.'cfg(windows)'.dev-dependencies.winapi]
+version = "0.3.8"
 
 [[example]]
 name = "chat"
@@ -75,6 +75,7 @@ path = "tinyhttp.rs"
 name = "custom-executor"
 path = "custom-executor.rs"
 
+
 [[example]]
 name = "custom-executor-tokio-context"
 path = "custom-executor-tokio-context.rs"

examples/hello_world.rs

@@ -1,7 +1,9 @@
+//! Hello world server.
+//!
 //! A simple client that opens a TCP stream, writes "hello world\n", and closes
 //! the connection.
 //!
-//! To start a server that this client can talk to on port 6142, you can use this command:
+//! You can test this out by running:
 //!
 //!     ncat -l 6142
 //!
@@ -24,7 +26,7 @@ pub async fn main() -> Result<(), Box<dyn Error>> {
     let mut stream = TcpStream::connect("127.0.0.1:6142").await?;
     println!("created stream");
 
-    let result = stream.write_all(b"hello world\n").await;
+    let result = stream.write(b"hello world\n").await;
     println!("wrote to stream; success={:?}", result.is_ok());
 
     Ok(())

examples/named-pipe-multi-client.rs

@@ -6,7 +6,7 @@ async fn windows_main() -> io::Result<()> {
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
     use tokio::net::windows::named_pipe::{ClientOptions, ServerOptions};
     use tokio::time;
-    use windows_sys::Win32::Foundation::ERROR_PIPE_BUSY;
+    use winapi::shared::winerror;
 
     const PIPE_NAME: &str = r"\\.\pipe\named-pipe-multi-client";
     const N: usize = 10;
@@ -59,7 +59,7 @@ async fn windows_main() -> io::Result<()> {
             let mut client = loop {
                 match ClientOptions::new().open(PIPE_NAME) {
                     Ok(client) => break client,
-                    Err(e) if e.raw_os_error() == Some(ERROR_PIPE_BUSY as i32) => (),
+                    Err(e) if e.raw_os_error() == Some(winerror::ERROR_PIPE_BUSY as i32) => (),
                     Err(e) => return Err(e),
                 }
 

target-specs/i686-unknown-linux-gnu.json

@@ -1,40 +0,0 @@
-{
-  "arch": "x86",
-  "cpu": "pentium4",
-  "crt-static-respected": true,
-  "data-layout": "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128",
-  "dynamic-linking": true,
-  "env": "gnu",
-  "has-rpath": true,
-  "has-thread-local": true,
-  "llvm-target": "i686-unknown-linux-gnu",
-  "max-atomic-width": 32,
-  "os": "linux",
-  "position-independent-executables": true,
-  "pre-link-args": {
-    "gcc": [
-      "-m32"
-    ]
-  },
-  "relro-level": "full",
-  "stack-probes": {
-    "kind": "inline-or-call",
-    "min-llvm-version-for-inline": [
-      16,
-      0,
-      0
-    ]
-  },
-  "supported-sanitizers": [
-    "address"
-  ],
-  "supported-split-debuginfo": [
-    "packed",
-    "unpacked",
-    "off"
-  ],
-  "target-family": [
-    "unix"
-  ],
-  "target-pointer-width": "32"
-}

tests-integration/Cargo.toml

@@ -58,4 +58,3 @@ tokio = { path = "../tokio" }
 tokio-test = { path = "../tokio-test", optional = true }
 doc-comment = "0.3.1"
 futures = { version = "0.3.0", features = ["async-await"] }
-bytes = "1.0.0"

tests-integration/tests/process_stdio.rs

@@ -190,54 +190,3 @@ async fn pipe_from_one_command_to_another() {
     assert!(second_status.expect("second status").success());
     assert!(third_status.expect("third status").success());
 }
-
-#[tokio::test]
-async fn vectored_writes() {
-    use bytes::{Buf, Bytes};
-    use std::{io::IoSlice, pin::Pin};
-    use tokio::io::AsyncWrite;
-
-    let mut cat = cat().spawn().unwrap();
-    let mut stdin = cat.stdin.take().unwrap();
-    let are_writes_vectored = stdin.is_write_vectored();
-    let mut stdout = cat.stdout.take().unwrap();
-
-    let write = async {
-        let mut input = Bytes::from_static(b"hello\n").chain(Bytes::from_static(b"world!\n"));
-        let mut writes_completed = 0;
-
-        futures::future::poll_fn(|cx| loop {
-            let mut slices = [IoSlice::new(&[]); 2];
-            let vectored = input.chunks_vectored(&mut slices);
-            if vectored == 0 {
-                return std::task::Poll::Ready(std::io::Result::Ok(()));
-            }
-            let n = futures::ready!(Pin::new(&mut stdin).poll_write_vectored(cx, &slices))?;
-            writes_completed += 1;
-            input.advance(n);
-        })
-        .await?;
-
-        drop(stdin);
-
-        std::io::Result::Ok(writes_completed)
-    };
-
-    let read = async {
-        let mut buffer = Vec::with_capacity(6 + 7);
-        stdout.read_to_end(&mut buffer).await?;
-        std::io::Result::Ok(buffer)
-    };
-
-    let (write, read, status) = future::join3(write, read, cat.wait()).await;
-
-    assert!(status.unwrap().success());
-
-    let writes_completed = write.unwrap();
-    // on unix our small payload should always fit in whatever default sized pipe with a single
-    // syscall. if multiple are used, then the forwarding does not work, or we are on a platform
-    // for which the `std` does not support vectored writes.
-    assert_eq!(writes_completed == 1, are_writes_vectored);
-
-    assert_eq!(&read.unwrap(), b"hello\nworld!\n");
-}

tokio-macros/CHANGELOG.md

@@ -1,21 +1,3 @@
-# 1.8.2 (November 30th, 2022)
-
-- fix a regression introduced in 1.8.1 ([#5244])
-
-[#5244]: https://github.com/tokio-rs/tokio/pull/5244
-
-# 1.8.1 (November 29th, 2022)
-
-(yanked)
-
-- macros: Pin Futures in `#[tokio::test]` to stack ([#5205])
-- macros: Reduce usage of last statement spans in proc-macros ([#5092])
-- macros: Improve the documentation for `#[tokio::test]` ([#4761])
-
-[#5205]: https://github.com/tokio-rs/tokio/pull/5205
-[#5092]: https://github.com/tokio-rs/tokio/pull/5092
-[#4761]: https://github.com/tokio-rs/tokio/pull/4761
-
 # 1.8.0 (June 4th, 2022)
 
 - macros: always emit return statement ([#4636])

tokio-macros/Cargo.toml

@@ -3,8 +3,8 @@ name = "tokio-macros"
 # When releasing to crates.io:
 # - Remove path dependencies
 # - Update CHANGELOG.md.
-# - Create "tokio-macros-1.x.y" git tag.
-version = "1.8.2"
+# - Create "tokio-macros-1.0.x" git tag.
+version = "1.8.0"
 edition = "2018"
 rust-version = "1.49"
 authors = ["Tokio Contributors <[email protected]>"]

tokio-macros/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2023 Tokio Contributors
+Copyright (c) 2022 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

@@ -383,50 +383,17 @@ fn parse_knobs(mut input: syn::ItemFn, is_test: bool, config: FinalConfig) -> To
 
     let body = &input.block;
     let brace_token = input.block.brace_token;
-    let body_ident = quote! { body };
-    let block_expr = quote_spanned! {last_stmt_end_span=>
-        #[allow(clippy::expect_used, clippy::diverging_sub_expression)]
+    input.block = syn::parse2(quote_spanned! {last_stmt_end_span=>
         {
-            return #rt
-                .enable_all()
-                .build()
-                .expect("Failed building the Runtime")
-                .block_on(#body_ident);
-        }
-    };
-
-    // For test functions pin the body to the stack and use `Pin<&mut dyn
-    // Future>` to reduce the amount of `Runtime::block_on` (and related
-    // functions) copies we generate during compilation due to the generic
-    // parameter `F` (the future to block on). This could have an impact on
-    // performance, but because it's only for testing it's unlikely to be very
-    // large.
-    //
-    // We don't do this for the main function as it should only be used once so
-    // there will be no benefit.
-    let body = if is_test {
-        let output_type = match &input.sig.output {
-            // For functions with no return value syn doesn't print anything,
-            // but that doesn't work as `Output` for our boxed `Future`, so
-            // default to `()` (the same type as the function output).
-            syn::ReturnType::Default => quote! { () },
-            syn::ReturnType::Type(_, ret_type) => quote! { #ret_type },
-        };
-        quote! {
             let body = async #body;
-            #crate_ident::pin!(body);
-            let body: ::std::pin::Pin<&mut dyn ::std::future::Future<Output = #output_type>> = body;
-        }
-    } else {
-        quote! {
-            let body = async #body;
-        }
-    };
-
-    input.block = syn::parse2(quote! {
-        {
-            #body
-            #block_expr
+            #[allow(clippy::expect_used, clippy::diverging_sub_expression)]
+            {
+                return #rt
+                    .enable_all()
+                    .build()
+                    .expect("Failed building the Runtime")
+                    .block_on(body);
+            }
         }
     })
     .expect("Parsing failure");
@@ -480,7 +447,7 @@ pub(crate) fn test(args: TokenStream, item: TokenStream, rt_multi_thread: bool)
     };
     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))
+        Err(syn::Error::new_spanned(&attr, msg))
     } else {
         AttributeArgs::parse_terminated
             .parse(args)

tokio-macros/src/select.rs

@@ -100,10 +100,10 @@ fn clean_pattern(pat: &mut syn::Pat) {
         }
         syn::Pat::Reference(reference) => {
             reference.mutability = None;
-            clean_pattern(&mut reference.pat);
+            clean_pattern(&mut *reference.pat);
         }
         syn::Pat::Type(type_pat) => {
-            clean_pattern(&mut type_pat.pat);
+            clean_pattern(&mut *type_pat.pat);
         }
         _ => {}
     }

tokio-stream/CHANGELOG.md

@@ -1,25 +1,3 @@
-# 0.1.12 (January 20, 2022)
-
-- time: remove `Unpin` bound on `Throttle` methods ([#5105])
-- time: document that `throttle` operates on ms granularity ([#5101])
-
-[#5105]: https://github.com/tokio-rs/tokio/pull/5105
-[#5101]: https://github.com/tokio-rs/tokio/pull/5101
-
-# 0.1.11 (October 11, 2022)
-
-- time: allow `StreamExt::chunks_timeout` outside of a runtime ([#5036])
-
-[#5036]: https://github.com/tokio-rs/tokio/pull/5036
-
-# 0.1.10 (Sept 18, 2022)
-
-- time: add `StreamExt::chunks_timeout` ([#4695])
-- stream: add track_caller to public APIs ([#4786])
-
-[#4695]: https://github.com/tokio-rs/tokio/pull/4695
-[#4786]: https://github.com/tokio-rs/tokio/pull/4786
-
 # 0.1.9 (June 4, 2022)
 
 - deps: upgrade `tokio-util` dependency to `0.7.x` ([#3762])

tokio-stream/Cargo.toml

@@ -4,7 +4,7 @@ name = "tokio-stream"
 # - Remove path dependencies
 # - Update CHANGELOG.md.
 # - Create "tokio-stream-0.1.x" git tag.
-version = "0.1.12"
+version = "0.1.9"
 edition = "2018"
 rust-version = "1.49"
 authors = ["Tokio Contributors <[email protected]>"]
@@ -38,6 +38,9 @@ parking_lot = "0.12.0"
 tokio-test = { path = "../tokio-test" }
 futures = { version = "0.3", default-features = false }
 
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+proptest = "1"
+
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]

tokio-stream/LICENSE

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

tokio-stream/fuzz/.gitignore

@@ -1,4 +0,0 @@
-target
-corpus
-artifacts
-coverage

tokio-stream/fuzz/Cargo.toml

@@ -1,29 +0,0 @@
-[package]
-name = "tokio-stream-fuzz"
-version = "0.0.0"
-publish = false
-edition = "2018"
-
-[package.metadata]
-cargo-fuzz = true
-
-[dependencies]
-libfuzzer-sys = "0.4"
-tokio-test = { path = "../../tokio-test" }
-
-[dependencies.tokio-stream]
-path = ".."
-
-
-# Prevent this from interfering with workspaces
-[workspace]
-members = ["."]
-
-[profile.release]
-debug = 1
-
-[[bin]]
-name = "fuzz_stream_map"
-path = "fuzz_targets/fuzz_stream_map.rs"
-test = false
-doc = false

tokio-stream/fuzz/fuzz_targets/fuzz_stream_map.rs

@@ -1,80 +0,0 @@
-#![no_main]
-
-use libfuzzer_sys::fuzz_target;
-use std::pin::Pin;
-
-use tokio_stream::{self as stream, pending, Stream, StreamExt, StreamMap};
-use tokio_test::{assert_ok, assert_pending, assert_ready, task};
-
-macro_rules! assert_ready_some {
-    ($($t:tt)*) => {
-        match assert_ready!($($t)*) {
-            Some(v) => v,
-            None => panic!("expected `Some`, got `None`"),
-        }
-    };
-}
-
-macro_rules! assert_ready_none {
-    ($($t:tt)*) => {
-        match assert_ready!($($t)*) {
-            None => {}
-            Some(v) => panic!("expected `None`, got `Some({:?})`", v),
-        }
-    };
-}
-
-fn pin_box<T: Stream<Item = U> + 'static, U>(s: T) -> Pin<Box<dyn Stream<Item = U>>> {
-    Box::pin(s)
-}
-
-fuzz_target!(|data: &[u8]| {
-    use std::task::{Context, Poll};
-
-    struct DidPoll<T> {
-        did_poll: bool,
-        inner: T,
-    }
-
-    impl<T: Stream + Unpin> Stream for DidPoll<T> {
-        type Item = T::Item;
-
-        fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<T::Item>> {
-            self.did_poll = true;
-            Pin::new(&mut self.inner).poll_next(cx)
-        }
-    }
-
-    for _ in 0..10 {
-        let mut map = task::spawn(StreamMap::new());
-        let mut expect = 0;
-
-        for (i, is_empty) in data.iter().map(|x| *x != 0).enumerate() {
-            let inner = if is_empty {
-                pin_box(stream::empty::<()>())
-            } else {
-                expect += 1;
-                pin_box(stream::pending::<()>())
-            };
-
-            let stream = DidPoll {
-                did_poll: false,
-                inner,
-            };
-
-            map.insert(i, stream);
-        }
-
-        if expect == 0 {
-            assert_ready_none!(map.poll_next());
-        } else {
-            assert_pending!(map.poll_next());
-
-            assert_eq!(expect, map.values().count());
-
-            for stream in map.values() {
-                assert!(stream.did_poll);
-            }
-        }
-    }
-});

tokio-stream/src/stream_ext.rs

@@ -982,8 +982,6 @@ pub trait StreamExt: Stream {
 
     /// Slows down a stream by enforcing a delay between items.
     ///
-    /// The underlying timer behind this utility has a granularity of one millisecond.
-    ///
     /// # Example
     ///
     /// Create a throttled stream.

tokio-stream/src/stream_ext/chunks_timeout.rs

@@ -1,6 +1,6 @@
 use crate::stream_ext::Fuse;
 use crate::Stream;
-use tokio::time::{sleep, Sleep};
+use tokio::time::{sleep, Instant, Sleep};
 
 use core::future::Future;
 use core::pin::Pin;
@@ -16,7 +16,7 @@ pin_project! {
         #[pin]
         stream: Fuse<S>,
         #[pin]
-        deadline: Option<Sleep>,
+        deadline: Sleep,
         duration: Duration,
         items: Vec<S::Item>,
         cap: usize, // https://github.com/rust-lang/futures-rs/issues/1475
@@ -27,7 +27,7 @@ impl<S: Stream> ChunksTimeout<S> {
     pub(super) fn new(stream: S, max_size: usize, duration: Duration) -> Self {
         ChunksTimeout {
             stream: Fuse::new(stream),
-            deadline: None,
+            deadline: sleep(duration),
             duration,
             items: Vec::with_capacity(max_size),
             cap: max_size,
@@ -45,7 +45,7 @@ impl<S: Stream> Stream for ChunksTimeout<S> {
                 Poll::Pending => break,
                 Poll::Ready(Some(item)) => {
                     if me.items.is_empty() {
-                        me.deadline.set(Some(sleep(*me.duration)));
+                        me.deadline.as_mut().reset(Instant::now() + *me.duration);
                         me.items.reserve_exact(*me.cap);
                     }
                     me.items.push(item);
@@ -67,9 +67,7 @@ impl<S: Stream> Stream for ChunksTimeout<S> {
         }
 
         if !me.items.is_empty() {
-            if let Some(deadline) = me.deadline.as_pin_mut() {
-                ready!(deadline.poll(cx));
-            }
+            ready!(me.deadline.poll(cx));
             return Poll::Ready(Some(std::mem::take(me.items)));
         }
 

tokio-stream/src/stream_ext/collect.rs

@@ -195,7 +195,11 @@ where
         } else {
             let res = mem::replace(collection, Ok(U::initialize(sealed::Internal, 0, Some(0))));
 
-            Err(res.map(drop).unwrap_err())
+            if let Err(err) = res {
+                Err(err)
+            } else {
+                unreachable!();
+            }
         }
     }
 }

tokio-stream/src/stream_ext/then.rs

@@ -72,7 +72,7 @@ where
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let future_len = usize::from(self.future.is_some());
+        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);

tokio-stream/src/stream_ext/throttle.rs

@@ -4,6 +4,7 @@ use crate::Stream;
 use tokio::time::{Duration, Instant, Sleep};
 
 use std::future::Future;
+use std::marker::Unpin;
 use std::pin::Pin;
 use std::task::{self, Poll};
 
@@ -40,7 +41,8 @@ pin_project! {
     }
 }
 
-impl<T> Throttle<T> {
+// XXX: are these safe if `T: !Unpin`?
+impl<T: Unpin> Throttle<T> {
     /// Acquires a reference to the underlying stream that this combinator is
     /// pulling from.
     pub fn get_ref(&self) -> &T {

tokio-stream/src/stream_ext/timeout.rs

@@ -24,7 +24,7 @@ pin_project! {
 }
 
 /// Error returned by `Timeout`.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq)]
 pub struct Elapsed(());
 
 impl<S: Stream> Timeout<S> {

tokio-stream/src/wrappers/broadcast.rs

@@ -18,7 +18,7 @@ pub struct BroadcastStream<T> {
 }
 
 /// An error returned from the inner stream of a [`BroadcastStream`].
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[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.

tokio-stream/src/wrappers/watch.rs

@@ -10,9 +10,8 @@ use tokio::sync::watch::error::RecvError;
 
 /// A wrapper around [`tokio::sync::watch::Receiver`] that implements [`Stream`].
 ///
-/// This stream will start by yielding the current value when the WatchStream is polled,
-/// regardless of whether it was the initial value or sent afterwards,
-/// unless you use [`WatchStream<T>::from_changes`].
+/// This stream will always start by yielding the current value when the WatchStream is polled,
+/// regardless of whether it was the initial value or sent afterwards.
 ///
 /// # Examples
 ///
@@ -41,28 +40,6 @@ use tokio::sync::watch::error::RecvError;
 /// let (tx, rx) = watch::channel("hello");
 /// let mut rx = WatchStream::new(rx);
 ///
-/// // existing rx output with "hello" is ignored here
-///
-/// tx.send("goodbye").unwrap();
-/// assert_eq!(rx.next().await, Some("goodbye"));
-/// # }
-/// ```
-///
-/// Example with [`WatchStream<T>::from_changes`]:
-///
-/// ```
-/// # #[tokio::main]
-/// # async fn main() {
-/// use futures::future::FutureExt;
-/// use tokio::sync::watch;
-/// use tokio_stream::{StreamExt, wrappers::WatchStream};
-///
-/// let (tx, rx) = watch::channel("hello");
-/// let mut rx = WatchStream::from_changes(rx);
-///
-/// // no output from rx is available at this point - let's check this:
-/// assert!(rx.next().now_or_never().is_none());
-///
 /// tx.send("goodbye").unwrap();
 /// assert_eq!(rx.next().await, Some("goodbye"));
 /// # }
@@ -89,13 +66,6 @@ impl<T: 'static + Clone + Send + Sync> WatchStream<T> {
             inner: ReusableBoxFuture::new(async move { (Ok(()), rx) }),
         }
     }
-
-    /// Create a new `WatchStream` that waits for the value to be changed.
-    pub fn from_changes(rx: Receiver<T>) -> Self {
-        Self {
-            inner: ReusableBoxFuture::new(make_future(rx)),
-        }
-    }
 }
 
 impl<T: Clone + 'static + Send + Sync> Stream for WatchStream<T> {

tokio-stream/tests/stream_stream_map.rs

@@ -325,6 +325,63 @@ fn one_ready_many_none() {
     }
 }
 
+#[cfg(not(target_os = "wasi"))]
+proptest::proptest! {
+    #[test]
+    fn fuzz_pending_complete_mix(kinds: Vec<bool>) {
+        use std::task::{Context, Poll};
+
+        struct DidPoll<T> {
+            did_poll: bool,
+            inner: T,
+        }
+
+        impl<T: Stream + Unpin> Stream for DidPoll<T> {
+            type Item = T::Item;
+
+            fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>)
+                -> Poll<Option<T::Item>>
+            {
+                self.did_poll = true;
+                Pin::new(&mut self.inner).poll_next(cx)
+            }
+        }
+
+        for _ in 0..10 {
+            let mut map = task::spawn(StreamMap::new());
+            let mut expect = 0;
+
+            for (i, &is_empty) in kinds.iter().enumerate() {
+                let inner = if is_empty {
+                    pin_box(stream::empty::<()>())
+                } else {
+                    expect += 1;
+                    pin_box(stream::pending::<()>())
+                };
+
+                let stream = DidPoll {
+                    did_poll: false,
+                    inner,
+                };
+
+                map.insert(i, stream);
+            }
+
+            if expect == 0 {
+                assert_ready_none!(map.poll_next());
+            } else {
+                assert_pending!(map.poll_next());
+
+                assert_eq!(expect, map.values().count());
+
+                for stream in map.values() {
+                    assert!(stream.did_poll);
+                }
+            }
+        }
+    }
+}
+
 fn pin_box<T: Stream<Item = U> + 'static, U>(s: T) -> Pin<Box<dyn Stream<Item = U>>> {
     Box::pin(s)
 }

tokio-stream/tests/watch.rs

@@ -3,11 +3,9 @@
 use tokio::sync::watch;
 use tokio_stream::wrappers::WatchStream;
 use tokio_stream::StreamExt;
-use tokio_test::assert_pending;
-use tokio_test::task::spawn;
 
 #[tokio::test]
-async fn watch_stream_message_not_twice() {
+async fn message_not_twice() {
     let (tx, rx) = watch::channel("hello");
 
     let mut counter = 0;
@@ -29,29 +27,3 @@ async fn watch_stream_message_not_twice() {
     drop(tx);
     task.await.unwrap();
 }
-
-#[tokio::test]
-async fn watch_stream_from_rx() {
-    let (tx, rx) = watch::channel("hello");
-
-    let mut stream = WatchStream::from(rx);
-
-    assert_eq!(stream.next().await.unwrap(), "hello");
-
-    tx.send("bye").unwrap();
-
-    assert_eq!(stream.next().await.unwrap(), "bye");
-}
-
-#[tokio::test]
-async fn watch_stream_from_changes() {
-    let (tx, rx) = watch::channel("hello");
-
-    let mut stream = WatchStream::from_changes(rx);
-
-    assert_pending!(spawn(&mut stream).poll_next());
-
-    tx.send("bye").unwrap();
-
-    assert_eq!(stream.next().await.unwrap(), "bye");
-}

tokio-test/Cargo.toml

@@ -19,7 +19,7 @@ categories = ["asynchronous", "testing"]
 [dependencies]
 tokio = { version = "1.2.0", path = "../tokio", features = ["rt", "sync", "time", "test-util"] }
 tokio-stream = { version = "0.1.1", path = "../tokio-stream" }
-async-stream = "0.3.3"
+async-stream = "0.3"
 
 bytes = "1.0.0"
 futures-core = "0.3.0"

tokio-test/LICENSE

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

tokio-test/src/task.rs

@@ -1,29 +1,4 @@
-//! Futures task based helpers to easily test futures and manually written futures.
-//!
-//! The [`Spawn`] type is used as a mock task harness that allows you to poll futures
-//! without needing to setup pinning or context. Any future can be polled but if the
-//! future requires the tokio async context you will need to ensure that you poll the
-//! [`Spawn`] within a tokio context, this means that as long as you are inside the
-//! runtime it will work and you can poll it via [`Spawn`].
-//!
-//! [`Spawn`] also supports [`Stream`] to call `poll_next` without pinning
-//! or context.
-//!
-//! In addition to circumventing the need for pinning and context, [`Spawn`] also tracks
-//! the amount of times the future/task was woken. This can be useful to track if some
-//! leaf future notified the root task correctly.
-//!
-//! # Example
-//!
-//! ```
-//! use tokio_test::task;
-//!
-//! let fut = async {};
-//!
-//! let mut task = task::spawn(fut);
-//!
-//! assert!(task.poll().is_ready(), "Task was not ready!");
-//! ```
+//! Futures task based helpers
 
 #![allow(clippy::mutex_atomic)]
 
@@ -36,11 +11,7 @@ use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
 
 use tokio_stream::Stream;
 
-/// Spawn a future into a [`Spawn`] which wraps the future in a mocked executor.
-///
-/// This can be used to spawn a [`Future`] or a [`Stream`].
-///
-/// For more information, check the module docs.
+/// TODO: dox
 pub fn spawn<T>(task: T) -> Spawn<T> {
     Spawn {
         task: MockTask::new(),
@@ -48,14 +19,16 @@ pub fn spawn<T>(task: T) -> Spawn<T> {
     }
 }
 
-/// Future spawned on a mock task that can be used to poll the future or stream
-/// without needing pinning or context types.
+/// Future spawned on a mock task
 #[derive(Debug)]
 pub struct Spawn<T> {
     task: MockTask,
     future: Pin<Box<T>>,
 }
 
+/// Mock task
+///
+/// A mock task is able to intercept and track wake notifications.
 #[derive(Debug, Clone)]
 struct MockTask {
     waker: Arc<ThreadWaker>,
@@ -118,8 +91,7 @@ impl<T: Unpin> ops::DerefMut for Spawn<T> {
 }
 
 impl<T: Future> Spawn<T> {
-    /// If `T` is a [`Future`] then poll it. This will handle pinning and the context
-    /// type for the future.
+    /// Polls a future
     pub fn poll(&mut self) -> Poll<T::Output> {
         let fut = self.future.as_mut();
         self.task.enter(|cx| fut.poll(cx))
@@ -127,8 +99,7 @@ impl<T: Future> Spawn<T> {
 }
 
 impl<T: Stream> Spawn<T> {
-    /// If `T` is a [`Stream`] then poll_next it. This will handle pinning and the context
-    /// type for the stream.
+    /// Polls a stream
     pub fn poll_next(&mut self) -> Poll<Option<T::Item>> {
         let stream = self.future.as_mut();
         self.task.enter(|cx| stream.poll_next(cx))

tokio-util/CHANGELOG.md

@@ -1,74 +1,3 @@
-# 0.7.7 (February 12, 2023)
-
-This release reverts the removal of the `Encoder` bound on the `FramedParts`
-constructor from [#5280] since it turned out to be a breaking change. ([#5450])
-
-[#5450]: https://github.com/tokio-rs/tokio/pull/5450
-
-# 0.7.6 (February 10, 2023)
-
-This release fixes a compilation failure in 0.7.5 when it is used together with
-Tokio version 1.21 and unstable features are enabled. ([#5445])
-
-[#5445]: https://github.com/tokio-rs/tokio/pull/5445
-
-# 0.7.5 (February 9, 2023)
-
-This release fixes an accidental breaking change where `UnwindSafe` was
-accidentally removed from `CancellationToken`.
-
-### Added
-- codec: add `Framed::backpressure_boundary` ([#5124])
-- io: add `InspectReader` and `InspectWriter` ([#5033])
-- io: add `tokio_util::io::{CopyToBytes, SinkWriter}` ([#5070], [#5436])
-- io: impl `std::io::BufRead` on `SyncIoBridge` ([#5265])
-- sync: add `PollSemaphore::poll_acquire_many` ([#5137])
-- sync: add owned future for `CancellationToken` ([#5153])
-- time: add `DelayQueue::try_remove` ([#5052])
-
-### Fixed
-- codec: fix `LengthDelimitedCodec` buffer over-reservation ([#4997])
-- sync: impl `UnwindSafe` on `CancellationToken` ([#5438])
-- util: remove `Encoder` bound on `FramedParts` constructor ([#5280])
-
-### Documented
-- io: add lines example for `StreamReader` ([#5145])
-
-[#4997]: https://github.com/tokio-rs/tokio/pull/4997
-[#5033]: https://github.com/tokio-rs/tokio/pull/5033
-[#5052]: https://github.com/tokio-rs/tokio/pull/5052
-[#5070]: https://github.com/tokio-rs/tokio/pull/5070
-[#5124]: https://github.com/tokio-rs/tokio/pull/5124
-[#5137]: https://github.com/tokio-rs/tokio/pull/5137
-[#5145]: https://github.com/tokio-rs/tokio/pull/5145
-[#5153]: https://github.com/tokio-rs/tokio/pull/5153
-[#5265]: https://github.com/tokio-rs/tokio/pull/5265
-[#5280]: https://github.com/tokio-rs/tokio/pull/5280
-[#5436]: https://github.com/tokio-rs/tokio/pull/5436
-[#5438]: https://github.com/tokio-rs/tokio/pull/5438
-
-# 0.7.4 (September 8, 2022)
-
-### Added
-
-- io: add `SyncIoBridge::shutdown()` ([#4938])
-- task: improve `LocalPoolHandle` ([#4680])
-
-### Fixed
-
-- util: add `track_caller` to public APIs ([#4785])
-
-### Unstable
-
-- task: fix compilation errors in `JoinMap` with Tokio v1.21.0 ([#4755])
-- task: remove the unstable, deprecated `JoinMap::join_one` ([#4920])
-
-[#4680]: https://github.com/tokio-rs/tokio/pull/4680
-[#4755]: https://github.com/tokio-rs/tokio/pull/4755
-[#4785]: https://github.com/tokio-rs/tokio/pull/4785
-[#4920]: https://github.com/tokio-rs/tokio/pull/4920
-[#4938]: https://github.com/tokio-rs/tokio/pull/4938
-
 # 0.7.3 (June 4, 2022)
 
 ### Changed

tokio-util/Cargo.toml

@@ -4,7 +4,7 @@ name = "tokio-util"
 # - Remove path dependencies
 # - Update CHANGELOG.md.
 # - Create "tokio-util-0.7.x" git tag.
-version = "0.7.7"
+version = "0.7.3"
 edition = "2018"
 rust-version = "1.49"
 authors = ["Tokio Contributors <[email protected]>"]
@@ -34,7 +34,7 @@ rt = ["tokio/rt", "tokio/sync", "futures-util", "hashbrown"]
 __docs_rs = ["futures-util"]
 
 [dependencies]
-tokio = { version = "1.22.0", path = "../tokio", features = ["sync"] }
+tokio = { version = "1.19.0", path = "../tokio", features = ["sync"] }
 bytes = "1.0.0"
 futures-core = "0.3.0"
 futures-sink = "0.3.0"

tokio-util/LICENSE

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

tokio-util/src/codec/framed.rs

@@ -253,16 +253,6 @@ impl<T, U> Framed<T, U> {
         &mut self.inner.state.write.buffer
     }
 
-    /// Returns backpressure boundary
-    pub fn backpressure_boundary(&self) -> usize {
-        self.inner.state.write.backpressure_boundary
-    }
-
-    /// Updates backpressure boundary
-    pub fn set_backpressure_boundary(&mut self, boundary: usize) {
-        self.inner.state.write.backpressure_boundary = boundary;
-    }
-
     /// Consumes the `Framed`, returning its underlying I/O stream.
     ///
     /// Note that care should be taken to not tamper with the underlying stream

tokio-util/src/codec/framed_impl.rs

@@ -25,6 +25,7 @@ pin_project! {
 }
 
 const INITIAL_CAPACITY: usize = 8 * 1024;
+const BACKPRESSURE_BOUNDARY: usize = INITIAL_CAPACITY;
 
 #[derive(Debug)]
 pub(crate) struct ReadFrame {
@@ -36,7 +37,6 @@ pub(crate) struct ReadFrame {
 
 pub(crate) struct WriteFrame {
     pub(crate) buffer: BytesMut,
-    pub(crate) backpressure_boundary: usize,
 }
 
 #[derive(Default)]
@@ -60,7 +60,6 @@ impl Default for WriteFrame {
     fn default() -> Self {
         Self {
             buffer: BytesMut::with_capacity(INITIAL_CAPACITY),
-            backpressure_boundary: INITIAL_CAPACITY,
         }
     }
 }
@@ -88,10 +87,7 @@ impl From<BytesMut> for WriteFrame {
             buffer.reserve(INITIAL_CAPACITY - size);
         }
 
-        Self {
-            buffer,
-            backpressure_boundary: INITIAL_CAPACITY,
-        }
+        Self { buffer }
     }
 }
 
@@ -260,7 +256,7 @@ where
     type Error = U::Error;
 
     fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        if self.state.borrow().buffer.len() >= self.state.borrow().backpressure_boundary {
+        if self.state.borrow().buffer.len() >= BACKPRESSURE_BOUNDARY {
             self.as_mut().poll_flush(cx)
         } else {
             Poll::Ready(Ok(()))
@@ -281,7 +277,7 @@ where
         let mut pinned = self.project();
 
         while !pinned.state.borrow_mut().buffer.is_empty() {
-            let WriteFrame { buffer, .. } = pinned.state.borrow_mut();
+            let WriteFrame { buffer } = pinned.state.borrow_mut();
             trace!(remaining = buffer.len(), "writing;");
 
             let n = ready!(poll_write_buf(pinned.inner.as_mut(), cx, buffer))?;

tokio-util/src/codec/framed_write.rs

@@ -123,16 +123,6 @@ impl<T, E> FramedWrite<T, E> {
     pub fn write_buffer_mut(&mut self) -> &mut BytesMut {
         &mut self.inner.state.buffer
     }
-
-    /// Returns backpressure boundary
-    pub fn backpressure_boundary(&self) -> usize {
-        self.inner.state.backpressure_boundary
-    }
-
-    /// Updates backpressure boundary
-    pub fn set_backpressure_boundary(&mut self, boundary: usize) {
-        self.inner.state.backpressure_boundary = boundary;
-    }
 }
 
 // This impl just defers to the underlying FramedImpl

tokio-util/src/codec/length_delimited.rs

@@ -522,11 +522,15 @@ impl LengthDelimitedCodec {
             }
         };
 
-        src.advance(self.builder.get_num_skip());
+        let num_skip = self.builder.get_num_skip();
+
+        if num_skip > 0 {
+            src.advance(num_skip);
+        }
 
         // Ensure that the buffer has enough space to read the incoming
         // payload
-        src.reserve(n.saturating_sub(src.len()));
+        src.reserve(n);
 
         Ok(Some(n))
     }
@@ -564,7 +568,7 @@ impl Decoder for LengthDelimitedCodec {
                 self.state = DecodeState::Head;
 
                 // Make sure the buffer has enough space to read the next head
-                src.reserve(self.builder.num_head_bytes().saturating_sub(src.len()));
+                src.reserve(self.builder.num_head_bytes());
 
                 Ok(Some(data))
             }

tokio-util/src/io/copy_to_bytes.rs

@@ -1,68 +0,0 @@
-use bytes::Bytes;
-use futures_sink::Sink;
-use pin_project_lite::pin_project;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-pin_project! {
-    /// A helper that wraps a [`Sink`]`<`[`Bytes`]`>` and converts it into a
-    /// [`Sink`]`<&'a [u8]>` by copying each byte slice into an owned [`Bytes`].
-    ///
-    /// See the documentation for [`SinkWriter`] for an example.
-    ///
-    /// [`Bytes`]: bytes::Bytes
-    /// [`SinkWriter`]: crate::io::SinkWriter
-    /// [`Sink`]: futures_sink::Sink
-    #[derive(Debug)]
-    pub struct CopyToBytes<S> {
-        #[pin]
-        inner: S,
-    }
-}
-
-impl<S> CopyToBytes<S> {
-    /// Creates a new [`CopyToBytes`].
-    pub fn new(inner: S) -> Self {
-        Self { inner }
-    }
-
-    /// Gets a reference to the underlying sink.
-    pub fn get_ref(&self) -> &S {
-        &self.inner
-    }
-
-    /// Gets a mutable reference to the underlying sink.
-    pub fn get_mut(&mut self) -> &mut S {
-        &mut self.inner
-    }
-
-    /// Consumes this [`CopyToBytes`], returning the underlying sink.
-    pub fn into_inner(self) -> S {
-        self.inner
-    }
-}
-
-impl<'a, S> Sink<&'a [u8]> for CopyToBytes<S>
-where
-    S: Sink<Bytes>,
-{
-    type Error = S::Error;
-
-    fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.project().inner.poll_ready(cx)
-    }
-
-    fn start_send(self: Pin<&mut Self>, item: &'a [u8]) -> Result<(), Self::Error> {
-        self.project()
-            .inner
-            .start_send(Bytes::copy_from_slice(item))
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.project().inner.poll_flush(cx)
-    }
-
-    fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.project().inner.poll_close(cx)
-    }
-}

tokio-util/src/io/inspect.rs

@@ -1,134 +0,0 @@
-use futures_core::ready;
-use pin_project_lite::pin_project;
-use std::io::{IoSlice, Result};
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
-
-pin_project! {
-    /// An adapter that lets you inspect the data that's being read.
-    ///
-    /// This is useful for things like hashing data as it's read in.
-    pub struct InspectReader<R, F> {
-        #[pin]
-        reader: R,
-        f: F,
-    }
-}
-
-impl<R, F> InspectReader<R, F> {
-    /// Create a new InspectReader, wrapping `reader` and calling `f` for the
-    /// new data supplied by each read call.
-    ///
-    /// The closure will only be called with an empty slice if the inner reader
-    /// returns without reading data into the buffer. This happens at EOF, or if
-    /// `poll_read` is called with a zero-size buffer.
-    pub fn new(reader: R, f: F) -> InspectReader<R, F>
-    where
-        R: AsyncRead,
-        F: FnMut(&[u8]),
-    {
-        InspectReader { reader, f }
-    }
-
-    /// Consumes the `InspectReader`, returning the wrapped reader
-    pub fn into_inner(self) -> R {
-        self.reader
-    }
-}
-
-impl<R: AsyncRead, F: FnMut(&[u8])> AsyncRead for InspectReader<R, F> {
-    fn poll_read(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<Result<()>> {
-        let me = self.project();
-        let filled_length = buf.filled().len();
-        ready!(me.reader.poll_read(cx, buf))?;
-        (me.f)(&buf.filled()[filled_length..]);
-        Poll::Ready(Ok(()))
-    }
-}
-
-pin_project! {
-    /// An adapter that lets you inspect the data that's being written.
-    ///
-    /// This is useful for things like hashing data as it's written out.
-    pub struct InspectWriter<W, F> {
-        #[pin]
-        writer: W,
-        f: F,
-    }
-}
-
-impl<W, F> InspectWriter<W, F> {
-    /// Create a new InspectWriter, wrapping `write` and calling `f` for the
-    /// data successfully written by each write call.
-    ///
-    /// The closure `f` will never be called with an empty slice. A vectored
-    /// write can result in multiple calls to `f` - at most one call to `f` per
-    /// buffer supplied to `poll_write_vectored`.
-    pub fn new(writer: W, f: F) -> InspectWriter<W, F>
-    where
-        W: AsyncWrite,
-        F: FnMut(&[u8]),
-    {
-        InspectWriter { writer, f }
-    }
-
-    /// Consumes the `InspectWriter`, returning the wrapped writer
-    pub fn into_inner(self) -> W {
-        self.writer
-    }
-}
-
-impl<W: AsyncWrite, F: FnMut(&[u8])> AsyncWrite for InspectWriter<W, F> {
-    fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<Result<usize>> {
-        let me = self.project();
-        let res = me.writer.poll_write(cx, buf);
-        if let Poll::Ready(Ok(count)) = res {
-            if count != 0 {
-                (me.f)(&buf[..count]);
-            }
-        }
-        res
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
-        let me = self.project();
-        me.writer.poll_flush(cx)
-    }
-
-    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
-        let me = self.project();
-        me.writer.poll_shutdown(cx)
-    }
-
-    fn poll_write_vectored(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        bufs: &[IoSlice<'_>],
-    ) -> Poll<Result<usize>> {
-        let me = self.project();
-        let res = me.writer.poll_write_vectored(cx, bufs);
-        if let Poll::Ready(Ok(mut count)) = res {
-            for buf in bufs {
-                if count == 0 {
-                    break;
-                }
-                let size = count.min(buf.len());
-                if size != 0 {
-                    (me.f)(&buf[..size]);
-                    count -= size;
-                }
-            }
-        }
-        res
-    }
-
-    fn is_write_vectored(&self) -> bool {
-        self.writer.is_write_vectored()
-    }
-}

tokio-util/src/io/mod.rs

@@ -10,22 +10,15 @@
 //! [`Body`]: https://docs.rs/hyper/0.13/hyper/struct.Body.html
 //! [`AsyncRead`]: tokio::io::AsyncRead
 
-mod copy_to_bytes;
-mod inspect;
 mod read_buf;
 mod reader_stream;
-mod sink_writer;
 mod stream_reader;
-
 cfg_io_util! {
     mod sync_bridge;
     pub use self::sync_bridge::SyncIoBridge;
 }
 
-pub use self::copy_to_bytes::CopyToBytes;
-pub use self::inspect::{InspectReader, InspectWriter};
 pub use self::read_buf::read_buf;
 pub use self::reader_stream::ReaderStream;
-pub use self::sink_writer::SinkWriter;
 pub use self::stream_reader::StreamReader;
 pub use crate::util::{poll_read_buf, poll_write_buf};

tokio-util/src/io/sink_writer.rs

@@ -1,117 +0,0 @@
-use futures_core::ready;
-use futures_sink::Sink;
-
-use pin_project_lite::pin_project;
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::io::AsyncWrite;
-
-pin_project! {
-    /// Convert a [`Sink`] of byte chunks into an [`AsyncWrite`].
-    ///
-    /// Whenever you write to this [`SinkWriter`], the supplied bytes are
-    /// forwarded to the inner [`Sink`]. When `shutdown` is called on this
-    /// [`SinkWriter`], the inner sink is closed.
-    ///
-    /// This adapter takes a `Sink<&[u8]>` and provides an [`AsyncWrite`] impl
-    /// for it. Because of the lifetime, this trait is relatively rarely
-    /// implemented. The main ways to get a `Sink<&[u8]>` that you can use with
-    /// this type are:
-    ///
-    ///  * With the codec module by implementing the [`Encoder`]`<&[u8]>` trait.
-    ///  * By wrapping a `Sink<Bytes>` in a [`CopyToBytes`].
-    ///  * Manually implementing `Sink<&[u8]>` directly.
-    ///
-    /// The opposite conversion of implementing `Sink<_>` for an [`AsyncWrite`]
-    /// is done using the [`codec`] module.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use bytes::Bytes;
-    /// use futures_util::SinkExt;
-    /// use std::io::{Error, ErrorKind};
-    /// use tokio::io::AsyncWriteExt;
-    /// use tokio_util::io::{SinkWriter, CopyToBytes};
-    /// use tokio_util::sync::PollSender;
-    ///
-    /// # #[tokio::main(flavor = "current_thread")]
-    /// # async fn main() -> Result<(), Error> {
-    /// // We use an mpsc channel as an example of a `Sink<Bytes>`.
-    /// let (tx, mut rx) = tokio::sync::mpsc::channel::<Bytes>(1);
-    /// let sink = PollSender::new(tx).sink_map_err(|_| Error::from(ErrorKind::BrokenPipe));
-    ///
-    /// // Wrap it in `CopyToBytes` to get a `Sink<&[u8]>`.
-    /// let mut writer = SinkWriter::new(CopyToBytes::new(sink));
-    ///
-    /// // Write data to our interface...
-    /// let data: [u8; 4] = [1, 2, 3, 4];
-    /// let _ = writer.write(&data).await?;
-    ///
-    /// // ... and receive it.
-    /// assert_eq!(data.as_slice(), &*rx.recv().await.unwrap());
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// [`AsyncWrite`]: tokio::io::AsyncWrite
-    /// [`CopyToBytes`]: crate::io::CopyToBytes
-    /// [`Encoder`]: crate::codec::Encoder
-    /// [`Sink`]: futures_sink::Sink
-    /// [`codec`]: tokio_util::codec
-    #[derive(Debug)]
-    pub struct SinkWriter<S> {
-        #[pin]
-        inner: S,
-    }
-}
-
-impl<S> SinkWriter<S> {
-    /// Creates a new [`SinkWriter`].
-    pub fn new(sink: S) -> Self {
-        Self { inner: sink }
-    }
-
-    /// Gets a reference to the underlying sink.
-    pub fn get_ref(&self) -> &S {
-        &self.inner
-    }
-
-    /// Gets a mutable reference to the underlying sink.
-    pub fn get_mut(&mut self) -> &mut S {
-        &mut self.inner
-    }
-
-    /// Consumes this [`SinkWriter`], returning the underlying sink.
-    pub fn into_inner(self) -> S {
-        self.inner
-    }
-}
-impl<S, E> AsyncWrite for SinkWriter<S>
-where
-    for<'a> S: Sink<&'a [u8], Error = E>,
-    E: Into<io::Error>,
-{
-    fn poll_write(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<Result<usize, io::Error>> {
-        let mut this = self.project();
-
-        ready!(this.inner.as_mut().poll_ready(cx).map_err(Into::into))?;
-        match this.inner.as_mut().start_send(buf) {
-            Ok(()) => Poll::Ready(Ok(buf.len())),
-            Err(e) => Poll::Ready(Err(e.into())),
-        }
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
-        self.project().inner.poll_flush(cx).map_err(Into::into)
-    }
-
-    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
-        self.project().inner.poll_close(cx).map_err(Into::into)
-    }
-}

tokio-util/src/io/stream_reader.rs

@@ -1,162 +1,64 @@
 use bytes::Buf;
 use futures_core::stream::Stream;
+use pin_project_lite::pin_project;
 use std::io;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 use tokio::io::{AsyncBufRead, AsyncRead, ReadBuf};
 
-/// Convert a [`Stream`] of byte chunks into an [`AsyncRead`].
-///
-/// This type performs the inverse operation of [`ReaderStream`].
-///
-/// This type also implements the [`AsyncBufRead`] trait, so you can use it
-/// to read a `Stream` of byte chunks line-by-line. See the examples below.
-///
-/// # Example
-///
-/// ```
-/// use bytes::Bytes;
-/// use tokio::io::{AsyncReadExt, Result};
-/// use tokio_util::io::StreamReader;
-/// # #[tokio::main(flavor = "current_thread")]
-/// # async fn main() -> std::io::Result<()> {
-///
-/// // Create a stream from an iterator.
-/// let stream = tokio_stream::iter(vec![
-///     Result::Ok(Bytes::from_static(&[0, 1, 2, 3])),
-///     Result::Ok(Bytes::from_static(&[4, 5, 6, 7])),
-///     Result::Ok(Bytes::from_static(&[8, 9, 10, 11])),
-/// ]);
-///
-/// // Convert it to an AsyncRead.
-/// let mut read = StreamReader::new(stream);
-///
-/// // Read five bytes from the stream.
-/// let mut buf = [0; 5];
-/// read.read_exact(&mut buf).await?;
-/// assert_eq!(buf, [0, 1, 2, 3, 4]);
-///
-/// // Read the rest of the current chunk.
-/// assert_eq!(read.read(&mut buf).await?, 3);
-/// assert_eq!(&buf[..3], [5, 6, 7]);
-///
-/// // Read the next chunk.
-/// assert_eq!(read.read(&mut buf).await?, 4);
-/// assert_eq!(&buf[..4], [8, 9, 10, 11]);
-///
-/// // We have now reached the end.
-/// assert_eq!(read.read(&mut buf).await?, 0);
-///
-/// # Ok(())
-/// # }
-/// ```
-///
-/// If the stream produces errors which are not [`std::io::Error`],
-/// the errors can be converted using [`StreamExt`] to map each
-/// element.
-///
-/// ```
-/// use bytes::Bytes;
-/// use tokio::io::AsyncReadExt;
-/// use tokio_util::io::StreamReader;
-/// use tokio_stream::StreamExt;
-/// # #[tokio::main(flavor = "current_thread")]
-/// # async fn main() -> std::io::Result<()> {
-///
-/// // Create a stream from an iterator, including an error.
-/// let stream = tokio_stream::iter(vec![
-///     Result::Ok(Bytes::from_static(&[0, 1, 2, 3])),
-///     Result::Ok(Bytes::from_static(&[4, 5, 6, 7])),
-///     Result::Err("Something bad happened!")
-/// ]);
-///
-/// // Use StreamExt to map the stream and error to a std::io::Error
-/// let stream = stream.map(|result| result.map_err(|err| {
-///     std::io::Error::new(std::io::ErrorKind::Other, err)
-/// }));
-///
-/// // Convert it to an AsyncRead.
-/// let mut read = StreamReader::new(stream);
-///
-/// // Read five bytes from the stream.
-/// let mut buf = [0; 5];
-/// read.read_exact(&mut buf).await?;
-/// assert_eq!(buf, [0, 1, 2, 3, 4]);
-///
-/// // Read the rest of the current chunk.
-/// assert_eq!(read.read(&mut buf).await?, 3);
-/// assert_eq!(&buf[..3], [5, 6, 7]);
-///
-/// // Reading the next chunk will produce an error
-/// let error = read.read(&mut buf).await.unwrap_err();
-/// assert_eq!(error.kind(), std::io::ErrorKind::Other);
-/// assert_eq!(error.into_inner().unwrap().to_string(), "Something bad happened!");
-///
-/// // We have now reached the end.
-/// assert_eq!(read.read(&mut buf).await?, 0);
-///
-/// # Ok(())
-/// # }
-/// ```
-///
-/// Using the [`AsyncBufRead`] impl, you can read a `Stream` of byte chunks
-/// line-by-line. Note that you will usually also need to convert the error
-/// type when doing this. See the second example for an explanation of how
-/// to do this.
-///
-/// ```
-/// use tokio::io::{Result, AsyncBufReadExt};
-/// use tokio_util::io::StreamReader;
-/// # #[tokio::main(flavor = "current_thread")]
-/// # async fn main() -> std::io::Result<()> {
-///
-/// // Create a stream of byte chunks.
-/// let stream = tokio_stream::iter(vec![
-///     Result::Ok(b"The first line.\n".as_slice()),
-///     Result::Ok(b"The second line.".as_slice()),
-///     Result::Ok(b"\nThe third".as_slice()),
-///     Result::Ok(b" line.\nThe fourth line.\nThe fifth line.\n".as_slice()),
-/// ]);
-///
-/// // Convert it to an AsyncRead.
-/// let mut read = StreamReader::new(stream);
-///
-/// // Loop through the lines from the `StreamReader`.
-/// let mut line = String::new();
-/// let mut lines = Vec::new();
-/// loop {
-///     line.clear();
-///     let len = read.read_line(&mut line).await?;
-///     if len == 0 { break; }
-///     lines.push(line.clone());
-/// }
-///
-/// // Verify that we got the lines we expected.
-/// assert_eq!(
-///     lines,
-///     vec![
-///         "The first line.\n",
-///         "The second line.\n",
-///         "The third line.\n",
-///         "The fourth line.\n",
-///         "The fifth line.\n",
-///     ]
-/// );
-/// # Ok(())
-/// # }
-/// ```
-///
-/// [`AsyncRead`]: tokio::io::AsyncRead
-/// [`AsyncBufRead`]: tokio::io::AsyncBufRead
-/// [`Stream`]: futures_core::Stream
-/// [`ReaderStream`]: crate::io::ReaderStream
-/// [`StreamExt`]: https://docs.rs/tokio-stream/latest/tokio_stream/trait.StreamExt.html
-#[derive(Debug)]
-pub struct StreamReader<S, B> {
-    // This field is pinned.
-    inner: S,
-    // This field is not pinned.
-    chunk: Option<B>,
+pin_project! {
+    /// Convert a [`Stream`] of byte chunks into an [`AsyncRead`].
+    ///
+    /// This type performs the inverse operation of [`ReaderStream`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use bytes::Bytes;
+    /// use tokio::io::{AsyncReadExt, Result};
+    /// use tokio_util::io::StreamReader;
+    /// # #[tokio::main]
+    /// # async fn main() -> std::io::Result<()> {
+    ///
+    /// // Create a stream from an iterator.
+    /// let stream = tokio_stream::iter(vec![
+    ///     Result::Ok(Bytes::from_static(&[0, 1, 2, 3])),
+    ///     Result::Ok(Bytes::from_static(&[4, 5, 6, 7])),
+    ///     Result::Ok(Bytes::from_static(&[8, 9, 10, 11])),
+    /// ]);
+    ///
+    /// // Convert it to an AsyncRead.
+    /// let mut read = StreamReader::new(stream);
+    ///
+    /// // Read five bytes from the stream.
+    /// let mut buf = [0; 5];
+    /// read.read_exact(&mut buf).await?;
+    /// assert_eq!(buf, [0, 1, 2, 3, 4]);
+    ///
+    /// // Read the rest of the current chunk.
+    /// assert_eq!(read.read(&mut buf).await?, 3);
+    /// assert_eq!(&buf[..3], [5, 6, 7]);
+    ///
+    /// // Read the next chunk.
+    /// assert_eq!(read.read(&mut buf).await?, 4);
+    /// assert_eq!(&buf[..4], [8, 9, 10, 11]);
+    ///
+    /// // We have now reached the end.
+    /// assert_eq!(read.read(&mut buf).await?, 0);
+    ///
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// [`AsyncRead`]: tokio::io::AsyncRead
+    /// [`Stream`]: futures_core::Stream
+    /// [`ReaderStream`]: crate::io::ReaderStream
+    #[derive(Debug)]
+    pub struct StreamReader<S, B> {
+        #[pin]
+        inner: S,
+        chunk: Option<B>,
+    }
 }
 
 impl<S, B, E> StreamReader<S, B>
@@ -299,28 +201,3 @@ where
         }
     }
 }
-
-// The code below is a manual expansion of the code that pin-project-lite would
-// generate. This is done because pin-project-lite fails by hitting the recusion
-// limit on this struct. (Every line of documentation is handled recursively by
-// the macro.)
-
-impl<S: Unpin, B> Unpin for StreamReader<S, B> {}
-
-struct StreamReaderProject<'a, S, B> {
-    inner: Pin<&'a mut S>,
-    chunk: &'a mut Option<B>,
-}
-
-impl<S, B> StreamReader<S, B> {
-    #[inline]
-    fn project(self: Pin<&mut Self>) -> StreamReaderProject<'_, S, B> {
-        // SAFETY: We define that only `inner` should be pinned when `Self` is
-        // and have an appropriate `impl Unpin` for this.
-        let me = unsafe { Pin::into_inner_unchecked(self) };
-        StreamReaderProject {
-            inner: unsafe { Pin::new_unchecked(&mut me.inner) },
-            chunk: &mut me.chunk,
-        }
-    }
-}

tokio-util/src/io/sync_bridge.rs

@@ -1,7 +1,5 @@
-use std::io::{BufRead, Read, Write};
-use tokio::io::{
-    AsyncBufRead, AsyncBufReadExt, AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt,
-};
+use std::io::{Read, Write};
+use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 
 /// Use a [`tokio::io::AsyncRead`] synchronously as a [`std::io::Read`] or
 /// a [`tokio::io::AsyncWrite`] as a [`std::io::Write`].
@@ -11,28 +9,6 @@ pub struct SyncIoBridge<T> {
     rt: tokio::runtime::Handle,
 }
 
-impl<T: AsyncBufRead + Unpin> BufRead for SyncIoBridge<T> {
-    fn fill_buf(&mut self) -> std::io::Result<&[u8]> {
-        let src = &mut self.src;
-        self.rt.block_on(AsyncBufReadExt::fill_buf(src))
-    }
-
-    fn consume(&mut self, amt: usize) {
-        let src = &mut self.src;
-        AsyncBufReadExt::consume(src, amt)
-    }
-
-    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> std::io::Result<usize> {
-        let src = &mut self.src;
-        self.rt
-            .block_on(AsyncBufReadExt::read_until(src, byte, buf))
-    }
-    fn read_line(&mut self, buf: &mut String) -> std::io::Result<usize> {
-        let src = &mut self.src;
-        self.rt.block_on(AsyncBufReadExt::read_line(src, buf))
-    }
-}
-
 impl<T: AsyncRead + Unpin> Read for SyncIoBridge<T> {
     fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
         let src = &mut self.src;

tokio-util/src/sync/cancellation_token.rs

@@ -55,9 +55,6 @@ pub struct CancellationToken {
     inner: Arc<tree_node::TreeNode>,
 }
 
-impl std::panic::UnwindSafe for CancellationToken {}
-impl std::panic::RefUnwindSafe for CancellationToken {}
-
 pin_project! {
     /// A Future that is resolved once the corresponding [`CancellationToken`]
     /// is cancelled.
@@ -69,23 +66,6 @@ pin_project! {
     }
 }
 
-pin_project! {
-    /// A Future that is resolved once the corresponding [`CancellationToken`]
-    /// is cancelled.
-    ///
-    /// This is the counterpart to [`WaitForCancellationFuture`] that takes
-    /// [`CancellationToken`] by value instead of using a reference.
-    #[must_use = "futures do nothing unless polled"]
-    pub struct WaitForCancellationFutureOwned {
-        // Since `future` is the first field, it is dropped before the
-        // cancellation_token field. This ensures that the reference inside the
-        // `Notified` remains valid.
-        #[pin]
-        future: tokio::sync::futures::Notified<'static>,
-        cancellation_token: CancellationToken,
-    }
-}
-
 // ===== impl CancellationToken =====
 
 impl core::fmt::Debug for CancellationToken {
@@ -203,21 +183,6 @@ impl CancellationToken {
         }
     }
 
-    /// Returns a `Future` that gets fulfilled when cancellation is requested.
-    ///
-    /// The future will complete immediately if the token is already cancelled
-    /// when this method is called.
-    ///
-    /// The function takes self by value and returns a future that owns the
-    /// token.
-    ///
-    /// # Cancel safety
-    ///
-    /// This method is cancel safe.
-    pub fn cancelled_owned(self) -> WaitForCancellationFutureOwned {
-        WaitForCancellationFutureOwned::new(self)
-    }
-
     /// Creates a `DropGuard` for this token.
     ///
     /// Returned guard will cancel this token (and all its children) on drop
@@ -257,68 +222,3 @@ impl<'a> Future for WaitForCancellationFuture<'a> {
         }
     }
 }
-
-// ===== impl WaitForCancellationFutureOwned =====
-
-impl core::fmt::Debug for WaitForCancellationFutureOwned {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        f.debug_struct("WaitForCancellationFutureOwned").finish()
-    }
-}
-
-impl WaitForCancellationFutureOwned {
-    fn new(cancellation_token: CancellationToken) -> Self {
-        WaitForCancellationFutureOwned {
-            // cancellation_token holds a heap allocation and is guaranteed to have a
-            // stable deref, thus it would be ok to move the cancellation_token while
-            // the future holds a reference to it.
-            //
-            // # Safety
-            //
-            // cancellation_token is dropped after future due to the field ordering.
-            future: unsafe { Self::new_future(&cancellation_token) },
-            cancellation_token,
-        }
-    }
-
-    /// # Safety
-    /// The returned future must be destroyed before the cancellation token is
-    /// destroyed.
-    unsafe fn new_future(
-        cancellation_token: &CancellationToken,
-    ) -> tokio::sync::futures::Notified<'static> {
-        let inner_ptr = Arc::as_ptr(&cancellation_token.inner);
-        // SAFETY: The `Arc::as_ptr` method guarantees that `inner_ptr` remains
-        // valid until the strong count of the Arc drops to zero, and the caller
-        // guarantees that they will drop the future before that happens.
-        (*inner_ptr).notified()
-    }
-}
-
-impl Future for WaitForCancellationFutureOwned {
-    type Output = ();
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
-        let mut this = self.project();
-
-        loop {
-            if this.cancellation_token.is_cancelled() {
-                return Poll::Ready(());
-            }
-
-            // No wakeups can be lost here because there is always a call to
-            // `is_cancelled` between the creation of the future and the call to
-            // `poll`, and the code that sets the cancelled flag does so before
-            // waking the `Notified`.
-            if this.future.as_mut().poll(cx).is_pending() {
-                return Poll::Pending;
-            }
-
-            // # Safety
-            //
-            // cancellation_token is dropped after future due to the field ordering.
-            this.future
-                .set(unsafe { Self::new_future(this.cancellation_token) });
-        }
-    }
-}

tokio-util/src/sync/mod.rs

@@ -1,9 +1,7 @@
 //! Synchronization primitives
 
 mod cancellation_token;
-pub use cancellation_token::{
-    guard::DropGuard, CancellationToken, WaitForCancellationFuture, WaitForCancellationFutureOwned,
-};
+pub use cancellation_token::{guard::DropGuard, CancellationToken, WaitForCancellationFuture};
 
 mod mpsc;
 pub use mpsc::{PollSendError, PollSender};

tokio-util/src/sync/poll_semaphore.rs

@@ -12,10 +12,7 @@ use super::ReusableBoxFuture;
 /// [`Semaphore`]: tokio::sync::Semaphore
 pub struct PollSemaphore {
     semaphore: Arc<Semaphore>,
-    permit_fut: Option<(
-        u32, // The number of permits requested.
-        ReusableBoxFuture<'static, Result<OwnedSemaphorePermit, AcquireError>>,
-    )>,
+    permit_fut: Option<ReusableBoxFuture<'static, Result<OwnedSemaphorePermit, AcquireError>>>,
 }
 
 impl PollSemaphore {
@@ -56,57 +53,25 @@ impl PollSemaphore {
     /// the `Waker` from the `Context` passed to the most recent call is
     /// scheduled to receive a wakeup.
     pub fn poll_acquire(&mut self, cx: &mut Context<'_>) -> Poll<Option<OwnedSemaphorePermit>> {
-        self.poll_acquire_many(cx, 1)
-    }
-
-    /// Poll to acquire many permits from the semaphore.
-    ///
-    /// This can return the following values:
-    ///
-    ///  - `Poll::Pending` if a permit is not currently available.
-    ///  - `Poll::Ready(Some(permit))` if a permit was acquired.
-    ///  - `Poll::Ready(None)` if the semaphore has been closed.
-    ///
-    /// When this method returns `Poll::Pending`, the current task is scheduled
-    /// to receive a wakeup when the permits become available, or when the
-    /// semaphore is closed. Note that on multiple calls to `poll_acquire`, only
-    /// the `Waker` from the `Context` passed to the most recent call is
-    /// scheduled to receive a wakeup.
-    pub fn poll_acquire_many(
-        &mut self,
-        cx: &mut Context<'_>,
-        permits: u32,
-    ) -> Poll<Option<OwnedSemaphorePermit>> {
         let permit_future = match self.permit_fut.as_mut() {
-            Some((prev_permits, fut)) if *prev_permits == permits => fut,
-            Some((old_permits, fut_box)) => {
-                // We're requesting a different number of permits, so replace the future
-                // and record the new amount.
-                let fut = Arc::clone(&self.semaphore).acquire_many_owned(permits);
-                fut_box.set(fut);
-                *old_permits = permits;
-                fut_box
-            }
+            Some(fut) => fut,
             None => {
                 // avoid allocations completely if we can grab a permit immediately
-                match Arc::clone(&self.semaphore).try_acquire_many_owned(permits) {
+                match Arc::clone(&self.semaphore).try_acquire_owned() {
                     Ok(permit) => return Poll::Ready(Some(permit)),
                     Err(TryAcquireError::Closed) => return Poll::Ready(None),
                     Err(TryAcquireError::NoPermits) => {}
                 }
 
-                let next_fut = Arc::clone(&self.semaphore).acquire_many_owned(permits);
-                &mut self
-                    .permit_fut
-                    .get_or_insert((permits, ReusableBoxFuture::new(next_fut)))
-                    .1
+                let next_fut = Arc::clone(&self.semaphore).acquire_owned();
+                self.permit_fut
+                    .get_or_insert(ReusableBoxFuture::new(next_fut))
             }
         };
 
         let result = ready!(permit_future.poll(cx));
 
-        // Assume we'll request the same amount of permits in a subsequent call.
-        let next_fut = Arc::clone(&self.semaphore).acquire_many_owned(permits);
+        let next_fut = Arc::clone(&self.semaphore).acquire_owned();
         permit_future.set(next_fut);
 
         match result {
@@ -130,7 +95,7 @@ impl PollSemaphore {
 
     /// Adds `n` new permits to the semaphore.
     ///
-    /// The maximum number of permits is [`Semaphore::MAX_PERMITS`], and this function
+    /// The maximum number of permits is `usize::MAX >> 3`, and this function
     /// will panic if the limit is exceeded.
     ///
     /// This is equivalent to the [`Semaphore::add_permits`] method on the
@@ -166,6 +131,6 @@ impl fmt::Debug for PollSemaphore {
 
 impl AsRef<Semaphore> for PollSemaphore {
     fn as_ref(&self) -> &Semaphore {
-        &self.semaphore
+        &*self.semaphore
     }
 }

tokio-util/src/sync/tests/loom_cancellation_token.rs

@@ -24,27 +24,6 @@ fn cancel_token() {
     });
 }
 
-#[test]
-fn cancel_token_owned() {
-    loom::model(|| {
-        let token = CancellationToken::new();
-        let token1 = token.clone();
-
-        let th1 = thread::spawn(move || {
-            block_on(async {
-                token1.cancelled_owned().await;
-            });
-        });
-
-        let th2 = thread::spawn(move || {
-            token.cancel();
-        });
-
-        assert_ok!(th1.join());
-        assert_ok!(th2.join());
-    });
-}
-
 #[test]
 fn cancel_with_child() {
     loom::model(|| {

tokio-util/src/task/join_map.rs

@@ -363,7 +363,10 @@ where
     fn insert(&mut self, key: K, abort: AbortHandle) {
         let hash = self.hash(&key);
         let id = abort.id();
-        let map_key = Key { id, key };
+        let map_key = Key {
+            id: id.clone(),
+            key,
+        };
 
         // Insert the new key into the map of tasks by keys.
         let entry = self

tokio-util/src/time/delay_queue.rs

@@ -275,7 +275,7 @@ impl<T> SlabStorage<T> {
     fn remap_key(&self, key: &Key) -> Option<KeyInternal> {
         let key_map = &self.key_map;
         if self.compact_called {
-            key_map.get(key).copied()
+            key_map.get(&*key).copied()
         } else {
             Some((*key).into())
         }
@@ -740,43 +740,6 @@ impl<T> DelayQueue<T> {
         }
     }
 
-    /// Attempts to remove the item associated with `key` from the queue.
-    ///
-    /// Removes the item associated with `key`, and returns it along with the
-    /// `Instant` at which it would have expired, if it exists.
-    ///
-    /// Returns `None` if `key` is not in the queue.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage
-    ///
-    /// ```rust
-    /// use tokio_util::time::DelayQueue;
-    /// use std::time::Duration;
-    ///
-    /// # #[tokio::main(flavor = "current_thread")]
-    /// # async fn main() {
-    /// let mut delay_queue = DelayQueue::new();
-    /// let key = delay_queue.insert("foo", Duration::from_secs(5));
-    ///
-    /// // The item is in the queue, `try_remove` returns `Some(Expired("foo"))`.
-    /// let item = delay_queue.try_remove(&key);
-    /// assert_eq!(item.unwrap().into_inner(), "foo");
-    ///
-    /// // The item is not in the queue anymore, `try_remove` returns `None`.
-    /// let item = delay_queue.try_remove(&key);
-    /// assert!(item.is_none());
-    /// # }
-    /// ```
-    pub fn try_remove(&mut self, key: &Key) -> Option<Expired<T>> {
-        if self.slab.contains(key) {
-            Some(self.remove(key))
-        } else {
-            None
-        }
-    }
-
     /// Sets the delay of the item associated with `key` to expire at `when`.
     ///
     /// This function is identical to `reset` but takes an `Instant` instead of

tokio-util/tests/context.rs

@@ -21,5 +21,5 @@ fn tokio_context_with_another_runtime() {
 
     // Without the `HandleExt.wrap()` there would be a panic because there is
     // no timer running, since it would be referencing runtime r1.
-    rt1.block_on(rt2.wrap(async move { sleep(Duration::from_millis(2)).await }));
+    let _ = rt1.block_on(rt2.wrap(async move { sleep(Duration::from_millis(2)).await }));
 }

tokio-util/tests/framed_write.rs

@@ -109,12 +109,12 @@ fn write_hits_backpressure() {
     const ITER: usize = 2 * 1024;
 
     let mut mock = mock! {
-        // Block the `ITER*2`th write
+        // Block the `ITER`th write
         Err(io::Error::new(io::ErrorKind::WouldBlock, "not ready")),
         Ok(b"".to_vec()),
     };
 
-    for i in 0..=ITER * 2 {
+    for i in 0..=ITER {
         let mut b = BytesMut::with_capacity(4);
         b.put_u32(i as u32);
 
@@ -133,15 +133,14 @@ fn write_hits_backpressure() {
         // Push a new chunk
         mock.calls.push_back(Ok(b[..].to_vec()));
     }
-    // 1 'wouldblock', 8 * 2KB buffers, 1 b-byte buffer
-    assert_eq!(mock.calls.len(), 10);
+    // 1 'wouldblock', 4 * 2KB buffers, 1 b-byte buffer
+    assert_eq!(mock.calls.len(), 6);
 
     let mut task = task::spawn(());
     let mut framed = FramedWrite::new(mock, U32Encoder);
-    framed.set_backpressure_boundary(ITER * 8);
     task.enter(|cx, _| {
-        // Send 16KB. This fills up FramedWrite buffer
-        for i in 0..ITER * 2 {
+        // Send 8KB. This fills up FramedWrite2 buffer
+        for i in 0..ITER {
             assert!(assert_ready!(pin!(framed).poll_ready(cx)).is_ok());
             assert!(pin!(framed).start_send(i as u32).is_ok());
         }
@@ -151,11 +150,11 @@ fn write_hits_backpressure() {
         assert!(pin!(framed).poll_ready(cx).is_pending());
 
         // We poll again, forcing another flush, which this time succeeds
-        // The whole 16KB buffer is flushed
+        // The whole 8KB buffer is flushed
         assert!(assert_ready!(pin!(framed).poll_ready(cx)).is_ok());
 
         // Send more data. This matches the final message expected by the mock
-        assert!(pin!(framed).start_send((ITER * 2) as u32).is_ok());
+        assert!(pin!(framed).start_send(ITER as u32).is_ok());
 
         // Flush the rest of the buffer
         assert!(assert_ready!(pin!(framed).poll_flush(cx)).is_ok());

tokio-util/tests/io_inspect.rs

@@ -1,194 +0,0 @@
-use futures::future::poll_fn;
-use std::{
-    io::IoSlice,
-    pin::Pin,
-    task::{Context, Poll},
-};
-use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, ReadBuf};
-use tokio_util::io::{InspectReader, InspectWriter};
-
-/// An AsyncRead implementation that works byte-by-byte, to catch out callers
-/// who don't allow for `buf` being part-filled before the call
-struct SmallReader {
-    contents: Vec<u8>,
-}
-
-impl Unpin for SmallReader {}
-
-impl AsyncRead for SmallReader {
-    fn poll_read(
-        mut self: Pin<&mut Self>,
-        _cx: &mut Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<std::io::Result<()>> {
-        if let Some(byte) = self.contents.pop() {
-            buf.put_slice(&[byte])
-        }
-        Poll::Ready(Ok(()))
-    }
-}
-
-#[tokio::test]
-async fn read_tee() {
-    let contents = b"This could be really long, you know".to_vec();
-    let reader = SmallReader {
-        contents: contents.clone(),
-    };
-    let mut altout: Vec<u8> = Vec::new();
-    let mut teeout = Vec::new();
-    {
-        let mut tee = InspectReader::new(reader, |bytes| altout.extend(bytes));
-        tee.read_to_end(&mut teeout).await.unwrap();
-    }
-    assert_eq!(teeout, altout);
-    assert_eq!(altout.len(), contents.len());
-}
-
-/// An AsyncWrite implementation that works byte-by-byte for poll_write, and
-/// that reads the whole of the first buffer plus one byte from the second in
-/// poll_write_vectored.
-///
-/// This is designed to catch bugs in handling partially written buffers
-#[derive(Debug)]
-struct SmallWriter {
-    contents: Vec<u8>,
-}
-
-impl Unpin for SmallWriter {}
-
-impl AsyncWrite for SmallWriter {
-    fn poll_write(
-        mut self: Pin<&mut Self>,
-        _cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<Result<usize, std::io::Error>> {
-        // Just write one byte at a time
-        if buf.is_empty() {
-            return Poll::Ready(Ok(0));
-        }
-        self.contents.push(buf[0]);
-        Poll::Ready(Ok(1))
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), std::io::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn poll_shutdown(
-        self: Pin<&mut Self>,
-        _cx: &mut Context<'_>,
-    ) -> Poll<Result<(), std::io::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn poll_write_vectored(
-        mut self: Pin<&mut Self>,
-        _cx: &mut Context<'_>,
-        bufs: &[IoSlice<'_>],
-    ) -> Poll<Result<usize, std::io::Error>> {
-        // Write all of the first buffer, then one byte from the second buffer
-        // This should trip up anything that doesn't correctly handle multiple
-        // buffers.
-        if bufs.is_empty() {
-            return Poll::Ready(Ok(0));
-        }
-        let mut written_len = bufs[0].len();
-        self.contents.extend_from_slice(&bufs[0]);
-
-        if bufs.len() > 1 {
-            let buf = bufs[1];
-            if !buf.is_empty() {
-                written_len += 1;
-                self.contents.push(buf[0]);
-            }
-        }
-        Poll::Ready(Ok(written_len))
-    }
-
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-}
-
-#[tokio::test]
-async fn write_tee() {
-    let mut altout: Vec<u8> = Vec::new();
-    let mut writeout = SmallWriter {
-        contents: Vec::new(),
-    };
-    {
-        let mut tee = InspectWriter::new(&mut writeout, |bytes| altout.extend(bytes));
-        tee.write_all(b"A testing string, very testing")
-            .await
-            .unwrap();
-    }
-    assert_eq!(altout, writeout.contents);
-}
-
-// This is inefficient, but works well enough for test use.
-// If you want something similar for real code, you'll want to avoid all the
-// fun of manipulating `bufs` - ideally, by the time you read this,
-// IoSlice::advance_slices will be stable, and you can use that.
-async fn write_all_vectored<W: AsyncWrite + Unpin>(
-    mut writer: W,
-    mut bufs: Vec<Vec<u8>>,
-) -> Result<usize, std::io::Error> {
-    let mut res = 0;
-    while !bufs.is_empty() {
-        let mut written = poll_fn(|cx| {
-            let bufs: Vec<IoSlice> = bufs.iter().map(|v| IoSlice::new(v)).collect();
-            Pin::new(&mut writer).poll_write_vectored(cx, &bufs)
-        })
-        .await?;
-        res += written;
-        while written > 0 {
-            let buf_len = bufs[0].len();
-            if buf_len <= written {
-                bufs.remove(0);
-                written -= buf_len;
-            } else {
-                let buf = &mut bufs[0];
-                let drain_len = written.min(buf.len());
-                buf.drain(..drain_len);
-                written -= drain_len;
-            }
-        }
-    }
-    Ok(res)
-}
-
-#[tokio::test]
-async fn write_tee_vectored() {
-    let mut altout: Vec<u8> = Vec::new();
-    let mut writeout = SmallWriter {
-        contents: Vec::new(),
-    };
-    let original = b"A very long string split up";
-    let bufs: Vec<Vec<u8>> = original
-        .split(|b| b.is_ascii_whitespace())
-        .map(Vec::from)
-        .collect();
-    assert!(bufs.len() > 1);
-    let expected: Vec<u8> = {
-        let mut out = Vec::new();
-        for item in &bufs {
-            out.extend_from_slice(item)
-        }
-        out
-    };
-    {
-        let mut bufcount = 0;
-        let tee = InspectWriter::new(&mut writeout, |bytes| {
-            bufcount += 1;
-            altout.extend(bytes)
-        });
-
-        assert!(tee.is_write_vectored());
-
-        write_all_vectored(tee, bufs.clone()).await.unwrap();
-
-        assert!(bufcount >= bufs.len());
-    }
-    assert_eq!(altout, writeout.contents);
-    assert_eq!(writeout.contents, expected);
-}

tokio-util/tests/io_sink_writer.rs

@@ -1,72 +0,0 @@
-#![warn(rust_2018_idioms)]
-
-use bytes::Bytes;
-use futures_util::SinkExt;
-use std::io::{self, Error, ErrorKind};
-use tokio::io::AsyncWriteExt;
-use tokio_util::codec::{Encoder, FramedWrite};
-use tokio_util::io::{CopyToBytes, SinkWriter};
-use tokio_util::sync::PollSender;
-
-#[tokio::test]
-async fn test_copied_sink_writer() -> Result<(), Error> {
-    // Construct a channel pair to send data across and wrap a pollable sink.
-    // Note that the sink must mimic a writable object, e.g. have `std::io::Error`
-    // as its error type.
-    // As `PollSender` requires an owned copy of the buffer, we wrap it additionally
-    // with a `CopyToBytes` helper.
-    let (tx, mut rx) = tokio::sync::mpsc::channel::<Bytes>(1);
-    let mut writer = SinkWriter::new(CopyToBytes::new(
-        PollSender::new(tx).sink_map_err(|_| io::Error::from(ErrorKind::BrokenPipe)),
-    ));
-
-    // Write data to our interface...
-    let data: [u8; 4] = [1, 2, 3, 4];
-    let _ = writer.write(&data).await;
-
-    // ... and receive it.
-    assert_eq!(data.to_vec(), rx.recv().await.unwrap().to_vec());
-
-    Ok(())
-}
-
-/// A trivial encoder.
-struct SliceEncoder;
-
-impl SliceEncoder {
-    fn new() -> Self {
-        Self {}
-    }
-}
-
-impl<'a> Encoder<&'a [u8]> for SliceEncoder {
-    type Error = Error;
-
-    fn encode(&mut self, item: &'a [u8], dst: &mut bytes::BytesMut) -> Result<(), Self::Error> {
-        // This is where we'd write packet headers, lengths, etc. in a real encoder.
-        // For simplicity and demonstration purposes, we just pack a copy of
-        // the slice at the end of a buffer.
-        dst.extend_from_slice(item);
-        Ok(())
-    }
-}
-
-#[tokio::test]
-async fn test_direct_sink_writer() -> Result<(), Error> {
-    // We define a framed writer which accepts byte slices
-    // and 'reverse' this construction immediately.
-    let framed_byte_lc = FramedWrite::new(Vec::new(), SliceEncoder::new());
-    let mut writer = SinkWriter::new(framed_byte_lc);
-
-    // Write multiple slices to the sink...
-    let _ = writer.write(&[1, 2, 3]).await;
-    let _ = writer.write(&[4, 5, 6]).await;
-
-    // ... and compare it with the buffer.
-    assert_eq!(
-        writer.into_inner().write_buffer().to_vec().as_slice(),
-        &[1, 2, 3, 4, 5, 6]
-    );
-
-    Ok(())
-}

tokio-util/tests/poll_semaphore.rs

@@ -13,14 +13,6 @@ fn semaphore_poll(
     tokio_test::task::spawn(fut)
 }
 
-fn semaphore_poll_many(
-    sem: &mut PollSemaphore,
-    permits: u32,
-) -> tokio_test::task::Spawn<impl Future<Output = SemRet> + '_> {
-    let fut = futures::future::poll_fn(move |cx| sem.poll_acquire_many(cx, permits));
-    tokio_test::task::spawn(fut)
-}
-
 #[tokio::test]
 async fn it_works() {
     let sem = Arc::new(Semaphore::new(1));
@@ -42,43 +34,3 @@ async fn it_works() {
     assert!(semaphore_poll(&mut poll_sem).await.is_none());
     assert!(semaphore_poll(&mut poll_sem).await.is_none());
 }
-
-#[tokio::test]
-async fn can_acquire_many_permits() {
-    let sem = Arc::new(Semaphore::new(4));
-    let mut poll_sem = PollSemaphore::new(sem.clone());
-
-    let permit1 = semaphore_poll(&mut poll_sem).poll();
-    assert!(matches!(permit1, Poll::Ready(Some(_))));
-
-    let permit2 = semaphore_poll_many(&mut poll_sem, 2).poll();
-    assert!(matches!(permit2, Poll::Ready(Some(_))));
-
-    assert_eq!(sem.available_permits(), 1);
-
-    drop(permit2);
-
-    let mut permit4 = semaphore_poll_many(&mut poll_sem, 4);
-    assert!(permit4.poll().is_pending());
-
-    drop(permit1);
-
-    let permit4 = permit4.poll();
-    assert!(matches!(permit4, Poll::Ready(Some(_))));
-    assert_eq!(sem.available_permits(), 0);
-}
-
-#[tokio::test]
-async fn can_poll_different_amounts_of_permits() {
-    let sem = Arc::new(Semaphore::new(4));
-    let mut poll_sem = PollSemaphore::new(sem.clone());
-    assert!(semaphore_poll_many(&mut poll_sem, 5).poll().is_pending());
-    assert!(semaphore_poll_many(&mut poll_sem, 4).poll().is_ready());
-
-    let permit = sem.acquire_many(4).await.unwrap();
-    assert!(semaphore_poll_many(&mut poll_sem, 5).poll().is_pending());
-    assert!(semaphore_poll_many(&mut poll_sem, 4).poll().is_pending());
-    drop(permit);
-    assert!(semaphore_poll_many(&mut poll_sem, 5).poll().is_pending());
-    assert!(semaphore_poll_many(&mut poll_sem, 4).poll().is_ready());
-}

tokio-util/tests/spawn_pinned.rs

@@ -82,8 +82,8 @@ async fn task_panic_propagates() {
     assert!(result.is_err());
     let error = result.unwrap_err();
     assert!(error.is_panic());
-    let panic_str = error.into_panic().downcast::<&'static str>().unwrap();
-    assert_eq!(*panic_str, "Test panic");
+    let panic_str: &str = *error.into_panic().downcast().unwrap();
+    assert_eq!(panic_str, "Test panic");
 
     // Trying again with a "safe" task still works
     let join_handle = pool.spawn_pinned(|| async { "test" });
@@ -108,8 +108,8 @@ async fn callback_panic_does_not_kill_worker() {
     assert!(result.is_err());
     let error = result.unwrap_err();
     assert!(error.is_panic());
-    let panic_str = error.into_panic().downcast::<&'static str>().unwrap();
-    assert_eq!(*panic_str, "Test panic");
+    let panic_str: &str = *error.into_panic().downcast().unwrap();
+    assert_eq!(panic_str, "Test panic");
 
     // Trying again with a "safe" callback works
     let join_handle = pool.spawn_pinned(|| async { "test" });

tokio-util/tests/sync_cancellation_token.rs

@@ -39,56 +39,6 @@ fn cancel_token() {
     );
 }
 
-#[test]
-fn cancel_token_owned() {
-    let (waker, wake_counter) = new_count_waker();
-    let token = CancellationToken::new();
-    assert!(!token.is_cancelled());
-
-    let wait_fut = token.clone().cancelled_owned();
-    pin!(wait_fut);
-
-    assert_eq!(
-        Poll::Pending,
-        wait_fut.as_mut().poll(&mut Context::from_waker(&waker))
-    );
-    assert_eq!(wake_counter, 0);
-
-    let wait_fut_2 = token.clone().cancelled_owned();
-    pin!(wait_fut_2);
-
-    token.cancel();
-    assert_eq!(wake_counter, 1);
-    assert!(token.is_cancelled());
-
-    assert_eq!(
-        Poll::Ready(()),
-        wait_fut.as_mut().poll(&mut Context::from_waker(&waker))
-    );
-    assert_eq!(
-        Poll::Ready(()),
-        wait_fut_2.as_mut().poll(&mut Context::from_waker(&waker))
-    );
-}
-
-#[test]
-fn cancel_token_owned_drop_test() {
-    let (waker, wake_counter) = new_count_waker();
-    let token = CancellationToken::new();
-
-    let future = token.cancelled_owned();
-    pin!(future);
-
-    assert_eq!(
-        Poll::Pending,
-        future.as_mut().poll(&mut Context::from_waker(&waker))
-    );
-    assert_eq!(wake_counter, 0);
-
-    // let future be dropped while pinned and under pending state to
-    // find potential memory related bugs.
-}
-
 #[test]
 fn cancel_child_token_through_parent() {
     let (waker, wake_counter) = new_count_waker();
@@ -256,6 +206,9 @@ fn create_child_token_after_parent_was_cancelled() {
                 parent_fut.as_mut().poll(&mut Context::from_waker(&waker))
             );
             assert_eq!(wake_counter, 0);
+
+            drop(child_fut);
+            drop(parent_fut);
         }
 
         if drop_child_first {

tokio-util/tests/time_delay_queue.rs

@@ -1,4 +1,4 @@
-#![allow(clippy::disallowed_names)]
+#![allow(clippy::blacklisted_name)]
 #![warn(rust_2018_idioms)]
 #![cfg(feature = "full")]
 

tokio/CHANGELOG.md

@@ -1,367 +1,3 @@
-# 1.25.0 (January 28, 2023)
-
-### Fixed
-
-- rt: fix runtime metrics reporting ([#5330])
-
-### Added
-
-- sync: add `broadcast::Sender::len` ([#5343])
-
-### Changed
-
-- fs: increase maximum read buffer size to 2MiB ([#5397])
-
-[#5330]: https://github.com/tokio-rs/tokio/pull/5330
-[#5343]: https://github.com/tokio-rs/tokio/pull/5343
-[#5397]: https://github.com/tokio-rs/tokio/pull/5397
-
-# 1.24.2 (January 17, 2023)
-
-Forward ports 1.18.5 changes.
-
-### Fixed
-
-- io: fix unsoundness in `ReadHalf::unsplit` ([#5375])
-
-[#5375]: https://github.com/tokio-rs/tokio/pull/5375
-
-# 1.24.1 (January 6, 2022)
-
-This release fixes a compilation failure on targets without `AtomicU64` when using rustc older than 1.63. ([#5356])
-
-[#5356]: https://github.com/tokio-rs/tokio/pull/5356
-
-# 1.24.0 (January 5, 2022)
-
-### Fixed
- - rt: improve native `AtomicU64` support detection ([#5284])
-
-### Added
- - rt: add configuration option for max number of I/O events polled from the OS
-   per tick ([#5186])
- - rt: add an environment variable for configuring the default number of worker
-   threads per runtime instance ([#4250])
-
-### Changed
- - sync: reduce MPSC channel stack usage ([#5294])
- - io: reduce lock contention in I/O operations  ([#5300])
- - fs: speed up `read_dir()` by chunking operations ([#5309])
- - rt: use internal `ThreadId` implementation ([#5329])
- - test: don't auto-advance time when a `spawn_blocking` task is running ([#5115])
-
-[#5186]: https://github.com/tokio-rs/tokio/pull/5186
-[#5294]: https://github.com/tokio-rs/tokio/pull/5294
-[#5284]: https://github.com/tokio-rs/tokio/pull/5284
-[#4250]: https://github.com/tokio-rs/tokio/pull/4250
-[#5300]: https://github.com/tokio-rs/tokio/pull/5300
-[#5329]: https://github.com/tokio-rs/tokio/pull/5329
-[#5115]: https://github.com/tokio-rs/tokio/pull/5115
-[#5309]: https://github.com/tokio-rs/tokio/pull/5309
-
-# 1.23.1 (January 4, 2022)
-
-This release forward ports changes from 1.18.4.
-
-### Fixed
-
-- net: fix Windows named pipe server builder to maintain option when toggling
-  pipe mode ([#5336]).
-
-[#5336]: https://github.com/tokio-rs/tokio/pull/5336
-
-# 1.23.0 (December 5, 2022)
-
-### Fixed
-
- - net: fix Windows named pipe connect ([#5208])
- - io: support vectored writes for `ChildStdin` ([#5216])
- - io: fix `async fn ready()` false positive for OS-specific events ([#5231])
-
- ### Changed
- - runtime: `yield_now` defers task until after driver poll ([#5223])
- - runtime: reduce amount of codegen needed per spawned task ([#5213])
- - windows: replace `winapi` dependency with `windows-sys` ([#5204])
-
- [#5208]: https://github.com/tokio-rs/tokio/pull/5208
- [#5216]: https://github.com/tokio-rs/tokio/pull/5216
- [#5213]: https://github.com/tokio-rs/tokio/pull/5213
- [#5204]: https://github.com/tokio-rs/tokio/pull/5204
- [#5223]: https://github.com/tokio-rs/tokio/pull/5223
- [#5231]: https://github.com/tokio-rs/tokio/pull/5231
-
-# 1.22.0 (November 17, 2022)
-
-### Added
- - runtime: add `Handle::runtime_flavor` ([#5138])
- - sync: add `Mutex::blocking_lock_owned` ([#5130])
- - sync: add `Semaphore::MAX_PERMITS` ([#5144])
- - sync: add `merge()` to semaphore permits ([#4948])
- - sync: add `mpsc::WeakUnboundedSender` ([#5189])
-
-### Added (unstable)
-
- - process: add `Command::process_group` ([#5114])
- - runtime: export metrics about the blocking thread pool ([#5161])
- - task: add `task::id()` and `task::try_id()` ([#5171])
-
-### Fixed
- - macros: don't take ownership of futures in macros ([#5087])
- - runtime: fix Stacked Borrows violation in `LocalOwnedTasks` ([#5099])
- - runtime: mitigate ABA with 32-bit queue indices when possible ([#5042])
- - task: wake local tasks to the local queue when woken by the same thread ([#5095])
- - time: panic in release mode when `mark_pending` called illegally ([#5093])
- - runtime: fix typo in expect message ([#5169])
- - runtime: fix `unsync_load` on atomic types ([#5175])
- - task: elaborate safety comments in task deallocation ([#5172])
- - runtime: fix `LocalSet` drop in thread local ([#5179])
- - net: remove libc type leakage in a public API ([#5191])
- - runtime: update the alignment of `CachePadded` ([#5106])
-
-### Changed
- - io: make `tokio::io::copy` continue filling the buffer when writer stalls ([#5066])
- - runtime: remove `coop::budget` from `LocalSet::run_until` ([#5155])
- - sync: make `Notify` panic safe ([#5154])
-
-### Documented
- - io: fix doc for `write_i8` to use signed integers ([#5040])
- - net: fix doc typos for TCP and UDP `set_tos` methods ([#5073])
- - net: fix function name in `UdpSocket::recv` documentation ([#5150])
- - sync: typo in `TryLockError` for `RwLock::try_write` ([#5160])
- - task: document that spawned tasks execute immediately ([#5117])
- - time: document return type of `timeout` ([#5118])
- - time: document that `timeout` checks only before poll ([#5126])
- - sync: specify return type of `oneshot::Receiver` in docs ([#5198])
-
-### Internal changes
- - runtime: use const `Mutex::new` for globals ([#5061])
- - runtime: remove `Option` around `mio::Events` in io driver ([#5078])
- - runtime: remove a conditional compilation clause ([#5104])
- - runtime: remove a reference to internal time handle ([#5107])
- - runtime: misc time driver cleanup ([#5120])
- - runtime: move signal driver to runtime module ([#5121])
- - runtime: signal driver now uses I/O driver directly ([#5125])
- - runtime: start decoupling I/O driver and I/O handle ([#5127])
- - runtime: switch `io::handle` refs with scheduler:Handle ([#5128])
- - runtime: remove Arc from I/O driver ([#5134])
- - runtime: use signal driver handle via `scheduler::Handle` ([#5135])
- - runtime: move internal clock fns out of context ([#5139])
- - runtime: remove `runtime::context` module ([#5140])
- - runtime: keep driver cfgs in `driver.rs` ([#5141])
- - runtime: add `runtime::context` to unify thread-locals ([#5143])
- - runtime: rename some confusing internal variables/fns ([#5151])
- - runtime: move `coop` mod into `runtime` ([#5152])
- - runtime: move budget state to context thread-local ([#5157])
- - runtime: move park logic into runtime module ([#5158])
- - runtime: move `Runtime` into its own file ([#5159])
- - runtime: unify entering a runtime with `Handle::enter` ([#5163])
- - runtime: remove handle reference from each scheduler ([#5166])
- - runtime: move `enter` into `context` ([#5167])
- - runtime: combine context and entered thread-locals ([#5168])
- - runtime: fix accidental unsetting of current handle ([#5178])
- - runtime: move `CoreStage` methods to `Core` ([#5182])
- - sync: name mpsc semaphore types ([#5146])
-
-[#4948]: https://github.com/tokio-rs/tokio/pull/4948
-[#5040]: https://github.com/tokio-rs/tokio/pull/5040
-[#5042]: https://github.com/tokio-rs/tokio/pull/5042
-[#5061]: https://github.com/tokio-rs/tokio/pull/5061
-[#5066]: https://github.com/tokio-rs/tokio/pull/5066
-[#5073]: https://github.com/tokio-rs/tokio/pull/5073
-[#5078]: https://github.com/tokio-rs/tokio/pull/5078
-[#5087]: https://github.com/tokio-rs/tokio/pull/5087
-[#5093]: https://github.com/tokio-rs/tokio/pull/5093
-[#5095]: https://github.com/tokio-rs/tokio/pull/5095
-[#5099]: https://github.com/tokio-rs/tokio/pull/5099
-[#5104]: https://github.com/tokio-rs/tokio/pull/5104
-[#5106]: https://github.com/tokio-rs/tokio/pull/5106
-[#5107]: https://github.com/tokio-rs/tokio/pull/5107
-[#5114]: https://github.com/tokio-rs/tokio/pull/5114
-[#5117]: https://github.com/tokio-rs/tokio/pull/5117
-[#5118]: https://github.com/tokio-rs/tokio/pull/5118
-[#5120]: https://github.com/tokio-rs/tokio/pull/5120
-[#5121]: https://github.com/tokio-rs/tokio/pull/5121
-[#5125]: https://github.com/tokio-rs/tokio/pull/5125
-[#5126]: https://github.com/tokio-rs/tokio/pull/5126
-[#5127]: https://github.com/tokio-rs/tokio/pull/5127
-[#5128]: https://github.com/tokio-rs/tokio/pull/5128
-[#5130]: https://github.com/tokio-rs/tokio/pull/5130
-[#5134]: https://github.com/tokio-rs/tokio/pull/5134
-[#5135]: https://github.com/tokio-rs/tokio/pull/5135
-[#5138]: https://github.com/tokio-rs/tokio/pull/5138
-[#5138]: https://github.com/tokio-rs/tokio/pull/5138
-[#5139]: https://github.com/tokio-rs/tokio/pull/5139
-[#5140]: https://github.com/tokio-rs/tokio/pull/5140
-[#5141]: https://github.com/tokio-rs/tokio/pull/5141
-[#5143]: https://github.com/tokio-rs/tokio/pull/5143
-[#5144]: https://github.com/tokio-rs/tokio/pull/5144
-[#5144]: https://github.com/tokio-rs/tokio/pull/5144
-[#5146]: https://github.com/tokio-rs/tokio/pull/5146
-[#5150]: https://github.com/tokio-rs/tokio/pull/5150
-[#5151]: https://github.com/tokio-rs/tokio/pull/5151
-[#5152]: https://github.com/tokio-rs/tokio/pull/5152
-[#5154]: https://github.com/tokio-rs/tokio/pull/5154
-[#5155]: https://github.com/tokio-rs/tokio/pull/5155
-[#5157]: https://github.com/tokio-rs/tokio/pull/5157
-[#5158]: https://github.com/tokio-rs/tokio/pull/5158
-[#5159]: https://github.com/tokio-rs/tokio/pull/5159
-[#5160]: https://github.com/tokio-rs/tokio/pull/5160
-[#5161]: https://github.com/tokio-rs/tokio/pull/5161
-[#5163]: https://github.com/tokio-rs/tokio/pull/5163
-[#5166]: https://github.com/tokio-rs/tokio/pull/5166
-[#5167]: https://github.com/tokio-rs/tokio/pull/5167
-[#5168]: https://github.com/tokio-rs/tokio/pull/5168
-[#5169]: https://github.com/tokio-rs/tokio/pull/5169
-[#5171]: https://github.com/tokio-rs/tokio/pull/5171
-[#5172]: https://github.com/tokio-rs/tokio/pull/5172
-[#5175]: https://github.com/tokio-rs/tokio/pull/5175
-[#5178]: https://github.com/tokio-rs/tokio/pull/5178
-[#5179]: https://github.com/tokio-rs/tokio/pull/5179
-[#5182]: https://github.com/tokio-rs/tokio/pull/5182
-[#5189]: https://github.com/tokio-rs/tokio/pull/5189
-[#5191]: https://github.com/tokio-rs/tokio/pull/5191
-[#5198]: https://github.com/tokio-rs/tokio/pull/5198
-
-# 1.21.2 (September 27, 2022)
-
-This release removes the dependency on the `once_cell` crate to restore the MSRV
-of 1.21.x, which is the latest minor version at the time of release. ([#5048])
-
-[#5048]: https://github.com/tokio-rs/tokio/pull/5048
-
-# 1.21.1 (September 13, 2022)
-
-### Fixed
-
-- net: fix dependency resolution for socket2 ([#5000])
-- task: ignore failure to set TLS in `LocalSet` Drop ([#4976])
-
-[#4976]: https://github.com/tokio-rs/tokio/pull/4976
-[#5000]: https://github.com/tokio-rs/tokio/pull/5000
-
-# 1.21.0 (September 2, 2022)
-
-This release is the first release of Tokio to intentionally support WASM. The
-`sync,macros,io-util,rt,time` features are stabilized on WASM. Additionally the
-wasm32-wasi target is given unstable support for the `net` feature.
-
-### Added
-
-- net: add `device` and `bind_device` methods to TCP/UDP sockets ([#4882])
-- net: add `tos` and `set_tos` methods to TCP and UDP sockets ([#4877])
-- net: add security flags to named pipe `ServerOptions` ([#4845])
-- signal: add more windows signal handlers ([#4924])
-- sync: add `mpsc::Sender::max_capacity` method ([#4904])
-- sync: implement Weak version of `mpsc::Sender` ([#4595])
-- task: add `LocalSet::enter` ([#4765])
-- task: stabilize `JoinSet` and `AbortHandle` ([#4920])
-- tokio: add `track_caller` to public APIs ([#4805], [#4848], [#4852])
-- wasm: initial support for `wasm32-wasi` target ([#4716])
-
-### Fixed
-
-- miri: improve miri compatibility by avoiding temporary references in `linked_list::Link` impls ([#4841])
-- signal: don't register write interest on signal pipe ([#4898])
-- sync: add `#[must_use]` to lock guards ([#4886])
-- sync: fix hang when calling `recv` on closed and reopened broadcast channel ([#4867])
-- task: propagate attributes on task-locals ([#4837])
-
-### Changed
-
-- fs: change panic to error in `File::start_seek` ([#4897])
-- io: reduce syscalls in `poll_read` ([#4840])
-- process: use blocking threadpool for child stdio I/O ([#4824])
-- signal: make `SignalKind` methods const ([#4956])
-
-### Internal changes
-
-- rt: extract `basic_scheduler::Config` ([#4935])
-- rt: move I/O driver into `runtime` module ([#4942])
-- rt: rename internal scheduler types ([#4945])
-
-### Documented
-
-- chore: fix typos and grammar ([#4858], [#4894], [#4928])
-- io: fix typo in `AsyncSeekExt::rewind` docs ([#4893])
-- net: add documentation to `try_read()` for zero-length buffers ([#4937])
-- runtime: remove incorrect panic section for `Builder::worker_threads` ([#4849])
-- sync: doc of `watch::Sender::send` improved ([#4959])
-- task: add cancel safety docs to `JoinHandle` ([#4901])
-- task: expand on cancellation of `spawn_blocking` ([#4811])
-- time: clarify that the first tick of `Interval::tick` happens immediately ([#4951])
-
-### Unstable
-
-- rt: add unstable option to disable the LIFO slot ([#4936])
-- task: fix incorrect signature in `Builder::spawn_on` ([#4953])
-- task: make `task::Builder::spawn*` methods fallible ([#4823])
-
-[#4595]: https://github.com/tokio-rs/tokio/pull/4595
-[#4716]: https://github.com/tokio-rs/tokio/pull/4716
-[#4765]: https://github.com/tokio-rs/tokio/pull/4765
-[#4805]: https://github.com/tokio-rs/tokio/pull/4805
-[#4811]: https://github.com/tokio-rs/tokio/pull/4811
-[#4823]: https://github.com/tokio-rs/tokio/pull/4823
-[#4824]: https://github.com/tokio-rs/tokio/pull/4824
-[#4837]: https://github.com/tokio-rs/tokio/pull/4837
-[#4840]: https://github.com/tokio-rs/tokio/pull/4840
-[#4841]: https://github.com/tokio-rs/tokio/pull/4841
-[#4845]: https://github.com/tokio-rs/tokio/pull/4845
-[#4848]: https://github.com/tokio-rs/tokio/pull/4848
-[#4849]: https://github.com/tokio-rs/tokio/pull/4849
-[#4852]: https://github.com/tokio-rs/tokio/pull/4852
-[#4858]: https://github.com/tokio-rs/tokio/pull/4858
-[#4867]: https://github.com/tokio-rs/tokio/pull/4867
-[#4877]: https://github.com/tokio-rs/tokio/pull/4877
-[#4882]: https://github.com/tokio-rs/tokio/pull/4882
-[#4886]: https://github.com/tokio-rs/tokio/pull/4886
-[#4893]: https://github.com/tokio-rs/tokio/pull/4893
-[#4894]: https://github.com/tokio-rs/tokio/pull/4894
-[#4897]: https://github.com/tokio-rs/tokio/pull/4897
-[#4898]: https://github.com/tokio-rs/tokio/pull/4898
-[#4901]: https://github.com/tokio-rs/tokio/pull/4901
-[#4904]: https://github.com/tokio-rs/tokio/pull/4904
-[#4920]: https://github.com/tokio-rs/tokio/pull/4920
-[#4924]: https://github.com/tokio-rs/tokio/pull/4924
-[#4928]: https://github.com/tokio-rs/tokio/pull/4928
-[#4935]: https://github.com/tokio-rs/tokio/pull/4935
-[#4936]: https://github.com/tokio-rs/tokio/pull/4936
-[#4937]: https://github.com/tokio-rs/tokio/pull/4937
-[#4942]: https://github.com/tokio-rs/tokio/pull/4942
-[#4945]: https://github.com/tokio-rs/tokio/pull/4945
-[#4951]: https://github.com/tokio-rs/tokio/pull/4951
-[#4953]: https://github.com/tokio-rs/tokio/pull/4953
-[#4956]: https://github.com/tokio-rs/tokio/pull/4956
-[#4959]: https://github.com/tokio-rs/tokio/pull/4959
-
-# 1.20.4 (January 17, 2023)
-
-Forward ports 1.18.5 changes.
-
-### Fixed
-
-- io: fix unsoundness in `ReadHalf::unsplit` ([#5375])
-
-[#5375]: https://github.com/tokio-rs/tokio/pull/5375
-
-# 1.20.3 (January 3, 2022)
-
-This release forward ports changes from 1.18.4.
-
-### Fixed
-
-- net: fix Windows named pipe server builder to maintain option when toggling
-  pipe mode ([#5336]).
-
-[#5336]: https://github.com/tokio-rs/tokio/pull/5336
-
-# 1.20.2 (September 27, 2022)
-
-This release removes the dependency on the `once_cell` crate to restore the MSRV
-of the 1.20.x LTS release. ([#5048])
-
-[#5048]: https://github.com/tokio-rs/tokio/pull/5048
-
 # 1.20.1 (July 25, 2022)
 
 ### Fixed
@@ -480,30 +116,6 @@ This release fixes a bug in `Notified::enable`. ([#4747])
 [#4729]: https://github.com/tokio-rs/tokio/pull/4729
 [#4739]: https://github.com/tokio-rs/tokio/pull/4739
 
-# 1.18.5 (January 17, 2023)
-
-### Fixed
-
-- io: fix unsoundness in `ReadHalf::unsplit` ([#5375])
-
-[#5375]: https://github.com/tokio-rs/tokio/pull/5375
-
-# 1.18.4 (January 3, 2022)
-
-### Fixed
-
-- net: fix Windows named pipe server builder to maintain option when toggling
-  pipe mode ([#5336]).
-
-[#5336]: https://github.com/tokio-rs/tokio/pull/5336
-
-# 1.18.3 (September 27, 2022)
-
-This release removes the dependency on the `once_cell` crate to restore the MSRV
-of the 1.18.x LTS release. ([#5048])
-
-[#5048]: https://github.com/tokio-rs/tokio/pull/5048
-
 # 1.18.2 (May 5, 2022)
 
 Add missing features for the `winapi` dependency. ([#4663])
@@ -624,7 +236,7 @@ performance improvements.
 - time: use bit manipulation instead of modulo to improve performance ([#4480])
 - net: use `std::future::Ready` instead of our own `Ready` future ([#4271])
 - replace deprecated `atomic::spin_loop_hint` with `hint::spin_loop` ([#4491])
-- fix miri failures in intrusive linked lists ([#4397])
+- fix miri failures in intrusive linked lists ([#4397]) 
 
 ### Documented
 

tokio/Cargo.toml

@@ -5,8 +5,8 @@ name = "tokio"
 # - Update doc url
 #   - README.md
 # - Update CHANGELOG.md.
-# - Create "v1.x.y" git tag.
-version = "1.25.0"
+# - Create "v1.0.x" git tag.
+version = "1.20.1"
 edition = "2018"
 rust-version = "1.49"
 authors = ["Tokio Contributors <[email protected]>"]
@@ -51,38 +51,46 @@ net = [
   "mio/os-poll",
   "mio/os-ext",
   "mio/net",
-  "socket2",
-  "windows-sys/Win32_Foundation",
-  "windows-sys/Win32_Security",
-  "windows-sys/Win32_Storage_FileSystem",
-  "windows-sys/Win32_System_Pipes",
-  "windows-sys/Win32_System_SystemServices",
+  "winapi/fileapi",
+  "winapi/handleapi",
+  "winapi/namedpipeapi",
+  "winapi/winbase",
+  "winapi/winnt",
+  "winapi/minwindef",
+  "winapi/accctrl",
+  "winapi/aclapi"
 ]
 process = [
   "bytes",
+  "once_cell",
   "libc",
   "mio/os-poll",
   "mio/os-ext",
   "mio/net",
   "signal-hook-registry",
-  "windows-sys/Win32_Foundation",
-  "windows-sys/Win32_System_Threading",
-  "windows-sys/Win32_System_WindowsProgramming",
+  "winapi/handleapi",
+  "winapi/minwindef",
+  "winapi/processthreadsapi",
+  "winapi/threadpoollegacyapiset",
+  "winapi/winbase",
+  "winapi/winnt",
 ]
 # Includes basic task execution capabilities
-rt = []
+rt = ["once_cell"]
 rt-multi-thread = [
   "num_cpus",
   "rt",
 ]
 signal = [
+  "once_cell",
   "libc",
   "mio/os-poll",
   "mio/net",
   "mio/os-ext",
   "signal-hook-registry",
-  "windows-sys/Win32_Foundation",
-  "windows-sys/Win32_System_Console",
+  "winapi/consoleapi",
+  "winapi/wincon",
+  "winapi/minwindef",
 ]
 sync = []
 test-util = ["rt", "sync", "time"]
@@ -103,13 +111,14 @@ pin-project-lite = "0.2.0"
 
 # Everything else is optional...
 bytes = { version = "1.0.0", optional = true }
+once_cell = { version = "1.5.2", optional = true }
 memchr = { version = "2.2", optional = true }
 mio = { version = "0.8.4", optional = true }
 num_cpus = { version = "1.8.0", optional = true }
 parking_lot = { version = "0.12.0", optional = true }
 
 [target.'cfg(not(any(target_arch = "wasm32", target_arch = "wasm64")))'.dependencies]
-socket2 = { version = "0.4.4", optional = true, features = [ "all" ] }
+socket2 = { version = "0.4.4", features = [ "all" ] }
 
 # Currently unstable. The API exposed by these features may be broken at any time.
 # Requires `--cfg tokio_unstable` to enable.
@@ -122,19 +131,14 @@ signal-hook-registry = { version = "1.1.1", optional = true }
 
 [target.'cfg(unix)'.dev-dependencies]
 libc = { version = "0.2.42" }
-nix = { version = "0.26", default-features = false, features = ["fs", "socket"] }
+nix = { version = "0.24", default-features = false, features = ["fs", "socket"] }
 
-[target.'cfg(windows)'.dependencies.windows-sys]
-version = "0.45"
+[target.'cfg(windows)'.dependencies.winapi]
+version = "0.3.8"
+default-features = false
+features = ["std"]
 optional = true
 
-[target.'cfg(docsrs)'.dependencies.windows-sys]
-version = "0.45"
-features = [
-    "Win32_Foundation",
-    "Win32_Security_Authorization",
-]
-
 [target.'cfg(windows)'.dev-dependencies.ntapi]
 version = "0.3.6"
 
@@ -147,6 +151,7 @@ tempfile = "3.1.0"
 async-stream = "0.3"
 
 [target.'cfg(not(any(target_arch = "wasm32", target_arch = "wasm64")))'.dev-dependencies]
+proptest = "1"
 socket2 = "0.4"
 
 [target.'cfg(not(all(any(target_arch = "wasm32", target_arch = "wasm64"), target_os = "unknown")))'.dev-dependencies]
@@ -156,7 +161,7 @@ rand = "0.8.0"
 wasm-bindgen-test = "0.3.0"
 
 [target.'cfg(target_os = "freebsd")'.dev-dependencies]
-mio-aio = { version = "0.7.0", features = ["tokio"] }
+mio-aio = { version = "0.6.0", features = ["tokio"] }
 
 [target.'cfg(loom)'.dev-dependencies]
 loom = { version = "0.5.2", features = ["futures", "checkpoint"] }

tokio/LICENSE

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

tokio/README.md

@@ -56,7 +56,7 @@ Make sure you activated the full features of the tokio crate on Cargo.toml:
 
 ```toml
 [dependencies]
-tokio = { version = "1.25.0", features = ["full"] }
+tokio = { version = "1.20.1", features = ["full"] }
 ```
 Then, on your main.rs:
 
@@ -202,12 +202,12 @@ 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.18.x` - LTS release until June 2023
- * `1.20.x` - LTS release until September 2023.
+ * `1.18.x` - LTS release until January 2023
+ * `1.20.x` - LTS release until April 2023.
 
-Each LTS release will continue to receive backported fixes for at least a year.
-If you wish to use a fixed minor release in your project, we recommend that you
-use an LTS release.
+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.18.x` patch release, you

tokio/build.rs

@@ -17,33 +17,9 @@ const ADDR_OF_PROBE: &str = r#"
 }
 "#;
 
-const CONST_MUTEX_NEW_PROBE: &str = r#"
-{
-    static MY_MUTEX: ::std::sync::Mutex<i32> = ::std::sync::Mutex::new(1);
-    *MY_MUTEX.lock().unwrap()
-}
-"#;
-
-const TARGET_HAS_ATOMIC_PROBE: &str = r#"
-{
-    #[cfg(target_has_atomic = "ptr")]
-    let _ = ();
-}
-"#;
-
-const TARGET_ATOMIC_U64_PROBE: &str = r#"
-{
-    #[allow(unused_imports)]
-    use std::sync::atomic::AtomicU64 as _;
-}
-"#;
-
 fn main() {
     let mut enable_const_thread_local = false;
     let mut enable_addr_of = false;
-    let mut enable_target_has_atomic = false;
-    let mut enable_const_mutex_new = false;
-    let mut target_needs_atomic_u64_fallback = false;
 
     match AutoCfg::new() {
         Ok(ac) => {
@@ -81,42 +57,6 @@ fn main() {
                     enable_addr_of = true;
                 }
             }
-
-            // The `target_has_atomic` cfg was stabilized in 1.60.
-            if ac.probe_rustc_version(1, 61) {
-                enable_target_has_atomic = true;
-            } else if ac.probe_rustc_version(1, 60) {
-                // This compiler claims to be 1.60, but there are some nightly
-                // compilers that claim to be 1.60 without supporting the
-                // feature. Explicitly probe to check if code using them
-                // compiles.
-                //
-                // The oldest nightly that supports the feature is 2022-02-11.
-                if ac.probe_expression(TARGET_HAS_ATOMIC_PROBE) {
-                    enable_target_has_atomic = true;
-                }
-            }
-
-            // If we can't tell using `target_has_atomic`, tell if the target
-            // has `AtomicU64` by trying to use it.
-            if !enable_target_has_atomic && !ac.probe_expression(TARGET_ATOMIC_U64_PROBE) {
-                target_needs_atomic_u64_fallback = true;
-            }
-
-            // The `Mutex::new` method was made const in 1.63.
-            if ac.probe_rustc_version(1, 64) {
-                enable_const_mutex_new = true;
-            } else if ac.probe_rustc_version(1, 63) {
-                // This compiler claims to be 1.63, but there are some nightly
-                // compilers that claim to be 1.63 without supporting the
-                // feature. Explicitly probe to check if code using them
-                // compiles.
-                //
-                // The oldest nightly that supports the feature is 2022-06-20.
-                if ac.probe_expression(CONST_MUTEX_NEW_PROBE) {
-                    enable_const_mutex_new = true;
-                }
-            }
         }
 
         Err(e) => {
@@ -146,30 +86,6 @@ fn main() {
         autocfg::emit("tokio_no_addr_of")
     }
 
-    if !enable_target_has_atomic {
-        // To disable this feature on compilers that support it, you can
-        // explicitly pass this flag with the following environment variable:
-        //
-        // RUSTFLAGS="--cfg tokio_no_target_has_atomic"
-        autocfg::emit("tokio_no_target_has_atomic")
-    }
-
-    if !enable_const_mutex_new {
-        // To disable this feature on compilers that support it, you can
-        // explicitly pass this flag with the following environment variable:
-        //
-        // RUSTFLAGS="--cfg tokio_no_const_mutex_new"
-        autocfg::emit("tokio_no_const_mutex_new")
-    }
-
-    if target_needs_atomic_u64_fallback {
-        // To disable this feature on compilers that support it, you can
-        // explicitly pass this flag with the following environment variable:
-        //
-        // RUSTFLAGS="--cfg tokio_no_atomic_u64"
-        autocfg::emit("tokio_no_atomic_u64")
-    }
-
     let target = ::std::env::var("TARGET").unwrap_or_default();
 
     // We emit cfgs instead of using `target_family = "wasm"` that requires Rust 1.54.

tokio/docs/reactor-refactor.md

@@ -188,12 +188,12 @@ readiness, the driver's tick is packed into the atomic `usize`.
 The `ScheduledIo` readiness `AtomicUsize` is structured as:
 
 ```
-| shutdown | generation |  driver tick | readiness |
+| reserved | generation |  driver tick | readiness |
 |----------+------------+--------------+-----------|
 |   1 bit  |   7 bits   +    8 bits    +  16 bits  |
 ```
 
-The `shutdown` and `generation` components exist today.
+The `reserved` and `generation` components exist today.
 
 The `readiness()` function returns a `ReadyEvent` value. This value includes the
 `tick` component read with the resource's readiness value. When

tokio/external-types.toml

@@ -7,5 +7,10 @@ allowed_external_types = [
    "bytes::buf::buf_mut::BufMut",
 
    "tokio_macros::*",
+
+   # TODO(https://github.com/tokio-rs/tokio/issues/4916): Remove the libc types
+   "libc::unix::gid_t",
+   "libc::unix::pid_t",
+   "libc::unix::uid_t",
 ]
 

tokio/fuzz/.gitignore

@@ -1,4 +0,0 @@
-target
-corpus
-artifacts
-coverage

tokio/fuzz/Cargo.toml

@@ -1,29 +0,0 @@
-[package]
-name = "tokio-fuzz"
-version = "0.0.0"
-publish = false
-edition = "2018"
-
-[package.metadata]
-cargo-fuzz = true
-
-[dependencies]
-libfuzzer-sys = "0.4"
-
-[dependencies.tokio]
-path = ".."
-features = ["fs","net","process","rt","sync","signal","time"]
-
-
-# Prevent this from interfering with workspaces
-[workspace]
-members = ["."]
-
-[profile.release]
-debug = 1
-
-[[bin]]
-name = "fuzz_linked_list"
-path = "fuzz_targets/fuzz_linked_list.rs"
-test = false
-doc = false

tokio/fuzz/fuzz_targets/fuzz_linked_list.rs

@@ -1,7 +0,0 @@
-#![no_main]
-
-use libfuzzer_sys::fuzz_target;
-
-fuzz_target!(|data: &[u8]| {
-    tokio::fuzz::fuzz_linked_list(data);
-});

tokio/src/coop.rs

@@ -29,7 +29,11 @@
 // other futures. By doing this, you avoid double-counting each iteration of
 // the outer future against the cooperating budget.
 
-use crate::runtime::context;
+use std::cell::Cell;
+
+thread_local! {
+    static CURRENT: Cell<Budget> = const { Cell::new(Budget::unconstrained()) };
+}
 
 /// Opaque type tracking the amount of "work" a task may still do before
 /// yielding back to the scheduler.
@@ -52,7 +56,7 @@ impl Budget {
     }
 
     /// Returns an unconstrained budget. Operations will not be limited.
-    pub(super) const fn unconstrained() -> Budget {
+    const fn unconstrained() -> Budget {
         Budget(None)
     }
 
@@ -77,42 +81,37 @@ pub(crate) fn with_unconstrained<R>(f: impl FnOnce() -> R) -> R {
 
 #[inline(always)]
 fn with_budget<R>(budget: Budget, f: impl FnOnce() -> R) -> R {
-    struct ResetGuard {
+    struct ResetGuard<'a> {
+        cell: &'a Cell<Budget>,
         prev: Budget,
     }
 
-    impl Drop for ResetGuard {
+    impl<'a> Drop for ResetGuard<'a> {
         fn drop(&mut self) {
-            let _ = context::budget(|cell| {
-                cell.set(self.prev);
-            });
+            self.cell.set(self.prev);
         }
     }
 
-    #[allow(unused_variables)]
-    let maybe_guard = context::budget(|cell| {
+    CURRENT.with(move |cell| {
         let prev = cell.get();
+
         cell.set(budget);
 
-        ResetGuard { prev }
-    });
+        let _guard = ResetGuard { cell, prev };
 
-    // The function is called regardless even if the budget is not successfully
-    // set due to the thread-local being destroyed.
-    f()
+        f()
+    })
 }
 
 #[inline(always)]
 pub(crate) fn has_budget_remaining() -> bool {
-    // If the current budget cannot be accessed due to the thread-local being
-    // shutdown, then we assume there is budget remaining.
-    context::budget(|cell| cell.get().has_remaining()).unwrap_or(true)
+    CURRENT.with(|cell| cell.get().has_remaining())
 }
 
 cfg_rt_multi_thread! {
     /// Sets the current task's budget.
     pub(crate) fn set(budget: Budget) {
-        let _ = context::budget(|cell| cell.set(budget));
+        CURRENT.with(|cell| cell.set(budget))
     }
 }
 
@@ -121,16 +120,15 @@ cfg_rt! {
     ///
     /// Returns the remaining budget
     pub(crate) fn stop() -> Budget {
-        context::budget(|cell| {
+        CURRENT.with(|cell| {
             let prev = cell.get();
             cell.set(Budget::unconstrained());
             prev
-        }).unwrap_or(Budget::unconstrained())
+        })
     }
 }
 
 cfg_coop! {
-    use std::cell::Cell;
     use std::task::{Context, Poll};
 
     #[must_use]
@@ -148,7 +146,7 @@ cfg_coop! {
             // They are both represented as the remembered budget being unconstrained.
             let budget = self.0.get();
             if !budget.is_unconstrained() {
-                let _ = context::budget(|cell| {
+                CURRENT.with(|cell| {
                     cell.set(budget);
                 });
             }
@@ -164,12 +162,12 @@ cfg_coop! {
     /// that the budget empties appropriately.
     ///
     /// Note that `RestoreOnPending` restores the budget **as it was before `poll_proceed`**.
-    /// Therefore, if the budget is _fCURRENT.withurther_ adjusted between when `poll_proceed` returns and
+    /// Therefore, if the budget is _further_ adjusted between when `poll_proceed` returns and
     /// `RestRestoreOnPending` is dropped, those adjustments are erased unless the caller indicates
     /// that progress was made.
     #[inline]
     pub(crate) fn poll_proceed(cx: &mut Context<'_>) -> Poll<RestoreOnPending> {
-        context::budget(|cell| {
+        CURRENT.with(|cell| {
             let mut budget = cell.get();
 
             if budget.decrement() {
@@ -180,7 +178,7 @@ cfg_coop! {
                 cx.waker().wake_by_ref();
                 Poll::Pending
             }
-        }).unwrap_or(Poll::Ready(RestoreOnPending(Cell::new(Budget::unconstrained()))))
+        })
     }
 
     impl Budget {
@@ -213,7 +211,7 @@ mod test {
     use wasm_bindgen_test::wasm_bindgen_test as test;
 
     fn get() -> Budget {
-        context::budget(|cell| cell.get()).unwrap_or(Budget::unconstrained())
+        CURRENT.with(|cell| cell.get())
     }
 
     #[test]

tokio/src/doc/mod.rs

@@ -21,3 +21,4 @@
 pub enum NotDefinedHere {}
 
 pub mod os;
+pub mod winapi;

tokio/src/doc/winapi.rs

@@ -0,0 +1,66 @@
+//! See [winapi].
+//!
+//! [winapi]: https://docs.rs/winapi
+
+/// See [winapi::shared](https://docs.rs/winapi/*/winapi/shared/index.html).
+pub mod shared {
+    /// See [winapi::shared::winerror](https://docs.rs/winapi/*/winapi/shared/winerror/index.html).
+    #[allow(non_camel_case_types)]
+    pub mod winerror {
+        /// See [winapi::shared::winerror::ERROR_ACCESS_DENIED][winapi]
+        ///
+        /// [winapi]: https://docs.rs/winapi/*/winapi/shared/winerror/constant.ERROR_ACCESS_DENIED.html
+        pub type ERROR_ACCESS_DENIED = crate::doc::NotDefinedHere;
+
+        /// See [winapi::shared::winerror::ERROR_PIPE_BUSY][winapi]
+        ///
+        /// [winapi]: https://docs.rs/winapi/*/winapi/shared/winerror/constant.ERROR_PIPE_BUSY.html
+        pub type ERROR_PIPE_BUSY = crate::doc::NotDefinedHere;
+
+        /// See [winapi::shared::winerror::ERROR_MORE_DATA][winapi]
+        ///
+        /// [winapi]: https://docs.rs/winapi/*/winapi/shared/winerror/constant.ERROR_MORE_DATA.html
+        pub type ERROR_MORE_DATA = crate::doc::NotDefinedHere;
+    }
+}
+
+/// See [winapi::um](https://docs.rs/winapi/*/winapi/um/index.html).
+pub mod um {
+    /// See [winapi::um::winbase](https://docs.rs/winapi/*/winapi/um/winbase/index.html).
+    #[allow(non_camel_case_types)]
+    pub mod winbase {
+        /// See [winapi::um::winbase::PIPE_TYPE_MESSAGE][winapi]
+        ///
+        /// [winapi]: https://docs.rs/winapi/*/winapi/um/winbase/constant.PIPE_TYPE_MESSAGE.html
+        pub type PIPE_TYPE_MESSAGE = crate::doc::NotDefinedHere;
+
+        /// See [winapi::um::winbase::PIPE_TYPE_BYTE][winapi]
+        ///
+        /// [winapi]: https://docs.rs/winapi/*/winapi/um/winbase/constant.PIPE_TYPE_BYTE.html
+        pub type PIPE_TYPE_BYTE = crate::doc::NotDefinedHere;
+
+        /// See [winapi::um::winbase::PIPE_CLIENT_END][winapi]
+        ///
+        /// [winapi]: https://docs.rs/winapi/*/winapi/um/winbase/constant.PIPE_CLIENT_END.html
+        pub type PIPE_CLIENT_END = crate::doc::NotDefinedHere;
+
+        /// See [winapi::um::winbase::PIPE_SERVER_END][winapi]
+        ///
+        /// [winapi]: https://docs.rs/winapi/*/winapi/um/winbase/constant.PIPE_SERVER_END.html
+        pub type PIPE_SERVER_END = crate::doc::NotDefinedHere;
+
+        /// See [winapi::um::winbase::SECURITY_IDENTIFICATION][winapi]
+        ///
+        /// [winapi]: https://docs.rs/winapi/*/winapi/um/winbase/constant.SECURITY_IDENTIFICATION.html
+        pub type SECURITY_IDENTIFICATION = crate::doc::NotDefinedHere;
+    }
+
+    /// See [winapi::um::minwinbase](https://docs.rs/winapi/*/winapi/um/minwinbase/index.html).
+    #[allow(non_camel_case_types)]
+    pub mod minwinbase {
+        /// See [winapi::um::minwinbase::SECURITY_ATTRIBUTES][winapi]
+        ///
+        /// [winapi]: https://docs.rs/winapi/*/winapi/um/minwinbase/constant.SECURITY_ATTRIBUTES.html
+        pub type SECURITY_ATTRIBUTES = crate::doc::NotDefinedHere;
+    }
+}

tokio/src/fs/file/tests.rs

@@ -231,12 +231,12 @@ fn flush_while_idle() {
 #[cfg_attr(miri, ignore)] // takes a really long time with miri
 fn read_with_buffer_larger_than_max() {
     // Chunks
-    let chunk_a = crate::io::blocking::MAX_BUF;
+    let chunk_a = 16 * 1024;
     let chunk_b = chunk_a * 2;
     let chunk_c = chunk_a * 3;
     let chunk_d = chunk_a * 4;
 
-    assert_eq!(chunk_d / 1024 / 1024, 8);
+    assert_eq!(chunk_d / 1024, 64);
 
     let mut data = vec![];
     for i in 0..(chunk_d - 1) {
@@ -303,12 +303,12 @@ fn read_with_buffer_larger_than_max() {
 #[cfg_attr(miri, ignore)] // takes a really long time with miri
 fn write_with_buffer_larger_than_max() {
     // Chunks
-    let chunk_a = crate::io::blocking::MAX_BUF;
+    let chunk_a = 16 * 1024;
     let chunk_b = chunk_a * 2;
     let chunk_c = chunk_a * 3;
     let chunk_d = chunk_a * 4;
 
-    assert_eq!(chunk_d / 1024 / 1024, 8);
+    assert_eq!(chunk_d / 1024, 64);
 
     let mut data = vec![];
     for i in 0..(chunk_d - 1) {

tokio/src/fs/mocks.rs

@@ -81,7 +81,7 @@ impl Write for &'_ MockFile {
     }
 }
 
-tokio_thread_local! {
+thread_local! {
     static QUEUE: RefCell<VecDeque<Box<dyn FnOnce() + Send>>> = RefCell::new(VecDeque::new())
 }
 

tokio/src/fs/open_options.rs

@@ -542,7 +542,7 @@ feature! {
         /// # Examples
         ///
         /// ```no_run
-        /// use windows_sys::Win32::Storage::FileSystem::FILE_FLAG_DELETE_ON_CLOSE;
+        /// use winapi::um::winbase::FILE_FLAG_DELETE_ON_CLOSE;
         /// use tokio::fs::OpenOptions;
         ///
         /// # #[tokio::main]
@@ -581,7 +581,7 @@ feature! {
         /// # Examples
         ///
         /// ```no_run
-        /// use windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_HIDDEN;
+        /// use winapi::um::winnt::FILE_ATTRIBUTE_HIDDEN;
         /// use tokio::fs::OpenOptions;
         ///
         /// # #[tokio::main]
@@ -624,7 +624,7 @@ feature! {
         /// # Examples
         ///
         /// ```no_run
-        /// use windows_sys::Win32::Storage::FileSystem::SECURITY_IDENTIFICATION;
+        /// use winapi::um::winbase::SECURITY_IDENTIFICATION;
         /// use tokio::fs::OpenOptions;
         ///
         /// # #[tokio::main]

tokio/src/fs/open_options/mock_open_options.rs

@@ -1,4 +1,3 @@
-#![allow(unreachable_pub)]
 //! Mock version of std::fs::OpenOptions;
 use mockall::mock;
 

tokio/src/fs/read_dir.rs

@@ -1,6 +1,5 @@
 use crate::fs::asyncify;
 
-use std::collections::VecDeque;
 use std::ffi::OsString;
 use std::fs::{FileType, Metadata};
 use std::future::Future;
@@ -20,8 +19,6 @@ use crate::blocking::spawn_blocking;
 #[cfg(not(test))]
 use crate::blocking::JoinHandle;
 
-const CHUNK_SIZE: usize = 32;
-
 /// Returns a stream over the entries within a directory.
 ///
 /// This is an async version of [`std::fs::read_dir`](std::fs::read_dir)
@@ -32,14 +29,9 @@ const CHUNK_SIZE: usize = 32;
 /// [`spawn_blocking`]: crate::task::spawn_blocking
 pub async fn read_dir(path: impl AsRef<Path>) -> io::Result<ReadDir> {
     let path = path.as_ref().to_owned();
-    asyncify(|| -> io::Result<ReadDir> {
-        let mut std = std::fs::read_dir(path)?;
-        let mut buf = VecDeque::with_capacity(CHUNK_SIZE);
-        ReadDir::next_chunk(&mut buf, &mut std);
+    let std = asyncify(|| std::fs::read_dir(path)).await?;
 
-        Ok(ReadDir(State::Idle(Some((buf, std)))))
-    })
-    .await
+    Ok(ReadDir(State::Idle(Some(std))))
 }
 
 /// Reads the entries in a directory.
@@ -66,8 +58,8 @@ pub struct ReadDir(State);
 
 #[derive(Debug)]
 enum State {
-    Idle(Option<(VecDeque<io::Result<DirEntry>>, std::fs::ReadDir)>),
-    Pending(JoinHandle<(VecDeque<io::Result<DirEntry>>, std::fs::ReadDir)>),
+    Idle(Option<std::fs::ReadDir>),
+    Pending(JoinHandle<(Option<io::Result<std::fs::DirEntry>>, std::fs::ReadDir)>),
 }
 
 impl ReadDir {
@@ -102,57 +94,29 @@ impl ReadDir {
     pub fn poll_next_entry(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<Option<DirEntry>>> {
         loop {
             match self.0 {
-                State::Idle(ref mut data) => {
-                    let (buf, _) = data.as_mut().unwrap();
-
-                    if let Some(ent) = buf.pop_front() {
-                        return Poll::Ready(ent.map(Some));
-                    };
-
-                    let (mut buf, mut std) = data.take().unwrap();
+                State::Idle(ref mut std) => {
+                    let mut std = std.take().unwrap();
 
                     self.0 = State::Pending(spawn_blocking(move || {
-                        ReadDir::next_chunk(&mut buf, &mut std);
-                        (buf, std)
+                        let ret = std.next();
+                        (ret, std)
                     }));
                 }
                 State::Pending(ref mut rx) => {
-                    let (mut buf, std) = ready!(Pin::new(rx).poll(cx))?;
+                    let (ret, std) = ready!(Pin::new(rx).poll(cx))?;
+                    self.0 = State::Idle(Some(std));
 
-                    let ret = match buf.pop_front() {
-                        Some(Ok(x)) => Ok(Some(x)),
+                    let ret = match ret {
+                        Some(Ok(std)) => Ok(Some(DirEntry(Arc::new(std)))),
                         Some(Err(e)) => Err(e),
                         None => Ok(None),
                     };
 
-                    self.0 = State::Idle(Some((buf, std)));
-
                     return Poll::Ready(ret);
                 }
             }
         }
     }
-
-    fn next_chunk(buf: &mut VecDeque<io::Result<DirEntry>>, std: &mut std::fs::ReadDir) {
-        for ret in std.by_ref().take(CHUNK_SIZE) {
-            let success = ret.is_ok();
-
-            buf.push_back(ret.map(|std| DirEntry {
-                #[cfg(not(any(
-                    target_os = "solaris",
-                    target_os = "illumos",
-                    target_os = "haiku",
-                    target_os = "vxworks"
-                )))]
-                file_type: std.file_type().ok(),
-                std: Arc::new(std),
-            }));
-
-            if !success {
-                break;
-            }
-        }
-    }
 }
 
 feature! {
@@ -196,16 +160,7 @@ feature! {
 /// filesystem. Each entry can be inspected via methods to learn about the full
 /// path or possibly other metadata through per-platform extension traits.
 #[derive(Debug)]
-pub struct DirEntry {
-    #[cfg(not(any(
-        target_os = "solaris",
-        target_os = "illumos",
-        target_os = "haiku",
-        target_os = "vxworks"
-    )))]
-    file_type: Option<FileType>,
-    std: Arc<std::fs::DirEntry>,
-}
+pub struct DirEntry(Arc<std::fs::DirEntry>);
 
 impl DirEntry {
     /// Returns the full path to the file that this entry represents.
@@ -238,7 +193,7 @@ impl DirEntry {
     ///
     /// The exact text, of course, depends on what files you have in `.`.
     pub fn path(&self) -> PathBuf {
-        self.std.path()
+        self.0.path()
     }
 
     /// Returns the bare file name of this directory entry without any other
@@ -259,7 +214,7 @@ impl DirEntry {
     /// # }
     /// ```
     pub fn file_name(&self) -> OsString {
-        self.std.file_name()
+        self.0.file_name()
     }
 
     /// Returns the metadata for the file that this entry points at.
@@ -293,7 +248,7 @@ impl DirEntry {
     /// # }
     /// ```
     pub async fn metadata(&self) -> io::Result<Metadata> {
-        let std = self.std.clone();
+        let std = self.0.clone();
         asyncify(move || std.metadata()).await
     }
 
@@ -328,23 +283,13 @@ impl DirEntry {
     /// # }
     /// ```
     pub async fn file_type(&self) -> io::Result<FileType> {
-        #[cfg(not(any(
-            target_os = "solaris",
-            target_os = "illumos",
-            target_os = "haiku",
-            target_os = "vxworks"
-        )))]
-        if let Some(file_type) = self.file_type {
-            return Ok(file_type);
-        }
-
-        let std = self.std.clone();
+        let std = self.0.clone();
         asyncify(move || std.file_type()).await
     }
 
     /// Returns a reference to the underlying `std::fs::DirEntry`.
     #[cfg(unix)]
     pub(super) fn as_inner(&self) -> &std::fs::DirEntry {
-        &self.std
+        &self.0
     }
 }

tokio/src/future/block_on.rs

@@ -3,12 +3,7 @@ use std::future::Future;
 cfg_rt! {
     #[track_caller]
     pub(crate) fn block_on<F: Future>(f: F) -> F::Output {
-        let mut e = crate::runtime::context::try_enter_blocking_region().expect(
-            "Cannot block the current thread from within a runtime. This \
-            happens because a function attempted to block the current \
-            thread while the thread is being used to drive asynchronous \
-            tasks."
-        );
+        let mut e = crate::runtime::enter::enter(false);
         e.block_on(f).unwrap()
     }
 }
@@ -16,7 +11,7 @@ cfg_rt! {
 cfg_not_rt! {
     #[track_caller]
     pub(crate) fn block_on<F: Future>(f: F) -> F::Output {
-        let mut park = crate::runtime::park::CachedParkThread::new();
+        let mut park = crate::park::thread::CachedParkThread::new();
         park.block_on(f).unwrap()
     }
 }

tokio/src/future/poll_fn.rs

@@ -7,23 +7,13 @@ use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-// This struct is intentionally `!Unpin` when `F` is `!Unpin`. This is to
-// mitigate the issue where rust puts noalias on mutable references to the
-// `PollFn` type if it is `Unpin`. If the closure has ownership of a future,
-// then this "leaks" and the future is affected by noalias too, which we don't
-// want.
-//
-// See this thread for more information:
-// <https://internals.rust-lang.org/t/surprising-soundness-trouble-around-pollfn/17484>
-//
-// The fact that `PollFn` is not `Unpin` when it shouldn't be is tested in
-// `tests/async_send_sync.rs`.
-
 /// Future for the [`poll_fn`] function.
 pub struct PollFn<F> {
     f: F,
 }
 
+impl<F> Unpin for PollFn<F> {}
+
 /// Creates a new future wrapping around a function returning [`Poll`].
 pub fn poll_fn<T, F>(f: F) -> PollFn<F>
 where
@@ -44,17 +34,7 @@ where
 {
     type Output = T;
 
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
-        // Safety: We never construct a `Pin<&mut F>` anywhere, so accessing `f`
-        // mutably in an unpinned way is sound.
-        //
-        // This use of unsafe cannot be replaced with the pin-project macro
-        // because:
-        //  * If we put `#[pin]` on the field, then it gives us a `Pin<&mut F>`,
-        //    which we can't use to call the closure.
-        //  * If we don't put `#[pin]` on the field, then it makes `PollFn` be
-        //    unconditionally `Unpin`, which we also don't want.
-        let me = unsafe { Pin::into_inner_unchecked(self) };
-        (me.f)(cx)
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
+        (self.f)(cx)
     }
 }

tokio/src/fuzz.rs

@@ -1 +0,0 @@
-pub use crate::util::linked_list::tests::fuzz_linked_list;

tokio/src/io/async_fd.rs

@@ -1,6 +1,5 @@
 use crate::io::Interest;
-use crate::runtime::io::{ReadyEvent, Registration};
-use crate::runtime::scheduler;
+use crate::runtime::io::{Handle, ReadyEvent, Registration};
 
 use mio::unix::SourceFd;
 use std::io;
@@ -65,8 +64,8 @@ use std::{task::Context, task::Poll};
 /// # Examples
 ///
 /// This example shows how to turn [`std::net::TcpStream`] asynchronous using
-/// `AsyncFd`.  It implements the read/write operations both as an `async fn`
-/// and using the IO traits [`AsyncRead`] and [`AsyncWrite`].
+/// `AsyncFd`.  It implements `read` as an async fn, and `AsyncWrite` as a trait
+/// to show how to implement both approaches.
 ///
 /// ```no_run
 /// use futures::ready;
@@ -74,7 +73,7 @@ use std::{task::Context, task::Poll};
 /// use std::net::TcpStream;
 /// use std::pin::Pin;
 /// use std::task::{Context, Poll};
-/// use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+/// use tokio::io::AsyncWrite;
 /// use tokio::io::unix::AsyncFd;
 ///
 /// pub struct AsyncTcpStream {
@@ -99,39 +98,6 @@ use std::{task::Context, task::Poll};
 ///             }
 ///         }
 ///     }
-///
-///     pub async fn write(&self, buf: &[u8]) -> io::Result<usize> {
-///         loop {
-///             let mut guard = self.inner.writable().await?;
-///
-///             match guard.try_io(|inner| inner.get_ref().write(buf)) {
-///                 Ok(result) => return result,
-///                 Err(_would_block) => continue,
-///             }
-///         }
-///     }
-/// }
-///
-/// impl AsyncRead for AsyncTcpStream {
-///     fn poll_read(
-///         self: Pin<&mut Self>,
-///         cx: &mut Context<'_>,
-///         buf: &mut ReadBuf<'_>
-///     ) -> Poll<io::Result<()>> {
-///         loop {
-///             let mut guard = ready!(self.inner.poll_read_ready(cx))?;
-///
-///             let unfilled = buf.initialize_unfilled();
-///             match guard.try_io(|inner| inner.get_ref().read(unfilled)) {
-///                 Ok(Ok(len)) => {
-///                     buf.advance(len);
-///                     return Poll::Ready(Ok(()));
-///                 },
-///                 Ok(Err(err)) => return Poll::Ready(Err(err)),
-///                 Err(_would_block) => continue,
-///             }
-///         }
-///     }
 /// }
 ///
 /// impl AsyncWrite for AsyncTcpStream {
@@ -172,8 +138,6 @@ use std::{task::Context, task::Poll};
 /// [`writable`]: method@Self::writable
 /// [`AsyncFdReadyGuard`]: struct@self::AsyncFdReadyGuard
 /// [`TcpStream::poll_read_ready`]: struct@crate::net::TcpStream
-/// [`AsyncRead`]: trait@crate::io::AsyncRead
-/// [`AsyncWrite`]: trait@crate::io::AsyncWrite
 pub struct AsyncFd<T: AsRawFd> {
     registration: Registration,
     inner: Option<T>,
@@ -236,13 +200,12 @@ impl<T: AsRawFd> AsyncFd<T> {
     where
         T: AsRawFd,
     {
-        Self::new_with_handle_and_interest(inner, scheduler::Handle::current(), interest)
+        Self::new_with_handle_and_interest(inner, Handle::current(), interest)
     }
 
-    #[track_caller]
     pub(crate) fn new_with_handle_and_interest(
         inner: T,
-        handle: scheduler::Handle,
+        handle: Handle,
         interest: Interest,
     ) -> io::Result<Self> {
         let fd = inner.as_raw_fd();

tokio/src/io/blocking.rs

@@ -26,7 +26,7 @@ pub(crate) struct Buf {
     pos: usize,
 }
 
-pub(crate) const MAX_BUF: usize = 2 * 1024 * 1024;
+pub(crate) const MAX_BUF: usize = 16 * 1024;
 
 #[derive(Debug)]
 enum State<T> {

tokio/src/io/bsd/poll_aio.rs

@@ -1,8 +1,7 @@
 //! Use POSIX AIO futures with Tokio.
 
 use crate::io::interest::Interest;
-use crate::runtime::io::{ReadyEvent, Registration};
-use crate::runtime::scheduler;
+use crate::runtime::io::{Handle, ReadyEvent, Registration};
 use mio::event::Source;
 use mio::Registry;
 use mio::Token;
@@ -119,7 +118,7 @@ impl<E: AioSource> Aio<E> {
 
     fn new_with_interest(io: E, interest: Interest) -> io::Result<Self> {
         let mut io = MioSource(io);
-        let handle = scheduler::Handle::current();
+        let handle = Handle::current();
         let registration = Registration::new_with_interest_and_handle(&mut io, interest, handle)?;
         Ok(Self { io, registration })
     }

tokio/src/io/mod.rs

@@ -178,12 +178,6 @@
 //! [`Sink`]: https://docs.rs/futures/0.3/futures/sink/trait.Sink.html
 //! [`Stream`]: https://docs.rs/futures/0.3/futures/stream/trait.Stream.html
 //! [`Write`]: std::io::Write
-
-#![cfg_attr(
-    not(all(feature = "rt", feature = "net")),
-    allow(dead_code, unused_imports)
-)]
-
 cfg_io_blocking! {
     pub(crate) mod blocking;
 }

tokio/src/io/poll_evented.rs

@@ -1,6 +1,5 @@
 use crate::io::interest::Interest;
-use crate::runtime::io::Registration;
-use crate::runtime::scheduler;
+use crate::runtime::io::{Handle, Registration};
 
 use mio::event::Source;
 use std::fmt;
@@ -104,14 +103,13 @@ impl<E: Source> PollEvented<E> {
     #[track_caller]
     #[cfg_attr(feature = "signal", allow(unused))]
     pub(crate) fn new_with_interest(io: E, interest: Interest) -> io::Result<Self> {
-        Self::new_with_interest_and_handle(io, interest, scheduler::Handle::current())
+        Self::new_with_interest_and_handle(io, interest, Handle::current())
     }
 
-    #[track_caller]
     pub(crate) fn new_with_interest_and_handle(
         mut io: E,
         interest: Interest,
-        handle: scheduler::Handle,
+        handle: Handle,
     ) -> io::Result<Self> {
         let registration = Registration::new_with_interest_and_handle(&mut io, interest, handle)?;
         Ok(Self {
@@ -121,7 +119,11 @@ impl<E: Source> PollEvented<E> {
     }
 
     /// Returns a reference to the registration.
-    #[cfg(any(feature = "net"))]
+    #[cfg(any(
+        feature = "net",
+        all(unix, feature = "process"),
+        all(unix, feature = "signal"),
+    ))]
     pub(crate) fn registration(&self) -> &Registration {
         &self.registration
     }
@@ -186,29 +188,10 @@ feature! {
             &'a E: io::Write + 'a,
         {
             use std::io::Write;
-
-            loop {
-                let evt = ready!(self.registration.poll_write_ready(cx))?;
-
-                match self.io.as_ref().unwrap().write(buf) {
-                    Ok(n) => {
-                        // if we write only part of our buffer, this is sufficient on unix to show
-                        // that the socket buffer is full
-                        if n > 0 && (!cfg!(windows) && n < buf.len()) {
-                            self.registration.clear_readiness(evt);
-                        }
-
-                        return Poll::Ready(Ok(n));
-                    },
-                    Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
-                        self.registration.clear_readiness(evt);
-                    }
-                    Err(e) => return Poll::Ready(Err(e)),
-                }
-            }
+            self.registration.poll_write_io(cx, || self.io.as_ref().unwrap().write(buf))
         }
 
-        #[cfg(any(feature = "net", feature = "process"))]
+        #[cfg(feature = "net")]
         pub(crate) fn poll_write_vectored<'a>(
             &'a self,
             cx: &mut Context<'_>,

tokio/src/io/ready.rs

@@ -12,7 +12,7 @@ const WRITE_CLOSED: usize = 0b0_1000;
 ///
 /// `Ready` tracks which operation an I/O resource is ready to perform.
 #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, PartialEq, PartialOrd)]
 pub struct Ready(usize);
 
 impl Ready {