Clarify chunk_mut documentation

2026-08-08 00:00:26 +02:00 · 2021-12-12 17:49:18 +01:00
32 changed files with 666 additions and 3300 deletions
@@ -7,13 +7,11 @@ on:
  push:
    branches:
      - master
-  schedule:
-    - cron: '0 2 * * 0'

 env:
  RUSTFLAGS: -Dwarnings
  RUST_BACKTRACE: 1
-  nightly: nightly-2024-09-15
+  nightly: nightly-2021-04-13

 defaults:
  run:
@@ -25,11 +23,11 @@ jobs:
    name: rustfmt
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v2
    - name: Install Rust
-      run: rustup update stable
+      run: rustup update stable && rustup default stable
    - name: Check formatting
-      run: cargo fmt --all --check
+      run: cargo fmt --all -- --check

  # TODO
  # # Apply clippy lints
@@ -37,7 +35,7 @@ jobs:
  #   name: clippy
  #   runs-on: ubuntu-latest
  #   steps:
-  #   - uses: actions/checkout@v4
+  #   - uses: actions/checkout@v2
  #   - name: Apply clippy lints
  #     run: cargo clippy --all-features

@@ -50,11 +48,11 @@ jobs:
    name: minrust
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v4
-      - name: Install cargo-hack
-        uses: taiki-e/install-action@cargo-hack
+      - uses: actions/checkout@v2
+      - name: Install Rust
+        run: rustup update 1.39.0 && rustup default 1.39.0
      - name: Check
-        run: cargo hack check --feature-powerset --optional-deps --rust-version
+        run: . ci/test-stable.sh check

  # Stable
  stable:
@@ -67,27 +65,23 @@ jobs:
          - windows-latest
    runs-on: ${{ matrix.os }}
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
      - name: Install Rust
        # --no-self-update is necessary because the windows environment cannot self-update rustup.exe.
-        run: rustup update stable --no-self-update
-      - name: Install cargo-hack
-        uses: taiki-e/install-action@cargo-hack
+        run: rustup update stable --no-self-update && rustup default stable
      - name: Test
-        run: ci/test-stable.sh test
+        run: . ci/test-stable.sh test

  # Nightly
  nightly:
    name: nightly
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
      - name: Install Rust
        run: rustup update $nightly && rustup default $nightly
-      - name: Install cargo-hack
-        uses: taiki-e/install-action@cargo-hack
      - name: Test
-        run: ci/test-stable.sh test
+        run: . ci/test-stable.sh test

  # Run tests on some extra platforms
  cross:
@@ -102,14 +96,13 @@ jobs:
          - wasm32-unknown-unknown
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
      - name: Install Rust
-        run: rustup update stable
-      - name: Install cross
-        uses: taiki-e/install-action@cross
-        if: matrix.target != 'wasm32-unknown-unknown'
+        run: rustup update stable && rustup default stable
      - name: cross build --target ${{ matrix.target }}
-        run: cross build --target ${{ matrix.target }}
+        run: |
+          cargo install cross
+          cross build --target ${{ matrix.target }}
        if: matrix.target != 'wasm32-unknown-unknown'
      # WASM support
      - name: cargo build --target ${{ matrix.target }}
@@ -123,21 +116,18 @@ jobs:
    name: tsan
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
      - name: Install Rust
        run: rustup update $nightly && rustup default $nightly
      - name: Install rust-src
        run: rustup component add rust-src
      - name: ASAN / TSAN
-        run: ci/tsan.sh
-
+        run: . ci/tsan.sh
  miri:
    name: miri
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v4
-      - name: Install Rust
-        run: rustup update $nightly && rustup default $nightly
+      - uses: actions/checkout@v2
      - name: Miri
        run: ci/miri.sh

@@ -146,7 +136,7 @@ jobs:
    name: loom
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
      - name: Install Rust
        run: rustup update $nightly && rustup default $nightly
      - name: Loom tests
@@ -162,13 +152,12 @@ jobs:
      - minrust
      - cross
      - tsan
-      - miri
      - loom
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
      - name: Install Rust
-        run: rustup update $nightly && rustup default $nightly
+        run: rustup update stable && rustup default stable
      - name: Build documentation
        run: cargo doc --no-deps --all-features
        env:
@@ -1,174 +1,3 @@
-# 1.8.0 (October 21, 2024)
-
- Guarantee address in `split_off`/`split_to` for empty slices (#740)
-
-# 1.7.2 (September 17, 2024)
-
-### Fixed
-
- Fix default impl of `Buf::{get_int, get_int_le}` (#732)
-
-### Documented
-
- Fix double spaces in comments and doc comments (#731)
-
-### Internal changes
-
- Ensure BytesMut::advance reduces capacity (#728) 
-
-# 1.7.1 (August 1, 2024)
-
-This release reverts the following change due to a regression:
-
- Reuse capacity when possible in `<BytesMut as Buf>::advance` impl (#698)
-
-The revert can be found at #726.
-
-# 1.7.0 (July 31, 2024)
-
-### Added
-
- Add conversion from `Bytes` to `BytesMut` (#695, #710)
- Add reclaim method without additional allocation (#686)
-
-### Documented
-
- Clarify how `BytesMut::zeroed` works (#714)
- Clarify the behavior of `Buf::chunk` (#717)
-
-### Changed
-
- Change length condition of `BytesMut::truncate`
- Reuse capacity when possible in `<BytesMut as Buf>::advance` impl (#698)
- Improve `must_use` suggestion of `BytesMut::split` (#699)
-
-### Internal changes
-
- Use `ManuallyDrop` instead of `mem::forget` (#678)
- Don't set `len` in `BytesMut::reserve` (#682)
- Optimize `Bytes::copy_to_bytes` (#688)
- Refactor `BytesMut::truncate` (#694)
- Refactor `BytesMut::resize` (#696)
- Reorder assertion in `Bytes::split_to`, `Bytes::split_off` (#689, #693)
- Use `offset_from` in more places (#705)
- Correct the wrong usage of `IntoIter` (#707)
-
-# 1.6.1 (July 13, 2024)
-
-This release fixes a bug where `Bytes::is_unique` returns incorrect values when
-the `Bytes` originates from a shared `BytesMut`. (#718)
-
-# 1.6.0 (March 22, 2024)
-
-### Added
-
- Add `Bytes::is_unique` (#643)
-
-### Documented
-
- Fix changelog typo (#628)
- Fix some spelling mistakes (#633)
- Typo fix (#637)
- Fix broken links (#639)
- Add security policy (#649)
-
-### Internal changes
-
- Move comment to correct constant (#629)
- Various cleanup (#635)
- Simplify `UninitSlice::as_uninit_slice_mut()` logic (#644)
- Use `self.` instead of `Self::` (#642)
- `BytesMut`: Assert alignment of `Shared` (#652)
- Remove unnecessary namespace qualifier (#660)
- Remove an unnecessary else branch (#662)
- Remove unreachable else branch (#661)
- make parameter mut in `From<Vec>` (#667)
- Restore commented tests (#665)
- Use `sub` instead of `offset` (#668)
- Calculate original capacity only if necessary (#666)
- `set_vec_pos` does not need a second parameter (#672)
- `get_vec_pos`: use `&self` instead of `&mut self` (#670)
- Refactor `split_at`/`split_to` (#663)
- Use `Iterator` from the prelude (#673)
- `copy_to_bytes`: Add panic section to docs (#676)
- Remove redundant reserve call (#674)
- Use `ManuallyDrop` instead of `mem::forget` (#675)
-
-
-# 1.5.0 (September 7, 2023)
-
-### Added
-
- Add `UninitSlice::{new,uninit}` (#598, #599)
- Implement `BufMut` for `&mut [MaybeUninit<u8>]` (#597)
-
-### Changed
-
- Mark `BytesMut::extend_from_slice` as inline (#595)
-
-# 1.4.0 (January 31, 2023)
-
-### Added
-
- Make `IntoIter` constructor public (#581)
-
-### Fixed
-
- Avoid large reallocations when freezing `BytesMut` (#592)
-
-### Documented
-
- Document which functions require `std` (#591)
- Fix duplicate "the the" typos (#585)
-
-# 1.3.0 (November 20, 2022)
-
-### Added
-
- Rename and expose `BytesMut::spare_capacity_mut` (#572)
- Implement native-endian get and put functions for `Buf` and `BufMut` (#576)
-
-### Fixed
-
- Don't have important data in unused capacity when calling reserve (#563)
-
-### Documented
-
- `Bytes::new` etc should return `Self` not `Bytes` (#568)
-
-# 1.2.1 (July 30, 2022)
-
-### Fixed
-
- Fix unbounded memory growth when using `reserve` (#560)
-
-# 1.2.0 (July 19, 2022)
-
-### Added
-
- Add `BytesMut::zeroed` (#517)
- Implement `Extend<Bytes>` for `BytesMut` (#527)
- Add conversion from `BytesMut` to `Vec<u8>` (#543, #554)
- Add conversion from `Bytes` to `Vec<u8>` (#547)
- Add `UninitSlice::as_uninit_slice_mut()` (#548)
- Add const to `Bytes::{len,is_empty}` (#514)
-
-### Changed
-
- Reuse vector in `BytesMut::reserve` (#539, #544)
-
-### Fixed
-
- Make miri happy (#515, #523, #542, #545, #553)
- Make tsan happy (#541)
- Fix `remaining_mut()` on chain (#488)
- Fix amortized asymptotics of `BytesMut` (#555)
-
-### Documented
-
- Redraw layout diagram with box drawing characters (#539)
- Clarify `BytesMut::unsplit` docs (#535)
-
 # 1.1.0 (August 25, 2021)

 ### Added
@@ -4,9 +4,7 @@ name = "bytes"
 # When releasing to crates.io:
 # - Update CHANGELOG.md.
 # - Create "v1.x.y" git tag.
-version = "1.8.0"
-edition = "2018"
-rust-version = "1.39"
+version = "1.1.0"
 license = "MIT"
 authors = [
    "Carl Lerche <[email protected]>",
@@ -17,6 +15,7 @@ repository = "https://github.com/tokio-rs/bytes"
 readme = "README.md"
 keywords = ["buffers", "zero-copy", "io"]
 categories = ["network-programming", "data-structures"]
+edition = "2018"

 [features]
 default = ["std"]
@@ -29,7 +28,7 @@ serde = { version = "1.0.60", optional = true, default-features = false, feature
 serde_test = "1.0"

 [target.'cfg(loom)'.dev-dependencies]
-loom = "0.7"
+loom = "0.5"

 [package.metadata.docs.rs]
 rustdoc-args = ["--cfg", "docsrs"]
@@ -36,15 +36,6 @@ Serde support is optional and disabled by default. To enable use the feature `se
 bytes = { version = "1", features = ["serde"] }
 ```

-## Building documentation
-
-When building the `bytes` documentation the `docsrs` option should be used, otherwise
-feature gates will not be shown. This requires a nightly toolchain:
-
-```
-RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc
-```
-
 ## License

 This project is licensed under the [MIT license](LICENSE).
@@ -1,9 +0,0 @@
-# Security Policy
-
-Bytes is part of the Tokio project and uses the same security policy as [Tokio][tokio-security].
-
-## Report a security issue
-
-The process for reporting an issue is the same as for [Tokio][tokio-security]. This includes private reporting via security@tokio.rs.
-
-[tokio-security]: https://github.com/tokio-rs/tokio/security/policy
@@ -46,7 +46,7 @@ impl TestBuf {
 }
 impl Buf for TestBuf {
    fn remaining(&self) -> usize {
-        self.buf.len() - self.pos
+        return self.buf.len() - self.pos;
    }
    fn advance(&mut self, cnt: usize) {
        self.pos += cnt;
@@ -47,7 +47,7 @@ fn clone_static(b: &mut Bencher) {

    b.iter(|| {
        for _ in 0..1024 {
-            test::black_box(test::black_box(&bytes).clone());
+            test::black_box(&bytes.clone());
        }
    })
 }
@@ -58,7 +58,7 @@ fn clone_shared(b: &mut Bencher) {

    b.iter(|| {
        for _ in 0..1024 {
-            test::black_box(test::black_box(&bytes).clone());
+            test::black_box(&bytes.clone());
        }
    })
 }
@@ -70,7 +70,7 @@ fn clone_arc_vec(b: &mut Bencher) {

    b.iter(|| {
        for _ in 0..1024 {
-            test::black_box(test::black_box(&bytes).clone());
+            test::black_box(&bytes.clone());
        }
    })
 }
@@ -88,7 +88,6 @@ fn from_long_slice(b: &mut Bencher) {
 #[bench]
 fn slice_empty(b: &mut Bencher) {
    b.iter(|| {
-        // `clone` is to convert to ARC
        let b = Bytes::from(vec![17; 1024]).clone();
        for i in 0..1000 {
            test::black_box(b.slice(i % 100..i % 100));
@@ -1,10 +1,11 @@
 #!/bin/bash
 set -e

+MIRI_NIGHTLY=nightly-$(curl -s https://rust-lang.github.io/rustup-components-history/x86_64-unknown-linux-gnu/miri)
+echo "Installing latest nightly with Miri: $MIRI_NIGHTLY"
+rustup set profile minimal
+rustup default "$MIRI_NIGHTLY"
 rustup component add miri
-cargo miri setup
-
-export MIRIFLAGS="-Zmiri-strict-provenance"

 cargo miri test
 cargo miri test --target mips64-unknown-linux-gnuabi64
@@ -4,6 +4,10 @@ set -ex

 cmd="${1:-test}"

+# Install cargo-hack for feature flag test
+host=$(rustc -Vv | grep host | sed 's/host: //')
+curl -LsSf https://github.com/taiki-e/cargo-hack/releases/latest/download/cargo-hack-$host.tar.gz | tar xzf - -C ~/.cargo/bin
+
 # Run with each feature
 # * --each-feature includes both default/no-default features
 # * --optional-deps is needed for serde feature
@@ -11,6 +15,8 @@ cargo hack "${cmd}" --each-feature --optional-deps
 # Run with all features
 cargo "${cmd}" --all-features

+cargo doc --no-deps --all-features
+
 if [[ "${RUST_VERSION}" == "nightly"* ]]; then
    # Check benchmarks
    cargo check --benches
@@ -1 +0,0 @@
-msrv = "1.39"
@@ -1,9 +1,8 @@
 #[cfg(feature = "std")]
 use crate::buf::{reader, Reader};
 use crate::buf::{take, Chain, Take};
-#[cfg(feature = "std")]
-use crate::{min_u64_usize, saturating_sub_usize_u64};
-use crate::{panic_advance, panic_does_not_fit};
+
+use core::{cmp, mem, ptr};

 #[cfg(feature = "std")]
 use std::io::IoSlice;
@@ -12,12 +11,7 @@ use alloc::boxed::Box;

 macro_rules! buf_get_impl {
    ($this:ident, $typ:tt::$conv:tt) => {{
-        const SIZE: usize = core::mem::size_of::<$typ>();
-
-        if $this.remaining() < SIZE {
-            panic_advance(SIZE, $this.remaining());
-        }
-
+        const SIZE: usize = mem::size_of::<$typ>();
        // try to convert directly from the bytes
        // this Option<ret> trick is to avoid keeping a borrow on self
        // when advance() is called (mut borrow) and to call bytes() only once
@@ -38,40 +32,23 @@ macro_rules! buf_get_impl {
        }
    }};
    (le => $this:ident, $typ:tt, $len_to_read:expr) => {{
-        const SIZE: usize = core::mem::size_of::<$typ>();
+        debug_assert!(mem::size_of::<$typ>() >= $len_to_read);

        // The same trick as above does not improve the best case speed.
        // It seems to be linked to the way the method is optimised by the compiler
-        let mut buf = [0; SIZE];
-
-        let subslice = match buf.get_mut(..$len_to_read) {
-            Some(subslice) => subslice,
-            None => panic_does_not_fit(SIZE, $len_to_read),
-        };
-
-        $this.copy_to_slice(subslice);
+        let mut buf = [0; (mem::size_of::<$typ>())];
+        $this.copy_to_slice(&mut buf[..($len_to_read)]);
        return $typ::from_le_bytes(buf);
    }};
    (be => $this:ident, $typ:tt, $len_to_read:expr) => {{
-        const SIZE: usize = core::mem::size_of::<$typ>();
+        debug_assert!(mem::size_of::<$typ>() >= $len_to_read);

-        let slice_at = match SIZE.checked_sub($len_to_read) {
-            Some(slice_at) => slice_at,
-            None => panic_does_not_fit(SIZE, $len_to_read),
-        };
-
-        let mut buf = [0; SIZE];
-        $this.copy_to_slice(&mut buf[slice_at..]);
+        let mut buf = [0; (mem::size_of::<$typ>())];
+        $this.copy_to_slice(&mut buf[mem::size_of::<$typ>() - ($len_to_read)..]);
        return $typ::from_be_bytes(buf);
    }};
 }

-// https://en.wikipedia.org/wiki/Sign_extension
-fn sign_extend(val: u64, nbytes: usize) -> i64 {
-    let shift = (8 - nbytes) * 8;
-    (val << shift) as i64 >> shift
-}
-
 /// Read bytes from a buffer.
 ///
 /// A buffer stores bytes in memory such that read operations are infallible.
@@ -147,11 +124,9 @@ pub trait Buf {
    ///
    /// # Implementer notes
    ///
-    /// This function should never panic. `chunk()` should return an empty
-    /// slice **if and only if** `remaining()` returns 0. In other words,
-    /// `chunk()` returning an empty slice implies that `remaining()` will
-    /// return 0 and `remaining()` returning 0 implies that `chunk()` will
-    /// return an empty slice.
+    /// This function should never panic. Once the end of the buffer is reached,
+    /// i.e., `Buf::remaining` returns 0, calls to `chunk()` should return an
+    /// empty slice.
    // The `chunk` method was previously called `bytes`. This alias makes the rename
    // more easily discoverable.
    #[cfg_attr(docsrs, doc(alias = "bytes"))]
@@ -185,7 +160,6 @@ pub trait Buf {
    ///
    /// [`writev`]: http://man7.org/linux/man-pages/man2/readv.2.html
    #[cfg(feature = "std")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
    fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
        if dst.is_empty() {
            return 0;
@@ -272,18 +246,23 @@ pub trait Buf {
    ///
    /// # Panics
    ///
-    /// This function panics if `self.remaining() < dst.len()`.
-    fn copy_to_slice(&mut self, mut dst: &mut [u8]) {
-        if self.remaining() < dst.len() {
-            panic_advance(dst.len(), self.remaining());
-        }
+    /// This function panics if `self.remaining() < dst.len()`
+    fn copy_to_slice(&mut self, dst: &mut [u8]) {
+        let mut off = 0;

-        while !dst.is_empty() {
-            let src = self.chunk();
-            let cnt = usize::min(src.len(), dst.len());
+        assert!(self.remaining() >= dst.len());

-            dst[..cnt].copy_from_slice(&src[..cnt]);
-            dst = &mut dst[cnt..];
+        while off < dst.len() {
+            let cnt;
+
+            unsafe {
+                let src = self.chunk();
+                cnt = cmp::min(src.len(), dst.len() - off);
+
+                ptr::copy_nonoverlapping(src.as_ptr(), dst[off..].as_mut_ptr(), cnt);
+
+                off += cnt;
+            }

            self.advance(cnt);
        }
@@ -306,9 +285,7 @@ pub trait Buf {
    ///
    /// This function panics if there is no more remaining data in `self`.
    fn get_u8(&mut self) -> u8 {
-        if self.remaining() < 1 {
-            panic_advance(1, 0);
-        }
+        assert!(self.remaining() >= 1);
        let ret = self.chunk()[0];
        self.advance(1);
        ret
@@ -331,9 +308,7 @@ pub trait Buf {
    ///
    /// This function panics if there is no more remaining data in `self`.
    fn get_i8(&mut self) -> i8 {
-        if self.remaining() < 1 {
-            panic_advance(1, 0);
-        }
+        assert!(self.remaining() >= 1);
        let ret = self.chunk()[0] as i8;
        self.advance(1);
        ret
@@ -379,29 +354,6 @@ pub trait Buf {
        buf_get_impl!(self, u16::from_le_bytes);
    }

-    /// Gets an unsigned 16 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09 hello",
-    ///     false => b"\x09\x08 hello",
-    /// };
-    /// assert_eq!(0x0809, buf.get_u16_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u16_ne(&mut self) -> u16 {
-        buf_get_impl!(self, u16::from_ne_bytes);
-    }
-
    /// Gets a signed 16 bit integer from `self` in big-endian byte order.
    ///
    /// The current position is advanced by 2.
@@ -442,29 +394,6 @@ pub trait Buf {
        buf_get_impl!(self, i16::from_le_bytes);
    }

-    /// Gets a signed 16 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09 hello",
-    ///     false => b"\x09\x08 hello",
-    /// };
-    /// assert_eq!(0x0809, buf.get_i16_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i16_ne(&mut self) -> i16 {
-        buf_get_impl!(self, i16::from_ne_bytes);
-    }
-
    /// Gets an unsigned 32 bit integer from `self` in the big-endian byte order.
    ///
    /// The current position is advanced by 4.
@@ -505,29 +434,6 @@ pub trait Buf {
        buf_get_impl!(self, u32::from_le_bytes);
    }

-    /// Gets an unsigned 32 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09\xA0\xA1 hello",
-    ///     false => b"\xA1\xA0\x09\x08 hello",
-    /// };
-    /// assert_eq!(0x0809A0A1, buf.get_u32_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u32_ne(&mut self) -> u32 {
-        buf_get_impl!(self, u32::from_ne_bytes);
-    }
-
    /// Gets a signed 32 bit integer from `self` in big-endian byte order.
    ///
    /// The current position is advanced by 4.
@@ -568,29 +474,6 @@ pub trait Buf {
        buf_get_impl!(self, i32::from_le_bytes);
    }

-    /// Gets a signed 32 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09\xA0\xA1 hello",
-    ///     false => b"\xA1\xA0\x09\x08 hello",
-    /// };
-    /// assert_eq!(0x0809A0A1, buf.get_i32_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i32_ne(&mut self) -> i32 {
-        buf_get_impl!(self, i32::from_ne_bytes);
-    }
-
    /// Gets an unsigned 64 bit integer from `self` in big-endian byte order.
    ///
    /// The current position is advanced by 8.
@@ -631,29 +514,6 @@ pub trait Buf {
        buf_get_impl!(self, u64::from_le_bytes);
    }

-    /// Gets an unsigned 64 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
-    ///     false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x0102030405060708, buf.get_u64_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u64_ne(&mut self) -> u64 {
-        buf_get_impl!(self, u64::from_ne_bytes);
-    }
-
    /// Gets a signed 64 bit integer from `self` in big-endian byte order.
    ///
    /// The current position is advanced by 8.
@@ -694,29 +554,6 @@ pub trait Buf {
        buf_get_impl!(self, i64::from_le_bytes);
    }

-    /// Gets a signed 64 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
-    ///     false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x0102030405060708, buf.get_i64_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i64_ne(&mut self) -> i64 {
-        buf_get_impl!(self, i64::from_ne_bytes);
-    }
-
    /// Gets an unsigned 128 bit integer from `self` in big-endian byte order.
    ///
    /// The current position is advanced by 16.
@@ -757,29 +594,6 @@ pub trait Buf {
        buf_get_impl!(self, u128::from_le_bytes);
    }

-    /// Gets an unsigned 128 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
-    ///     false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x01020304050607080910111213141516, buf.get_u128_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u128_ne(&mut self) -> u128 {
-        buf_get_impl!(self, u128::from_ne_bytes);
-    }
-
    /// Gets a signed 128 bit integer from `self` in big-endian byte order.
    ///
    /// The current position is advanced by 16.
@@ -820,29 +634,6 @@ pub trait Buf {
        buf_get_impl!(self, i128::from_le_bytes);
    }

-    /// Gets a signed 128 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
-    ///     false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x01020304050607080910111213141516, buf.get_i128_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i128_ne(&mut self) -> i128 {
-        buf_get_impl!(self, i128::from_ne_bytes);
-    }
-
    /// Gets an unsigned n-byte integer from `self` in big-endian byte order.
    ///
    /// The current position is advanced by `nbytes`.
@@ -883,34 +674,6 @@ pub trait Buf {
        buf_get_impl!(le => self, u64, nbytes);
    }

-    /// Gets an unsigned n-byte integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03 hello",
-    ///     false => b"\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x010203, buf.get_uint_ne(3));
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`, or
-    /// if `nbytes` is greater than 8.
-    fn get_uint_ne(&mut self, nbytes: usize) -> u64 {
-        if cfg!(target_endian = "big") {
-            self.get_uint(nbytes)
-        } else {
-            self.get_uint_le(nbytes)
-        }
-    }
-
    /// Gets a signed n-byte integer from `self` in big-endian byte order.
    ///
    /// The current position is advanced by `nbytes`.
@@ -926,10 +689,9 @@ pub trait Buf {
    ///
    /// # Panics
    ///
-    /// This function panics if there is not enough remaining data in `self`, or
-    /// if `nbytes` is greater than 8.
+    /// This function panics if there is not enough remaining data in `self`.
    fn get_int(&mut self, nbytes: usize) -> i64 {
-        sign_extend(self.get_uint(nbytes), nbytes)
+        buf_get_impl!(be => self, i64, nbytes);
    }

    /// Gets a signed n-byte integer from `self` in little-endian byte order.
@@ -947,38 +709,9 @@ pub trait Buf {
    ///
    /// # Panics
    ///
-    /// This function panics if there is not enough remaining data in `self`, or
-    /// if `nbytes` is greater than 8.
+    /// This function panics if there is not enough remaining data in `self`.
    fn get_int_le(&mut self, nbytes: usize) -> i64 {
-        sign_extend(self.get_uint_le(nbytes), nbytes)
-    }
-
-    /// Gets a signed n-byte integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03 hello",
-    ///     false => b"\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x010203, buf.get_int_ne(3));
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`, or
-    /// if `nbytes` is greater than 8.
-    fn get_int_ne(&mut self, nbytes: usize) -> i64 {
-        if cfg!(target_endian = "big") {
-            self.get_int(nbytes)
-        } else {
-            self.get_int_le(nbytes)
-        }
+        buf_get_impl!(le => self, i64, nbytes);
    }

    /// Gets an IEEE754 single-precision (4 bytes) floating point number from
@@ -999,7 +732,7 @@ pub trait Buf {
    ///
    /// This function panics if there is not enough remaining data in `self`.
    fn get_f32(&mut self) -> f32 {
-        f32::from_bits(self.get_u32())
+        f32::from_bits(Self::get_u32(self))
    }

    /// Gets an IEEE754 single-precision (4 bytes) floating point number from
@@ -1020,31 +753,7 @@ pub trait Buf {
    ///
    /// This function panics if there is not enough remaining data in `self`.
    fn get_f32_le(&mut self) -> f32 {
-        f32::from_bits(self.get_u32_le())
-    }
-
-    /// Gets an IEEE754 single-precision (4 bytes) floating point number from
-    /// `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x3F\x99\x99\x9A hello",
-    ///     false => b"\x9A\x99\x99\x3F hello",
-    /// };
-    /// assert_eq!(1.2f32, buf.get_f32_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_f32_ne(&mut self) -> f32 {
-        f32::from_bits(self.get_u32_ne())
+        f32::from_bits(Self::get_u32_le(self))
    }

    /// Gets an IEEE754 double-precision (8 bytes) floating point number from
@@ -1065,7 +774,7 @@ pub trait Buf {
    ///
    /// This function panics if there is not enough remaining data in `self`.
    fn get_f64(&mut self) -> f64 {
-        f64::from_bits(self.get_u64())
+        f64::from_bits(Self::get_u64(self))
    }

    /// Gets an IEEE754 double-precision (8 bytes) floating point number from
@@ -1086,31 +795,7 @@ pub trait Buf {
    ///
    /// This function panics if there is not enough remaining data in `self`.
    fn get_f64_le(&mut self) -> f64 {
-        f64::from_bits(self.get_u64_le())
-    }
-
-    /// Gets an IEEE754 double-precision (8 bytes) floating point number from
-    /// `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello",
-    ///     false => b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello",
-    /// };
-    /// assert_eq!(1.2f64, buf.get_f64_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_f64_ne(&mut self) -> f64 {
-        f64::from_bits(self.get_u64_ne())
+        f64::from_bits(Self::get_u64_le(self))
    }

    /// Consumes `len` bytes inside self and returns new instance of `Bytes`
@@ -1128,16 +813,10 @@ pub trait Buf {
    /// let bytes = (&b"hello world"[..]).copy_to_bytes(5);
    /// assert_eq!(&bytes[..], &b"hello"[..]);
    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if `len > self.remaining()`.
    fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
        use super::BufMut;

-        if self.remaining() < len {
-            panic_advance(len, self.remaining());
-        }
+        assert!(len <= self.remaining(), "`len` greater than remaining");

        let mut ret = crate::BytesMut::with_capacity(len);
        ret.put(self.take(len));
@@ -1218,7 +897,6 @@ pub trait Buf {
    /// assert_eq!(&dst[..11], &b"hello world"[..]);
    /// ```
    #[cfg(feature = "std")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
    fn reader(self) -> Reader<Self>
    where
        Self: Sized,
@@ -1229,168 +907,103 @@ pub trait Buf {

 macro_rules! deref_forward_buf {
    () => {
-        #[inline]
        fn remaining(&self) -> usize {
            (**self).remaining()
        }

-        #[inline]
        fn chunk(&self) -> &[u8] {
            (**self).chunk()
        }

        #[cfg(feature = "std")]
-        #[inline]
        fn chunks_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize {
            (**self).chunks_vectored(dst)
        }

-        #[inline]
        fn advance(&mut self, cnt: usize) {
            (**self).advance(cnt)
        }

-        #[inline]
        fn has_remaining(&self) -> bool {
            (**self).has_remaining()
        }

-        #[inline]
        fn copy_to_slice(&mut self, dst: &mut [u8]) {
            (**self).copy_to_slice(dst)
        }

-        #[inline]
        fn get_u8(&mut self) -> u8 {
            (**self).get_u8()
        }

-        #[inline]
        fn get_i8(&mut self) -> i8 {
            (**self).get_i8()
        }

-        #[inline]
        fn get_u16(&mut self) -> u16 {
            (**self).get_u16()
        }

-        #[inline]
        fn get_u16_le(&mut self) -> u16 {
            (**self).get_u16_le()
        }

-        #[inline]
-        fn get_u16_ne(&mut self) -> u16 {
-            (**self).get_u16_ne()
-        }
-
-        #[inline]
        fn get_i16(&mut self) -> i16 {
            (**self).get_i16()
        }

-        #[inline]
        fn get_i16_le(&mut self) -> i16 {
            (**self).get_i16_le()
        }

-        #[inline]
-        fn get_i16_ne(&mut self) -> i16 {
-            (**self).get_i16_ne()
-        }
-
-        #[inline]
        fn get_u32(&mut self) -> u32 {
            (**self).get_u32()
        }

-        #[inline]
        fn get_u32_le(&mut self) -> u32 {
            (**self).get_u32_le()
        }

-        #[inline]
-        fn get_u32_ne(&mut self) -> u32 {
-            (**self).get_u32_ne()
-        }
-
-        #[inline]
        fn get_i32(&mut self) -> i32 {
            (**self).get_i32()
        }

-        #[inline]
        fn get_i32_le(&mut self) -> i32 {
            (**self).get_i32_le()
        }

-        #[inline]
-        fn get_i32_ne(&mut self) -> i32 {
-            (**self).get_i32_ne()
-        }
-
-        #[inline]
        fn get_u64(&mut self) -> u64 {
            (**self).get_u64()
        }

-        #[inline]
        fn get_u64_le(&mut self) -> u64 {
            (**self).get_u64_le()
        }

-        #[inline]
-        fn get_u64_ne(&mut self) -> u64 {
-            (**self).get_u64_ne()
-        }
-
-        #[inline]
        fn get_i64(&mut self) -> i64 {
            (**self).get_i64()
        }

-        #[inline]
        fn get_i64_le(&mut self) -> i64 {
            (**self).get_i64_le()
        }

-        #[inline]
-        fn get_i64_ne(&mut self) -> i64 {
-            (**self).get_i64_ne()
-        }
-
-        #[inline]
        fn get_uint(&mut self, nbytes: usize) -> u64 {
            (**self).get_uint(nbytes)
        }

-        #[inline]
        fn get_uint_le(&mut self, nbytes: usize) -> u64 {
            (**self).get_uint_le(nbytes)
        }

-        #[inline]
-        fn get_uint_ne(&mut self, nbytes: usize) -> u64 {
-            (**self).get_uint_ne(nbytes)
-        }
-
-        #[inline]
        fn get_int(&mut self, nbytes: usize) -> i64 {
            (**self).get_int(nbytes)
        }

-        #[inline]
        fn get_int_le(&mut self, nbytes: usize) -> i64 {
            (**self).get_int_le(nbytes)
        }

-        #[inline]
-        fn get_int_ne(&mut self, nbytes: usize) -> i64 {
-            (**self).get_int_ne(nbytes)
-        }
-
-        #[inline]
        fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
            (**self).copy_to_bytes(len)
        }
@@ -1418,52 +1031,41 @@ impl Buf for &[u8] {

    #[inline]
    fn advance(&mut self, cnt: usize) {
-        if self.len() < cnt {
-            panic_advance(cnt, self.len());
-        }
-
        *self = &self[cnt..];
    }
-
-    #[inline]
-    fn copy_to_slice(&mut self, dst: &mut [u8]) {
-        if self.len() < dst.len() {
-            panic_advance(dst.len(), self.len());
-        }
-
-        dst.copy_from_slice(&self[..dst.len()]);
-        self.advance(dst.len());
-    }
 }

 #[cfg(feature = "std")]
 impl<T: AsRef<[u8]>> Buf for std::io::Cursor<T> {
-    #[inline]
    fn remaining(&self) -> usize {
-        saturating_sub_usize_u64(self.get_ref().as_ref().len(), self.position())
-    }
-
-    #[inline]
-    fn chunk(&self) -> &[u8] {
-        let slice = self.get_ref().as_ref();
-        let pos = min_u64_usize(self.position(), slice.len());
-        &slice[pos..]
-    }
-
-    #[inline]
-    fn advance(&mut self, cnt: usize) {
        let len = self.get_ref().as_ref().len();
        let pos = self.position();

-        // We intentionally allow `cnt == 0` here even if `pos > len`.
-        let max_cnt = saturating_sub_usize_u64(len, pos);
-        if cnt > max_cnt {
-            panic_advance(cnt, max_cnt);
+        if pos >= len as u64 {
+            return 0;
        }

-        // This will not overflow because either `cnt == 0` or the sum is not
-        // greater than `len`.
-        self.set_position(pos + cnt as u64);
+        len - pos as usize
+    }
+
+    fn chunk(&self) -> &[u8] {
+        let len = self.get_ref().as_ref().len();
+        let pos = self.position();
+
+        if pos >= len as u64 {
+            return &[];
+        }
+
+        &self.get_ref().as_ref()[pos as usize..]
+    }
+
+    fn advance(&mut self, cnt: usize) {
+        let pos = (self.position() as usize)
+            .checked_add(cnt)
+            .expect("overflow");
+
+        assert!(pos <= self.get_ref().as_ref().len());
+        self.set_position(pos as u64);
    }
 }

@@ -25,7 +25,9 @@ use std::io::IoSlice;
 /// assert_eq!(full[..], b"hello world"[..]);
 /// ```
 ///
-/// [`Buf::chain`]: Buf::chain
+/// [`Buf::chain`]: trait.Buf.html#method.chain
+/// [`Buf`]: trait.Buf.html
+/// [`BufMut`]: trait.BufMut.html
 #[derive(Debug)]
 pub struct Chain<T, U> {
    a: T,
@@ -133,7 +135,7 @@ where
    U: Buf,
 {
    fn remaining(&self) -> usize {
-        self.a.remaining().saturating_add(self.b.remaining())
+        self.a.remaining().checked_add(self.b.remaining()).unwrap()
    }

    fn chunk(&self) -> &[u8] {
@@ -196,7 +198,8 @@ where
    fn remaining_mut(&self) -> usize {
        self.a
            .remaining_mut()
-            .saturating_add(self.b.remaining_mut())
+            .checked_add(self.b.remaining_mut())
+            .unwrap()
    }

    fn chunk_mut(&mut self) -> &mut UninitSlice {
@@ -2,6 +2,8 @@ use crate::Buf;

 /// Iterator over the bytes contained by the buffer.
 ///
+/// This struct is created by the [`iter`] method on [`Buf`].
+///
 /// # Examples
 ///
 /// Basic usage:
@@ -17,6 +19,9 @@ use crate::Buf;
 /// assert_eq!(iter.next(), Some(b'c'));
 /// assert_eq!(iter.next(), None);
 /// ```
+///
+/// [`iter`]: trait.Buf.html#method.iter
+/// [`Buf`]: trait.Buf.html
 #[derive(Debug)]
 pub struct IntoIter<T> {
    inner: T,
@@ -38,7 +43,7 @@ impl<T> IntoIter<T> {
    /// assert_eq!(iter.next(), Some(b'c'));
    /// assert_eq!(iter.next(), None);
    /// ```
-    pub fn new(inner: T) -> IntoIter<T> {
+    pub(crate) fn new(inner: T) -> IntoIter<T> {
        IntoIter { inner }
    }

@@ -13,6 +13,8 @@
 //! See [`Buf`] and [`BufMut`] for more details.
 //!
 //! [rope]: https://en.wikipedia.org/wiki/Rope_(data_structure)
+//! [`Buf`]: trait.Buf.html
+//! [`BufMut`]: trait.BufMut.html

 mod buf_impl;
 mod buf_mut;
@@ -5,7 +5,7 @@ use std::{cmp, io};
 /// A `Buf` adapter which implements `io::Read` for the inner value.
 ///
 /// This struct is generally created by calling `reader()` on `Buf`. See
-/// documentation of [`reader()`](Buf::reader) for more
+/// documentation of [`reader()`](trait.Buf.html#method.reader) for more
 /// details.
 #[derive(Debug)]
 pub struct Reader<B> {
@@ -5,7 +5,7 @@ use core::cmp;
 /// A `Buf` adapter which limits the bytes read from an underlying buffer.
 ///
 /// This struct is generally created by calling `take()` on `Buf`. See
-/// documentation of [`take()`](Buf::take) for more details.
+/// documentation of [`take()`](trait.Buf.html#method.take) for more details.
 #[derive(Debug)]
 pub struct Take<T> {
    inner: T,
@@ -22,44 +22,6 @@ use core::ops::{
 pub struct UninitSlice([MaybeUninit<u8>]);

 impl UninitSlice {
-    /// Creates a `&mut UninitSlice` wrapping a slice of initialised memory.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::buf::UninitSlice;
-    ///
-    /// let mut buffer = [0u8; 64];
-    /// let slice = UninitSlice::new(&mut buffer[..]);
-    /// ```
-    #[inline]
-    pub fn new(slice: &mut [u8]) -> &mut UninitSlice {
-        unsafe { &mut *(slice as *mut [u8] as *mut [MaybeUninit<u8>] as *mut UninitSlice) }
-    }
-
-    /// Creates a `&mut UninitSlice` wrapping a slice of uninitialised memory.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::buf::UninitSlice;
-    /// use core::mem::MaybeUninit;
-    ///
-    /// let mut buffer = [MaybeUninit::uninit(); 64];
-    /// let slice = UninitSlice::uninit(&mut buffer[..]);
-    ///
-    /// let mut vec = Vec::with_capacity(1024);
-    /// let spare: &mut UninitSlice = vec.spare_capacity_mut().into();
-    /// ```
-    #[inline]
-    pub fn uninit(slice: &mut [MaybeUninit<u8>]) -> &mut UninitSlice {
-        unsafe { &mut *(slice as *mut [MaybeUninit<u8>] as *mut UninitSlice) }
-    }
-
-    fn uninit_ref(slice: &[MaybeUninit<u8>]) -> &UninitSlice {
-        unsafe { &*(slice as *const [MaybeUninit<u8>] as *const UninitSlice) }
-    }
-
    /// Create a `&mut UninitSlice` from a pointer and a length.
    ///
    /// # Safety
@@ -82,7 +44,7 @@ impl UninitSlice {
    pub unsafe fn from_raw_parts_mut<'a>(ptr: *mut u8, len: usize) -> &'a mut UninitSlice {
        let maybe_init: &mut [MaybeUninit<u8>] =
            core::slice::from_raw_parts_mut(ptr as *mut _, len);
-        Self::uninit(maybe_init)
+        &mut *(maybe_init as *mut [MaybeUninit<u8>] as *mut UninitSlice)
    }

    /// Write a single byte at the specified offset.
@@ -110,7 +72,7 @@ impl UninitSlice {
        unsafe { self[index..].as_mut_ptr().write(byte) }
    }

-    /// Copies bytes from `src` into `self`.
+    /// Copies bytes  from `src` into `self`.
    ///
    /// The length of `src` must be the same as `self`.
    ///
@@ -162,32 +124,6 @@ impl UninitSlice {
        self.0.as_mut_ptr() as *mut _
    }

-    /// Return a `&mut [MaybeUninit<u8>]` to this slice's buffer.
-    ///
-    /// # Safety
-    ///
-    /// The caller **must not** read from the referenced memory and **must not** write
-    /// **uninitialized** bytes to the slice either. This is because `BufMut` implementation
-    /// that created the `UninitSlice` knows which parts are initialized. Writing uninitialized
-    /// bytes to the slice may cause the `BufMut` to read those bytes and trigger undefined
-    /// behavior.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut data = [0, 1, 2];
-    /// let mut slice = &mut data[..];
-    /// unsafe {
-    ///     let uninit_slice = BufMut::chunk_mut(&mut slice).as_uninit_slice_mut();
-    /// };
-    /// ```
-    #[inline]
-    pub unsafe fn as_uninit_slice_mut(&mut self) -> &mut [MaybeUninit<u8>] {
-        &mut self.0
-    }
-
    /// Returns the number of bytes in the slice.
    ///
    /// # Examples
@@ -213,18 +149,6 @@ impl fmt::Debug for UninitSlice {
    }
 }

-impl<'a> From<&'a mut [u8]> for &'a mut UninitSlice {
-    fn from(slice: &'a mut [u8]) -> Self {
-        UninitSlice::new(slice)
-    }
-}
-
-impl<'a> From<&'a mut [MaybeUninit<u8>]> for &'a mut UninitSlice {
-    fn from(slice: &'a mut [MaybeUninit<u8>]) -> Self {
-        UninitSlice::uninit(slice)
-    }
-}
-
 macro_rules! impl_index {
    ($($t:ty),*) => {
        $(
@@ -233,14 +157,16 @@ macro_rules! impl_index {

                #[inline]
                fn index(&self, index: $t) -> &UninitSlice {
-                    UninitSlice::uninit_ref(&self.0[index])
+                    let maybe_uninit: &[MaybeUninit<u8>] = &self.0[index];
+                    unsafe { &*(maybe_uninit as *const [MaybeUninit<u8>] as *const UninitSlice) }
                }
            }

            impl IndexMut<$t> for UninitSlice {
                #[inline]
                fn index_mut(&mut self, index: $t) -> &mut UninitSlice {
-                    UninitSlice::uninit(&mut self.0[index])
+                    let maybe_uninit: &mut [MaybeUninit<u8>] = &mut self.0[index];
+                    unsafe { &mut *(maybe_uninit as *mut [MaybeUninit<u8>] as *mut UninitSlice) }
                }
            }
        )*
@@ -5,7 +5,7 @@ use std::{cmp, io};
 /// A `BufMut` adapter which implements `io::Write` for the inner value.
 ///
 /// This struct is generally created by calling `writer()` on `BufMut`. See
-/// documentation of [`writer()`](BufMut::writer) for more
+/// documentation of [`writer()`](trait.BufMut.html#method.writer) for more
 /// details.
 #[derive(Debug)]
 pub struct Writer<B> {
@@ -1,21 +1,14 @@
 use core::iter::FromIterator;
-use core::mem::{self, ManuallyDrop};
 use core::ops::{Deref, RangeBounds};
-use core::{cmp, fmt, hash, ptr, slice, usize};
+use core::{cmp, fmt, hash, mem, ptr, slice, usize};

-use alloc::{
-    alloc::{dealloc, Layout},
-    borrow::Borrow,
-    boxed::Box,
-    string::String,
-    vec::Vec,
-};
+use alloc::{borrow::Borrow, boxed::Box, string::String, vec::Vec};

 use crate::buf::IntoIter;
 #[allow(unused)]
 use crate::loom::sync::atomic::AtomicMut;
-use crate::loom::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
-use crate::{offset_from, Buf, BytesMut};
+use crate::loom::sync::atomic::{self, AtomicPtr, AtomicUsize, Ordering};
+use crate::Buf;

 /// A cheaply cloneable and sliceable chunk of contiguous memory.
 ///
@@ -33,7 +26,7 @@ use crate::{offset_from, Buf, BytesMut};
 /// All `Bytes` implementations must fulfill the following requirements:
 /// - They are cheaply cloneable and thereby shareable between an unlimited amount
 ///   of components, for example by modifying a reference count.
-/// - Instances can be sliced to refer to a subset of the original buffer.
+/// - Instances can be sliced to refer to a subset of the the original buffer.
 ///
 /// ```
 /// use bytes::Bytes;
@@ -62,17 +55,17 @@ use crate::{offset_from, Buf, BytesMut};
 /// # Sharing
 ///
 /// `Bytes` contains a vtable, which allows implementations of `Bytes` to define
-/// how sharing/cloning is implemented in detail.
+/// how sharing/cloneing is implemented in detail.
 /// When `Bytes::clone()` is called, `Bytes` will call the vtable function for
-/// cloning the backing storage in order to share it behind multiple `Bytes`
-/// instances.
+/// cloning the backing storage in order to share it behind between multiple
+/// `Bytes` instances.
 ///
 /// For `Bytes` implementations which refer to constant memory (e.g. created
 /// via `Bytes::from_static()`) the cloning implementation will be a no-op.
 ///
 /// For `Bytes` implementations which point to a reference counted shared storage
 /// (e.g. an `Arc<[u8]>`), sharing will be implemented by increasing the
-/// reference count.
+/// the reference count.
 ///
 /// Due to this mechanism, multiple `Bytes` instances may point to the same
 /// shared memory region.
@@ -85,18 +78,18 @@ use crate::{offset_from, Buf, BytesMut};
 ///
 /// ```text
 ///
-///    Arc ptrs                   ┌─────────┐
-///    ________________________ / │ Bytes 2 │
-///   /                           └─────────┘
-///  /          ┌───────────┐     |         |
-/// |_________/ │  Bytes 1  │     |         |
-/// |           └───────────┘     |         |
+///    Arc ptrs                   +---------+
+///    ________________________ / | Bytes 2 |
+///   /                           +---------+
+///  /          +-----------+     |         |
+/// |_________/ |  Bytes 1  |     |         |
+/// |           +-----------+     |         |
 /// |           |           | ___/ data     | tail
 /// |      data |      tail |/              |
 /// v           v           v               v
-/// ┌─────┬─────┬───────────┬───────────────┬─────┐
-/// │ Arc │     │           │               │     │
-/// └─────┴─────┴───────────┴───────────────┴─────┘
+/// +-----+---------------------------------+-----+
+/// | Arc |     |           |               |     |
+/// +-----+---------------------------------+-----+
 /// ```
 pub struct Bytes {
    ptr: *const u8,
@@ -110,13 +103,6 @@ pub(crate) struct Vtable {
    /// fn(data, ptr, len)
    pub clone: unsafe fn(&AtomicPtr<()>, *const u8, usize) -> Bytes,
    /// fn(data, ptr, len)
-    ///
-    /// takes `Bytes` to value
-    pub to_vec: unsafe fn(&AtomicPtr<()>, *const u8, usize) -> Vec<u8>,
-    pub to_mut: unsafe fn(&AtomicPtr<()>, *const u8, usize) -> BytesMut,
-    /// fn(data)
-    pub is_unique: unsafe fn(&AtomicPtr<()>) -> bool,
-    /// fn(data, ptr, len)
    pub drop: unsafe fn(&mut AtomicPtr<()>, *const u8, usize),
 }

@@ -135,16 +121,15 @@ impl Bytes {
    /// ```
    #[inline]
    #[cfg(not(all(loom, test)))]
-    pub const fn new() -> Self {
+    pub const fn new() -> Bytes {
        // Make it a named const to work around
        // "unsizing casts are not allowed in const fn"
        const EMPTY: &[u8] = &[];
        Bytes::from_static(EMPTY)
    }

-    /// Creates a new empty `Bytes`.
    #[cfg(all(loom, test))]
-    pub fn new() -> Self {
+    pub fn new() -> Bytes {
        const EMPTY: &[u8] = &[];
        Bytes::from_static(EMPTY)
    }
@@ -164,7 +149,7 @@ impl Bytes {
    /// ```
    #[inline]
    #[cfg(not(all(loom, test)))]
-    pub const fn from_static(bytes: &'static [u8]) -> Self {
+    pub const fn from_static(bytes: &'static [u8]) -> Bytes {
        Bytes {
            ptr: bytes.as_ptr(),
            len: bytes.len(),
@@ -173,9 +158,8 @@ impl Bytes {
        }
    }

-    /// Creates a new `Bytes` from a static slice.
    #[cfg(all(loom, test))]
-    pub fn from_static(bytes: &'static [u8]) -> Self {
+    pub fn from_static(bytes: &'static [u8]) -> Bytes {
        Bytes {
            ptr: bytes.as_ptr(),
            len: bytes.len(),
@@ -184,22 +168,6 @@ impl Bytes {
        }
    }

-    /// Creates a new `Bytes` with length zero and the given pointer as the address.
-    fn new_empty_with_ptr(ptr: *const u8) -> Self {
-        debug_assert!(!ptr.is_null());
-
-        // Detach this pointer's provenance from whichever allocation it came from, and reattach it
-        // to the provenance of the fake ZST [u8;0] at the same address.
-        let ptr = without_provenance(ptr as usize);
-
-        Bytes {
-            ptr,
-            len: 0,
-            data: AtomicPtr::new(ptr::null_mut()),
-            vtable: &STATIC_VTABLE,
-        }
-    }
-
    /// Returns the number of bytes contained in this `Bytes`.
    ///
    /// # Examples
@@ -211,7 +179,7 @@ impl Bytes {
    /// assert_eq!(b.len(), 5);
    /// ```
    #[inline]
-    pub const fn len(&self) -> usize {
+    pub fn len(&self) -> usize {
        self.len
    }

@@ -226,32 +194,10 @@ impl Bytes {
    /// assert!(b.is_empty());
    /// ```
    #[inline]
-    pub const fn is_empty(&self) -> bool {
+    pub fn is_empty(&self) -> bool {
        self.len == 0
    }

-    /// Returns true if this is the only reference to the data.
-    ///
-    /// Always returns false if the data is backed by a static slice.
-    ///
-    /// The result of this method may be invalidated immediately if another
-    /// thread clones this value while this is being called. Ensure you have
-    /// unique access to this value (`&mut Bytes`) first if you need to be
-    /// certain the result is valid (i.e. for safety reasons)
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Bytes;
-    ///
-    /// let a = Bytes::from(vec![1, 2, 3]);
-    /// assert!(a.is_unique());
-    /// let b = a.clone();
-    /// assert!(!a.is_unique());
-    /// ```
-    pub fn is_unique(&self) -> bool {
-        unsafe { (self.vtable.is_unique)(&self.data) }
-    }
-
    /// Creates `Bytes` instance from slice, by copying it.
    pub fn copy_from_slice(data: &[u8]) -> Self {
        data.to_vec().into()
@@ -279,14 +225,14 @@ impl Bytes {
    ///
    /// Requires that `begin <= end` and `end <= self.len()`, otherwise slicing
    /// will panic.
-    pub fn slice(&self, range: impl RangeBounds<usize>) -> Self {
+    pub fn slice(&self, range: impl RangeBounds<usize>) -> Bytes {
        use core::ops::Bound;

        let len = self.len();

        let begin = match range.start_bound() {
            Bound::Included(&n) => n,
-            Bound::Excluded(&n) => n.checked_add(1).expect("out of range"),
+            Bound::Excluded(&n) => n + 1,
            Bound::Unbounded => 0,
        };

@@ -316,7 +262,7 @@ impl Bytes {
        let mut ret = self.clone();

        ret.len = end - begin;
-        ret.ptr = unsafe { ret.ptr.add(begin) };
+        ret.ptr = unsafe { ret.ptr.offset(begin as isize) };

        ret
    }
@@ -346,7 +292,7 @@ impl Bytes {
    ///
    /// Requires that the given `sub` slice is in fact contained within the
    /// `Bytes` buffer; otherwise this function will panic.
-    pub fn slice_ref(&self, subset: &[u8]) -> Self {
+    pub fn slice_ref(&self, subset: &[u8]) -> Bytes {
        // Empty slice and empty Bytes may have their pointers reset
        // so explicitly allow empty slice to be a subslice of any slice.
        if subset.is_empty() {
@@ -362,15 +308,15 @@ impl Bytes {
        assert!(
            sub_p >= bytes_p,
            "subset pointer ({:p}) is smaller than self pointer ({:p})",
-            subset.as_ptr(),
-            self.as_ptr(),
+            sub_p as *const u8,
+            bytes_p as *const u8,
        );
        assert!(
            sub_p + sub_len <= bytes_p + bytes_len,
            "subset is out of bounds: self = ({:p}, {}), subset = ({:p}, {})",
-            self.as_ptr(),
+            bytes_p as *const u8,
            bytes_len,
-            subset.as_ptr(),
+            sub_p as *const u8,
            sub_len,
        );

@@ -382,9 +328,7 @@ impl Bytes {
    /// Splits the bytes into two at the given index.
    ///
    /// Afterwards `self` contains elements `[0, at)`, and the returned `Bytes`
-    /// contains elements `[at, len)`. It's guaranteed that the memory does not
-    /// move, that is, the address of `self` does not change, and the address of
-    /// the returned slice is `at` bytes after that.
+    /// contains elements `[at, len)`.
    ///
    /// This is an `O(1)` operation that just increases the reference count and
    /// sets a few indices.
@@ -405,15 +349,7 @@ impl Bytes {
    ///
    /// Panics if `at > len`.
    #[must_use = "consider Bytes::truncate if you don't need the other half"]
-    pub fn split_off(&mut self, at: usize) -> Self {
-        if at == self.len() {
-            return Bytes::new_empty_with_ptr(self.ptr.wrapping_add(at));
-        }
-
-        if at == 0 {
-            return mem::replace(self, Bytes::new_empty_with_ptr(self.ptr));
-        }
-
+    pub fn split_off(&mut self, at: usize) -> Bytes {
        assert!(
            at <= self.len(),
            "split_off out of bounds: {:?} <= {:?}",
@@ -421,6 +357,14 @@ impl Bytes {
            self.len(),
        );

+        if at == self.len() {
+            return Bytes::new();
+        }
+
+        if at == 0 {
+            return mem::replace(self, Bytes::new());
+        }
+
        let mut ret = self.clone();

        self.len = at;
@@ -454,16 +398,7 @@ impl Bytes {
    ///
    /// Panics if `at > len`.
    #[must_use = "consider Bytes::advance if you don't need the other half"]
-    pub fn split_to(&mut self, at: usize) -> Self {
-        if at == self.len() {
-            let end_ptr = self.ptr.wrapping_add(at);
-            return mem::replace(self, Bytes::new_empty_with_ptr(end_ptr));
-        }
-
-        if at == 0 {
-            return Bytes::new_empty_with_ptr(self.ptr);
-        }
-
+    pub fn split_to(&mut self, at: usize) -> Bytes {
        assert!(
            at <= self.len(),
            "split_to out of bounds: {:?} <= {:?}",
@@ -471,6 +406,14 @@ impl Bytes {
            self.len(),
        );

+        if at == self.len() {
+            return mem::replace(self, Bytes::new());
+        }
+
+        if at == 0 {
+            return Bytes::new();
+        }
+
        let mut ret = self.clone();

        unsafe { self.inc_start(at) };
@@ -485,7 +428,7 @@ impl Bytes {
    /// If `len` is greater than the buffer's current length, this has no
    /// effect.
    ///
-    /// The [split_off](`Self::split_off()`) method can emulate `truncate`, but this causes the
+    /// The [`split_off`] method can emulate `truncate`, but this causes the
    /// excess bytes to be returned instead of dropped.
    ///
    /// # Examples
@@ -497,6 +440,8 @@ impl Bytes {
    /// buf.truncate(5);
    /// assert_eq!(buf, b"hello"[..]);
    /// ```
+    ///
+    /// [`split_off`]: #method.split_off
    #[inline]
    pub fn truncate(&mut self, len: usize) {
        if len < self.len {
@@ -529,29 +474,6 @@ impl Bytes {
        self.truncate(0);
    }

-    /// Try to convert self into `BytesMut`.
-    ///
-    /// If `self` is unique for the entire original buffer, this will succeed
-    /// and return a `BytesMut` with the contents of `self` without copying.
-    /// If `self` is not unique for the entire original buffer, this will fail
-    /// and return self.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::{Bytes, BytesMut};
-    ///
-    /// let bytes = Bytes::from(b"hello".to_vec());
-    /// assert_eq!(bytes.try_into_mut(), Ok(BytesMut::from(&b"hello"[..])));
-    /// ```
-    pub fn try_into_mut(self) -> Result<BytesMut, Bytes> {
-        if self.is_unique() {
-            Ok(self.into())
-        } else {
-            Err(self)
-        }
-    }
-
    #[inline]
    pub(crate) unsafe fn with_vtable(
        ptr: *const u8,
@@ -579,7 +501,7 @@ impl Bytes {
        // should already be asserted, but debug assert for tests
        debug_assert!(self.len >= by, "internal: inc_start out of bounds");
        self.len -= by;
-        self.ptr = self.ptr.add(by);
+        self.ptr = self.ptr.offset(by as isize);
    }
 }

@@ -626,8 +548,14 @@ impl Buf for Bytes {
        }
    }

-    fn copy_to_bytes(&mut self, len: usize) -> Self {
-        self.split_to(len)
+    fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
+        if len == self.remaining() {
+            core::mem::replace(self, Bytes::new())
+        } else {
+            let ret = self.slice(..len);
+            self.advance(len);
+            ret
+        }
    }
 }

@@ -676,7 +604,7 @@ impl<'a> IntoIterator for &'a Bytes {
    type IntoIter = core::slice::Iter<'a, u8>;

    fn into_iter(self) -> Self::IntoIter {
-        self.as_slice().iter()
+        self.as_slice().into_iter()
    }
 }

@@ -758,7 +686,7 @@ impl PartialOrd<Bytes> for str {

 impl PartialEq<Vec<u8>> for Bytes {
    fn eq(&self, other: &Vec<u8>) -> bool {
-        *self == other[..]
+        *self == &other[..]
    }
 }

@@ -782,7 +710,7 @@ impl PartialOrd<Bytes> for Vec<u8> {

 impl PartialEq<String> for Bytes {
    fn eq(&self, other: &String) -> bool {
-        *self == other[..]
+        *self == &other[..]
    }
 }

@@ -869,36 +797,8 @@ impl From<&'static str> for Bytes {

 impl From<Vec<u8>> for Bytes {
    fn from(vec: Vec<u8>) -> Bytes {
-        let mut vec = ManuallyDrop::new(vec);
-        let ptr = vec.as_mut_ptr();
-        let len = vec.len();
-        let cap = vec.capacity();
-
-        // Avoid an extra allocation if possible.
-        if len == cap {
-            let vec = ManuallyDrop::into_inner(vec);
-            return Bytes::from(vec.into_boxed_slice());
-        }
-
-        let shared = Box::new(Shared {
-            buf: ptr,
-            cap,
-            ref_cnt: AtomicUsize::new(1),
-        });
-
-        let shared = Box::into_raw(shared);
-        // The pointer should be aligned, so this assert should
-        // always succeed.
-        debug_assert!(
-            0 == (shared as usize & KIND_MASK),
-            "internal: Box<Shared> should have an aligned pointer",
-        );
-        Bytes {
-            ptr,
-            len,
-            data: AtomicPtr::new(shared as _),
-            vtable: &SHARED_VTABLE,
-        }
+        let slice = vec.into_boxed_slice();
+        slice.into()
    }
 }

@@ -915,59 +815,30 @@ impl From<Box<[u8]>> for Bytes {
        let ptr = Box::into_raw(slice) as *mut u8;

        if ptr as usize & 0x1 == 0 {
-            let data = ptr_map(ptr, |addr| addr | KIND_VEC);
+            let data = ptr as usize | KIND_VEC;
            Bytes {
                ptr,
                len,
-                data: AtomicPtr::new(data.cast()),
+                data: AtomicPtr::new(data as *mut _),
                vtable: &PROMOTABLE_EVEN_VTABLE,
            }
        } else {
            Bytes {
                ptr,
                len,
-                data: AtomicPtr::new(ptr.cast()),
+                data: AtomicPtr::new(ptr as *mut _),
                vtable: &PROMOTABLE_ODD_VTABLE,
            }
        }
    }
 }

-impl From<Bytes> for BytesMut {
-    /// Convert self into `BytesMut`.
-    ///
-    /// If `bytes` is unique for the entire original buffer, this will return a
-    /// `BytesMut` with the contents of `bytes` without copying.
-    /// If `bytes` is not unique for the entire original buffer, this will make
-    /// a copy of `bytes` subset of the original buffer in a new `BytesMut`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::{Bytes, BytesMut};
-    ///
-    /// let bytes = Bytes::from(b"hello".to_vec());
-    /// assert_eq!(BytesMut::from(bytes), BytesMut::from(&b"hello"[..]));
-    /// ```
-    fn from(bytes: Bytes) -> Self {
-        let bytes = ManuallyDrop::new(bytes);
-        unsafe { (bytes.vtable.to_mut)(&bytes.data, bytes.ptr, bytes.len) }
-    }
-}
-
 impl From<String> for Bytes {
    fn from(s: String) -> Bytes {
        Bytes::from(s.into_bytes())
    }
 }

-impl From<Bytes> for Vec<u8> {
-    fn from(bytes: Bytes) -> Vec<u8> {
-        let bytes = ManuallyDrop::new(bytes);
-        unsafe { (bytes.vtable.to_vec)(&bytes.data, bytes.ptr, bytes.len) }
-    }
-}
-
 // ===== impl Vtable =====

 impl fmt::Debug for Vtable {
@@ -983,9 +854,6 @@ impl fmt::Debug for Vtable {

 const STATIC_VTABLE: Vtable = Vtable {
    clone: static_clone,
-    to_vec: static_to_vec,
-    to_mut: static_to_mut,
-    is_unique: static_is_unique,
    drop: static_drop,
 };

@@ -994,20 +862,6 @@ unsafe fn static_clone(_: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Bytes {
    Bytes::from_static(slice)
 }

-unsafe fn static_to_vec(_: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> {
-    let slice = slice::from_raw_parts(ptr, len);
-    slice.to_vec()
-}
-
-unsafe fn static_to_mut(_: &AtomicPtr<()>, ptr: *const u8, len: usize) -> BytesMut {
-    let slice = slice::from_raw_parts(ptr, len);
-    BytesMut::from(slice)
-}
-
-fn static_is_unique(_: &AtomicPtr<()>) -> bool {
-    false
-}
-
 unsafe fn static_drop(_: &mut AtomicPtr<()>, _: *const u8, _: usize) {
    // nothing to drop for &'static [u8]
 }
@@ -1016,17 +870,11 @@ unsafe fn static_drop(_: &mut AtomicPtr<()>, _: *const u8, _: usize) {

 static PROMOTABLE_EVEN_VTABLE: Vtable = Vtable {
    clone: promotable_even_clone,
-    to_vec: promotable_even_to_vec,
-    to_mut: promotable_even_to_mut,
-    is_unique: promotable_is_unique,
    drop: promotable_even_drop,
 };

 static PROMOTABLE_ODD_VTABLE: Vtable = Vtable {
    clone: promotable_odd_clone,
-    to_vec: promotable_odd_to_vec,
-    to_mut: promotable_odd_to_mut,
-    is_unique: promotable_is_unique,
    drop: promotable_odd_drop,
 };

@@ -1035,92 +883,25 @@ unsafe fn promotable_even_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize
    let kind = shared as usize & KIND_MASK;

    if kind == KIND_ARC {
-        shallow_clone_arc(shared.cast(), ptr, len)
+        shallow_clone_arc(shared as _, ptr, len)
    } else {
        debug_assert_eq!(kind, KIND_VEC);
-        let buf = ptr_map(shared.cast(), |addr| addr & !KIND_MASK);
+        let buf = (shared as usize & !KIND_MASK) as *mut u8;
        shallow_clone_vec(data, shared, buf, ptr, len)
    }
 }

-unsafe fn promotable_to_vec(
-    data: &AtomicPtr<()>,
-    ptr: *const u8,
-    len: usize,
-    f: fn(*mut ()) -> *mut u8,
-) -> Vec<u8> {
-    let shared = data.load(Ordering::Acquire);
-    let kind = shared as usize & KIND_MASK;
-
-    if kind == KIND_ARC {
-        shared_to_vec_impl(shared.cast(), ptr, len)
-    } else {
-        // If Bytes holds a Vec, then the offset must be 0.
-        debug_assert_eq!(kind, KIND_VEC);
-
-        let buf = f(shared);
-
-        let cap = offset_from(ptr, buf) + len;
-
-        // Copy back buffer
-        ptr::copy(ptr, buf, len);
-
-        Vec::from_raw_parts(buf, len, cap)
-    }
-}
-
-unsafe fn promotable_to_mut(
-    data: &AtomicPtr<()>,
-    ptr: *const u8,
-    len: usize,
-    f: fn(*mut ()) -> *mut u8,
-) -> BytesMut {
-    let shared = data.load(Ordering::Acquire);
-    let kind = shared as usize & KIND_MASK;
-
-    if kind == KIND_ARC {
-        shared_to_mut_impl(shared.cast(), ptr, len)
-    } else {
-        // KIND_VEC is a view of an underlying buffer at a certain offset.
-        // The ptr + len always represents the end of that buffer.
-        // Before truncating it, it is first promoted to KIND_ARC.
-        // Thus, we can safely reconstruct a Vec from it without leaking memory.
-        debug_assert_eq!(kind, KIND_VEC);
-
-        let buf = f(shared);
-        let off = offset_from(ptr, buf);
-        let cap = off + len;
-        let v = Vec::from_raw_parts(buf, cap, cap);
-
-        let mut b = BytesMut::from_vec(v);
-        b.advance_unchecked(off);
-        b
-    }
-}
-
-unsafe fn promotable_even_to_vec(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> {
-    promotable_to_vec(data, ptr, len, |shared| {
-        ptr_map(shared.cast(), |addr| addr & !KIND_MASK)
-    })
-}
-
-unsafe fn promotable_even_to_mut(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> BytesMut {
-    promotable_to_mut(data, ptr, len, |shared| {
-        ptr_map(shared.cast(), |addr| addr & !KIND_MASK)
-    })
-}
-
 unsafe fn promotable_even_drop(data: &mut AtomicPtr<()>, ptr: *const u8, len: usize) {
    data.with_mut(|shared| {
        let shared = *shared;
        let kind = shared as usize & KIND_MASK;

        if kind == KIND_ARC {
-            release_shared(shared.cast());
+            release_shared(shared as *mut Shared);
        } else {
            debug_assert_eq!(kind, KIND_VEC);
-            let buf = ptr_map(shared.cast(), |addr| addr & !KIND_MASK);
-            free_boxed_slice(buf, ptr, len);
+            let buf = (shared as usize & !KIND_MASK) as *mut u8;
+            drop(rebuild_boxed_slice(buf, ptr, len));
        }
    });
 }
@@ -1133,65 +914,38 @@ unsafe fn promotable_odd_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize)
        shallow_clone_arc(shared as _, ptr, len)
    } else {
        debug_assert_eq!(kind, KIND_VEC);
-        shallow_clone_vec(data, shared, shared.cast(), ptr, len)
+        shallow_clone_vec(data, shared, shared as *mut u8, ptr, len)
    }
 }

-unsafe fn promotable_odd_to_vec(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> {
-    promotable_to_vec(data, ptr, len, |shared| shared.cast())
-}
-
-unsafe fn promotable_odd_to_mut(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> BytesMut {
-    promotable_to_mut(data, ptr, len, |shared| shared.cast())
-}
-
 unsafe fn promotable_odd_drop(data: &mut AtomicPtr<()>, ptr: *const u8, len: usize) {
    data.with_mut(|shared| {
        let shared = *shared;
        let kind = shared as usize & KIND_MASK;

        if kind == KIND_ARC {
-            release_shared(shared.cast());
+            release_shared(shared as *mut Shared);
        } else {
            debug_assert_eq!(kind, KIND_VEC);

-            free_boxed_slice(shared.cast(), ptr, len);
+            drop(rebuild_boxed_slice(shared as *mut u8, ptr, len));
        }
    });
 }

-unsafe fn promotable_is_unique(data: &AtomicPtr<()>) -> bool {
-    let shared = data.load(Ordering::Acquire);
-    let kind = shared as usize & KIND_MASK;
-
-    if kind == KIND_ARC {
-        let ref_cnt = (*shared.cast::<Shared>()).ref_cnt.load(Ordering::Relaxed);
-        ref_cnt == 1
-    } else {
-        true
-    }
-}
-
-unsafe fn free_boxed_slice(buf: *mut u8, offset: *const u8, len: usize) {
-    let cap = offset_from(offset, buf) + len;
-    dealloc(buf, Layout::from_size_align(cap, 1).unwrap())
+unsafe fn rebuild_boxed_slice(buf: *mut u8, offset: *const u8, len: usize) -> Box<[u8]> {
+    let cap = (offset as usize - buf as usize) + len;
+    Box::from_raw(slice::from_raw_parts_mut(buf, cap))
 }

 // ===== impl SharedVtable =====

 struct Shared {
-    // Holds arguments to dealloc upon Drop, but otherwise doesn't use them
-    buf: *mut u8,
-    cap: usize,
+    // holds vec for drop, but otherwise doesnt access it
+    _vec: Vec<u8>,
    ref_cnt: AtomicUsize,
 }

-impl Drop for Shared {
-    fn drop(&mut self) {
-        unsafe { dealloc(self.buf, Layout::from_size_align(self.cap, 1).unwrap()) }
-    }
-}
-
 // Assert that the alignment of `Shared` is divisible by 2.
 // This is a necessary invariant since we depend on allocating `Shared` a
 // shared object to implicitly carry the `KIND_ARC` flag in its pointer.
@@ -1200,9 +954,6 @@ const _: [(); 0 - mem::align_of::<Shared>() % 2] = []; // Assert that the alignm

 static SHARED_VTABLE: Vtable = Vtable {
    clone: shared_clone,
-    to_vec: shared_to_vec,
-    to_mut: shared_to_mut,
-    is_unique: shared_is_unique,
    drop: shared_drop,
 };

@@ -1215,87 +966,9 @@ unsafe fn shared_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Byte
    shallow_clone_arc(shared as _, ptr, len)
 }

-unsafe fn shared_to_vec_impl(shared: *mut Shared, ptr: *const u8, len: usize) -> Vec<u8> {
-    // Check that the ref_cnt is 1 (unique).
-    //
-    // If it is unique, then it is set to 0 with AcqRel fence for the same
-    // reason in release_shared.
-    //
-    // Otherwise, we take the other branch and call release_shared.
-    if (*shared)
-        .ref_cnt
-        .compare_exchange(1, 0, Ordering::AcqRel, Ordering::Relaxed)
-        .is_ok()
-    {
-        // Deallocate the `Shared` instance without running its destructor.
-        let shared = *Box::from_raw(shared);
-        let shared = ManuallyDrop::new(shared);
-        let buf = shared.buf;
-        let cap = shared.cap;
-
-        // Copy back buffer
-        ptr::copy(ptr, buf, len);
-
-        Vec::from_raw_parts(buf, len, cap)
-    } else {
-        let v = slice::from_raw_parts(ptr, len).to_vec();
-        release_shared(shared);
-        v
-    }
-}
-
-unsafe fn shared_to_vec(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> {
-    shared_to_vec_impl(data.load(Ordering::Relaxed).cast(), ptr, len)
-}
-
-unsafe fn shared_to_mut_impl(shared: *mut Shared, ptr: *const u8, len: usize) -> BytesMut {
-    // The goal is to check if the current handle is the only handle
-    // that currently has access to the buffer. This is done by
-    // checking if the `ref_cnt` is currently 1.
-    //
-    // The `Acquire` ordering synchronizes with the `Release` as
-    // part of the `fetch_sub` in `release_shared`. The `fetch_sub`
-    // operation guarantees that any mutations done in other threads
-    // are ordered before the `ref_cnt` is decremented. As such,
-    // this `Acquire` will guarantee that those mutations are
-    // visible to the current thread.
-    //
-    // Otherwise, we take the other branch, copy the data and call `release_shared`.
-    if (*shared).ref_cnt.load(Ordering::Acquire) == 1 {
-        // Deallocate the `Shared` instance without running its destructor.
-        let shared = *Box::from_raw(shared);
-        let shared = ManuallyDrop::new(shared);
-        let buf = shared.buf;
-        let cap = shared.cap;
-
-        // Rebuild Vec
-        let off = offset_from(ptr, buf);
-        let v = Vec::from_raw_parts(buf, len + off, cap);
-
-        let mut b = BytesMut::from_vec(v);
-        b.advance_unchecked(off);
-        b
-    } else {
-        // Copy the data from Shared in a new Vec, then release it
-        let v = slice::from_raw_parts(ptr, len).to_vec();
-        release_shared(shared);
-        BytesMut::from_vec(v)
-    }
-}
-
-unsafe fn shared_to_mut(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> BytesMut {
-    shared_to_mut_impl(data.load(Ordering::Relaxed).cast(), ptr, len)
-}
-
-pub(crate) unsafe fn shared_is_unique(data: &AtomicPtr<()>) -> bool {
-    let shared = data.load(Ordering::Acquire);
-    let ref_cnt = (*shared.cast::<Shared>()).ref_cnt.load(Ordering::Relaxed);
-    ref_cnt == 1
-}
-
 unsafe fn shared_drop(data: &mut AtomicPtr<()>, _ptr: *const u8, _len: usize) {
    data.with_mut(|shared| {
-        release_shared(shared.cast());
+        release_shared(*shared as *mut Shared);
    });
 }

@@ -1322,7 +995,7 @@ unsafe fn shallow_clone_vec(
    offset: *const u8,
    len: usize,
 ) -> Bytes {
-    // If the buffer is still tracked in a `Vec<u8>`. It is time to
+    // If  the buffer is still tracked in a `Vec<u8>`. It is time to
    // promote the vec to an `Arc`. This could potentially be called
    // concurrently, so some care must be taken.

@@ -1333,9 +1006,9 @@ unsafe fn shallow_clone_vec(
    // updated and since the buffer hasn't been promoted to an
    // `Arc`, those three fields still are the components of the
    // vector.
+    let vec = rebuild_boxed_slice(buf, offset, len).into_vec();
    let shared = Box::new(Shared {
-        buf,
-        cap: offset_from(offset, buf) + len,
+        _vec: vec,
        // Initialize refcount to 2. One for this reference, and one
        // for the new clone that will be returned from
        // `shallow_clone`.
@@ -1409,44 +1082,10 @@ unsafe fn release_shared(ptr: *mut Shared) {
    // > "acquire" operation before deleting the object.
    //
    // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)
-    //
-    // Thread sanitizer does not support atomic fences. Use an atomic load
-    // instead.
-    (*ptr).ref_cnt.load(Ordering::Acquire);
+    atomic::fence(Ordering::Acquire);

    // Drop the data
-    drop(Box::from_raw(ptr));
-}
-
-// Ideally we would always use this version of `ptr_map` since it is strict
-// provenance compatible, but it results in worse codegen. We will however still
-// use it on miri because it gives better diagnostics for people who test bytes
-// code with miri.
-//
-// See https://github.com/tokio-rs/bytes/pull/545 for more info.
-#[cfg(miri)]
-fn ptr_map<F>(ptr: *mut u8, f: F) -> *mut u8
-where
-    F: FnOnce(usize) -> usize,
-{
-    let old_addr = ptr as usize;
-    let new_addr = f(old_addr);
-    let diff = new_addr.wrapping_sub(old_addr);
-    ptr.wrapping_add(diff)
-}
-
-#[cfg(not(miri))]
-fn ptr_map<F>(ptr: *mut u8, f: F) -> *mut u8
-where
-    F: FnOnce(usize) -> usize,
-{
-    let old_addr = ptr as usize;
-    let new_addr = f(old_addr);
-    new_addr as *mut u8
-}
-
-fn without_provenance(ptr: usize) -> *const u8 {
-    core::ptr::null::<u8>().wrapping_add(ptr)
+    Box::from_raw(ptr);
 }

 // compile-fails
@@ -25,7 +25,7 @@ impl Debug for BytesRef<'_> {
            } else if b == b'\0' {
                write!(f, "\\0")?;
            // ASCII printable
-            } else if (0x20..0x7f).contains(&b) {
+            } else if b >= 0x20 && b < 0x7f {
                write!(f, "{}", b as char)?;
            } else {
                write!(f, "\\x{:02x}", b)?;
@@ -38,12 +38,12 @@ impl Debug for BytesRef<'_> {

 impl Debug for Bytes {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        Debug::fmt(&BytesRef(self.as_ref()), f)
+        Debug::fmt(&BytesRef(&self.as_ref()), f)
    }
 }

 impl Debug for BytesMut {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        Debug::fmt(&BytesRef(self.as_ref()), f)
+        Debug::fmt(&BytesRef(&self.as_ref()), f)
    }
 }
@@ -1,18 +1,19 @@
-#![allow(unknown_lints, unexpected_cfgs)]
 #![warn(missing_docs, missing_debug_implementations, rust_2018_idioms)]
 #![doc(test(
    no_crate_inject,
    attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
 ))]
 #![no_std]
-#![cfg_attr(docsrs, feature(doc_cfg))]

 //! Provides abstractions for working with bytes.
 //!
 //! The `bytes` crate provides an efficient byte buffer structure
-//! ([`Bytes`]) and traits for working with buffer
+//! ([`Bytes`](struct.Bytes.html)) and traits for working with buffer
 //! implementations ([`Buf`], [`BufMut`]).
 //!
+//! [`Buf`]: trait.Buf.html
+//! [`BufMut`]: trait.BufMut.html
+//!
 //! # `Bytes`
 //!
 //! `Bytes` is an efficient container for storing and operating on contiguous
@@ -50,7 +51,9 @@
 //! `a` and `b` will share the underlying buffer and maintain indices tracking
 //! the view into the buffer represented by the handle.
 //!
-//! See the [struct docs](`Bytes`) for more details.
+//! See the [struct docs] for more details.
+//!
+//! [struct docs]: struct.Bytes.html
 //!
 //! # `Buf`, `BufMut`
 //!
@@ -66,7 +69,7 @@
 //! ## Relation with `Read` and `Write`
 //!
 //! At first glance, it may seem that `Buf` and `BufMut` overlap in
-//! functionality with [`std::io::Read`] and [`std::io::Write`]. However, they
+//! functionality with `std::io::Read` and `std::io::Write`. However, they
 //! serve different purposes. A buffer is the value that is provided as an
 //! argument to `Read::read` and `Write::write`. `Read` and `Write` may then
 //! perform a syscall, which has the potential of failing. Operations on `Buf`
@@ -111,55 +114,3 @@ fn abort() -> ! {
        panic!("abort");
    }
 }
-
-#[inline(always)]
-#[cfg(feature = "std")]
-fn saturating_sub_usize_u64(a: usize, b: u64) -> usize {
-    use core::convert::TryFrom;
-    match usize::try_from(b) {
-        Ok(b) => a.saturating_sub(b),
-        Err(_) => 0,
-    }
-}
-
-#[inline(always)]
-#[cfg(feature = "std")]
-fn min_u64_usize(a: u64, b: usize) -> usize {
-    use core::convert::TryFrom;
-    match usize::try_from(a) {
-        Ok(a) => usize::min(a, b),
-        Err(_) => b,
-    }
-}
-
-/// Panic with a nice error message.
-#[cold]
-fn panic_advance(idx: usize, len: usize) -> ! {
-    panic!(
-        "advance out of bounds: the len is {} but advancing by {}",
-        len, idx
-    );
-}
-
-#[cold]
-fn panic_does_not_fit(size: usize, nbytes: usize) -> ! {
-    panic!(
-        "size too large: the integer type can fit {} bytes, but nbytes is {}",
-        size, nbytes
-    );
-}
-
-/// Precondition: dst >= original
-///
-/// The following line is equivalent to:
-///
-/// ```rust,ignore
-/// self.ptr.as_ptr().offset_from(ptr) as usize;
-/// ```
-///
-/// But due to min rust is 1.39 and it is only stabilized
-/// in 1.47, we cannot use it.
-#[inline]
-fn offset_from(dst: *const u8, original: *const u8) -> usize {
-    dst as usize - original as usize
-}
@@ -1,7 +1,7 @@
 #[cfg(not(all(test, loom)))]
 pub(crate) mod sync {
    pub(crate) mod atomic {
-        pub(crate) use core::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
+        pub(crate) use core::sync::atomic::{fence, AtomicPtr, AtomicUsize, Ordering};

        pub(crate) trait AtomicMut<T> {
            fn with_mut<F, R>(&mut self, f: F) -> R
@@ -23,7 +23,7 @@ pub(crate) mod sync {
 #[cfg(all(test, loom))]
 pub(crate) mod sync {
    pub(crate) mod atomic {
-        pub(crate) use loom::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
+        pub(crate) use loom::sync::atomic::{fence, AtomicPtr, AtomicUsize, Ordering};

        pub(crate) trait AtomicMut<T> {}
    }
@@ -36,19 +36,6 @@ fn test_get_u16() {
    assert_eq!(0x5421, buf.get_u16_le());
 }

-#[test]
-fn test_get_int() {
-    let mut buf = &b"\xd6zomg"[..];
-    assert_eq!(-42, buf.get_int(1));
-    let mut buf = &b"\xd6zomg"[..];
-    assert_eq!(-42, buf.get_int_le(1));
-
-    let mut buf = &b"\xfe\x1d\xc0zomg"[..];
-    assert_eq!(0xffffffffffc01dfeu64 as i64, buf.get_int_le(3));
-    let mut buf = &b"\xfe\x1d\xc0zomg"[..];
-    assert_eq!(0xfffffffffffe1dc0u64 as i64, buf.get_int(3));
-}
-
 #[test]
 #[should_panic]
 fn test_get_u16_buffer_underflow() {
@@ -85,7 +72,6 @@ fn test_vec_deque() {
    assert_eq!(b"world piece", &out[..]);
 }

-#[allow(unused_allocation)] // This is intentional.
 #[test]
 fn test_deref_buf_forwards() {
    struct Special;
@@ -3,7 +3,6 @@
 use bytes::buf::UninitSlice;
 use bytes::{BufMut, BytesMut};
 use core::fmt::Write;
-use core::mem::MaybeUninit;
 use core::usize;

 #[test]
@@ -83,7 +82,7 @@ fn test_put_int_le_nbytes_overflow() {
 }

 #[test]
-#[should_panic(expected = "advance out of bounds: the len is 8 but advancing by 12")]
+#[should_panic(expected = "cannot advance")]
 fn test_vec_advance_mut() {
    // Verify fix for #354
    let mut buf = Vec::with_capacity(8);
@@ -102,123 +101,26 @@ fn test_clone() {
    assert!(buf != buf2);
 }

-fn do_test_slice_small<T: ?Sized>(make: impl Fn(&mut [u8]) -> &mut T)
-where
-    for<'r> &'r mut T: BufMut,
-{
-    let mut buf = [b'X'; 8];
+#[test]
+fn test_mut_slice() {
+    let mut v = vec![0, 0, 0, 0];
+    let mut s = &mut v[..];
+    s.put_u32(42);

-    let mut slice = make(&mut buf[..]);
-    slice.put_bytes(b'A', 2);
-    slice.put_u8(b'B');
-    slice.put_slice(b"BCC");
-    assert_eq!(2, slice.remaining_mut());
-    assert_eq!(b"AABBCCXX", &buf[..]);
-
-    let mut slice = make(&mut buf[..]);
-    slice.put_u32(0x61626364);
-    assert_eq!(4, slice.remaining_mut());
-    assert_eq!(b"abcdCCXX", &buf[..]);
-
-    let mut slice = make(&mut buf[..]);
-    slice.put_u32_le(0x30313233);
-    assert_eq!(4, slice.remaining_mut());
-    assert_eq!(b"3210CCXX", &buf[..]);
-}
-
-fn do_test_slice_large<T: ?Sized>(make: impl Fn(&mut [u8]) -> &mut T)
-where
-    for<'r> &'r mut T: BufMut,
-{
-    const LEN: usize = 100;
-    const FILL: [u8; LEN] = [b'Y'; LEN];
-
-    let test = |fill: &dyn Fn(&mut &mut T, usize)| {
-        for buf_len in 0..LEN {
-            let mut buf = [b'X'; LEN];
-            for fill_len in 0..=buf_len {
-                let mut slice = make(&mut buf[..buf_len]);
-                fill(&mut slice, fill_len);
-                assert_eq!(buf_len - fill_len, slice.remaining_mut());
-                let (head, tail) = buf.split_at(fill_len);
-                assert_eq!(&FILL[..fill_len], head);
-                assert!(tail.iter().all(|b| *b == b'X'));
-            }
-        }
-    };
-
-    test(&|slice, fill_len| slice.put_slice(&FILL[..fill_len]));
-    test(&|slice, fill_len| slice.put_bytes(FILL[0], fill_len));
-}
-
-fn do_test_slice_put_slice_panics<T: ?Sized>(make: impl Fn(&mut [u8]) -> &mut T)
-where
-    for<'r> &'r mut T: BufMut,
-{
-    let mut buf = [b'X'; 4];
-    let mut slice = make(&mut buf[..]);
-    slice.put_slice(b"12345");
-}
-
-fn do_test_slice_put_bytes_panics<T: ?Sized>(make: impl Fn(&mut [u8]) -> &mut T)
-where
-    for<'r> &'r mut T: BufMut,
-{
-    let mut buf = [b'X'; 4];
-    let mut slice = make(&mut buf[..]);
-    slice.put_bytes(b'1', 5);
+    assert_eq!(s.len(), 0);
+    assert_eq!(&v, &[0, 0, 0, 42]);
 }

 #[test]
-fn test_slice_buf_mut_small() {
-    do_test_slice_small(|x| x);
+fn test_slice_put_bytes() {
+    let mut v = [0, 0, 0, 0];
+    let mut s = &mut v[..];
+    s.put_u8(17);
+    s.put_bytes(19, 2);
+    assert_eq!(1, s.remaining_mut());
+    assert_eq!(&[17, 19, 19, 0], &v[..]);
 }

-#[test]
-fn test_slice_buf_mut_large() {
-    do_test_slice_large(|x| x);
-}
-
-#[test]
-#[should_panic]
-fn test_slice_buf_mut_put_slice_overflow() {
-    do_test_slice_put_slice_panics(|x| x);
-}
-
-#[test]
-#[should_panic]
-fn test_slice_buf_mut_put_bytes_overflow() {
-    do_test_slice_put_bytes_panics(|x| x);
-}
-
-fn make_maybe_uninit_slice(slice: &mut [u8]) -> &mut [MaybeUninit<u8>] {
-    // SAFETY: [u8] has the same layout as [MaybeUninit<u8>].
-    unsafe { core::mem::transmute(slice) }
-}
-
-#[test]
-fn test_maybe_uninit_buf_mut_small() {
-    do_test_slice_small(make_maybe_uninit_slice);
-}
-
-#[test]
-fn test_maybe_uninit_buf_mut_large() {
-    do_test_slice_large(make_maybe_uninit_slice);
-}
-
-#[test]
-#[should_panic]
-fn test_maybe_uninit_buf_mut_put_slice_overflow() {
-    do_test_slice_put_slice_panics(make_maybe_uninit_slice);
-}
-
-#[test]
-#[should_panic]
-fn test_maybe_uninit_buf_mut_put_bytes_overflow() {
-    do_test_slice_put_bytes_panics(make_maybe_uninit_slice);
-}
-
-#[allow(unused_allocation)] // This is intentional.
 #[test]
 fn test_deref_bufmut_forwards() {
    struct Special;
@@ -4,8 +4,8 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};

 use std::usize;

-const LONG: &[u8] = b"mary had a little lamb, little lamb, little lamb";
-const SHORT: &[u8] = b"hello world";
+const LONG: &'static [u8] = b"mary had a little lamb, little lamb, little lamb";
+const SHORT: &'static [u8] = b"hello world";

 fn is_sync<T: Sync>() {}
 fn is_send<T: Send>() {}
@@ -411,8 +411,8 @@ fn freeze_after_split_off() {
 fn fns_defined_for_bytes_mut() {
    let mut bytes = BytesMut::from(&b"hello world"[..]);

-    let _ = bytes.as_ptr();
-    let _ = bytes.as_mut_ptr();
+    bytes.as_ptr();
+    bytes.as_mut_ptr();

    // Iterator
    let v: Vec<u8> = bytes.as_ref().iter().cloned().collect();
@@ -443,7 +443,7 @@ fn reserve_growth() {
    let _ = bytes.split();

    bytes.reserve(65);
-    assert_eq!(bytes.capacity(), 117);
+    assert_eq!(bytes.capacity(), 128);
 }

 #[test]
@@ -515,34 +515,6 @@ fn reserve_in_arc_unique_doubles() {
    assert_eq!(2000, bytes.capacity());
 }

-#[test]
-fn reserve_in_arc_unique_does_not_overallocate_after_split() {
-    let mut bytes = BytesMut::from(LONG);
-    let orig_capacity = bytes.capacity();
-    drop(bytes.split_off(LONG.len() / 2));
-
-    // now bytes is Arc and refcount == 1
-
-    let new_capacity = bytes.capacity();
-    bytes.reserve(orig_capacity - new_capacity);
-    assert_eq!(bytes.capacity(), orig_capacity);
-}
-
-#[test]
-fn reserve_in_arc_unique_does_not_overallocate_after_multiple_splits() {
-    let mut bytes = BytesMut::from(LONG);
-    let orig_capacity = bytes.capacity();
-    for _ in 0..10 {
-        drop(bytes.split_off(LONG.len() / 2));
-
-        // now bytes is Arc and refcount == 1
-
-        let new_capacity = bytes.capacity();
-        bytes.reserve(orig_capacity - new_capacity);
-    }
-    assert_eq!(bytes.capacity(), orig_capacity);
-}
-
 #[test]
 fn reserve_in_arc_nonunique_does_not_overallocate() {
    let mut bytes = BytesMut::with_capacity(1000);
@@ -555,25 +527,6 @@ fn reserve_in_arc_nonunique_does_not_overallocate() {
    assert_eq!(2001, bytes.capacity());
 }

-/// This function tests `BytesMut::reserve_inner`, where `BytesMut` holds
-/// a unique reference to the shared vector and decide to reuse it
-/// by reallocating the `Vec`.
-#[test]
-fn reserve_shared_reuse() {
-    let mut bytes = BytesMut::with_capacity(1000);
-    bytes.put_slice(b"Hello, World!");
-    drop(bytes.split());
-
-    bytes.put_slice(b"!123ex123,sadchELLO,_wORLD!");
-    // Use split_off so that v.capacity() - self.cap != off
-    drop(bytes.split_off(9));
-    assert_eq!(&*bytes, b"!123ex123");
-
-    bytes.reserve(2000);
-    assert_eq!(&*bytes, b"!123ex123");
-    assert_eq!(bytes.capacity(), 2009);
-}
-
 #[test]
 fn extend_mut() {
    let mut bytes = BytesMut::with_capacity(0);
@@ -591,35 +544,6 @@ fn extend_from_slice_mut() {
    }
 }

-#[test]
-fn extend_mut_from_bytes() {
-    let mut bytes = BytesMut::with_capacity(0);
-    bytes.extend([Bytes::from(LONG)]);
-    assert_eq!(*bytes, LONG[..]);
-}
-
-#[test]
-fn extend_past_lower_limit_of_size_hint() {
-    // See https://github.com/tokio-rs/bytes/pull/674#pullrequestreview-1913035700
-    struct Iter<I>(I);
-
-    impl<I: Iterator<Item = u8>> Iterator for Iter<I> {
-        type Item = u8;
-
-        fn next(&mut self) -> Option<Self::Item> {
-            self.0.next()
-        }
-
-        fn size_hint(&self) -> (usize, Option<usize>) {
-            (5, None)
-        }
-    }
-
-    let mut bytes = BytesMut::with_capacity(5);
-    bytes.extend(Iter(std::iter::repeat(0).take(10)));
-    assert_eq!(bytes.len(), 10);
-}
-
 #[test]
 fn extend_mut_without_size_hint() {
    let mut bytes = BytesMut::with_capacity(0);
@@ -676,43 +600,6 @@ fn advance_bytes_mut() {
    assert_eq!(a, b"d zomg wat wat"[..]);
 }

-// Ensures BytesMut::advance reduces always capacity
-//
-// See https://github.com/tokio-rs/bytes/issues/725
-#[test]
-fn advance_bytes_mut_remaining_capacity() {
-    // reduce the search space under miri
-    let max_capacity = if cfg!(miri) { 16 } else { 256 };
-    for capacity in 0..=max_capacity {
-        for len in 0..=capacity {
-            for advance in 0..=len {
-                eprintln!("testing capacity={capacity}, len={len}, advance={advance}");
-                let mut buf = BytesMut::with_capacity(capacity);
-
-                buf.resize(len, 42);
-                assert_eq!(buf.len(), len, "resize should write `len` bytes");
-                assert_eq!(
-                    buf.remaining(),
-                    len,
-                    "Buf::remaining() should equal BytesMut::len"
-                );
-
-                buf.advance(advance);
-                assert_eq!(
-                    buf.remaining(),
-                    len - advance,
-                    "Buf::advance should reduce the remaining len"
-                );
-                assert_eq!(
-                    buf.capacity(),
-                    capacity - advance,
-                    "Buf::advance should reduce the remaining capacity"
-                );
-            }
-        }
-    }
-}
-
 #[test]
 #[should_panic]
 fn advance_past_len() {
@@ -769,6 +656,97 @@ fn partial_eq_bytesmut() {
    assert!(bytesmut != bytes2);
 }

+/*
+#[test]
+fn bytes_unsplit_basic() {
+    let buf = Bytes::from(&b"aaabbbcccddd"[..]);
+
+    let splitted = buf.split_off(6);
+    assert_eq!(b"aaabbb", &buf[..]);
+    assert_eq!(b"cccddd", &splitted[..]);
+
+    buf.unsplit(splitted);
+    assert_eq!(b"aaabbbcccddd", &buf[..]);
+}
+
+#[test]
+fn bytes_unsplit_empty_other() {
+    let buf = Bytes::from(&b"aaabbbcccddd"[..]);
+
+    // empty other
+    let other = Bytes::new();
+
+    buf.unsplit(other);
+    assert_eq!(b"aaabbbcccddd", &buf[..]);
+}
+
+#[test]
+fn bytes_unsplit_empty_self() {
+    // empty self
+    let mut buf = Bytes::new();
+
+    let mut other = Bytes::with_capacity(64);
+    other.extend_from_slice(b"aaabbbcccddd");
+
+    buf.unsplit(other);
+    assert_eq!(b"aaabbbcccddd", &buf[..]);
+}
+
+#[test]
+fn bytes_unsplit_arc_different() {
+    let mut buf = Bytes::with_capacity(64);
+    buf.extend_from_slice(b"aaaabbbbeeee");
+
+    buf.split_off(8); //arc
+
+    let mut buf2 = Bytes::with_capacity(64);
+    buf2.extend_from_slice(b"ccccddddeeee");
+
+    buf2.split_off(8); //arc
+
+    buf.unsplit(buf2);
+    assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+#[test]
+fn bytes_unsplit_arc_non_contiguous() {
+    let mut buf = Bytes::with_capacity(64);
+    buf.extend_from_slice(b"aaaabbbbeeeeccccdddd");
+
+    let mut buf2 = buf.split_off(8); //arc
+
+    let buf3 = buf2.split_off(4); //arc
+
+    buf.unsplit(buf3);
+    assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+#[test]
+fn bytes_unsplit_two_split_offs() {
+    let mut buf = Bytes::with_capacity(64);
+    buf.extend_from_slice(b"aaaabbbbccccdddd");
+
+    let mut buf2 = buf.split_off(8); //arc
+    let buf3 = buf2.split_off(4); //arc
+
+    buf2.unsplit(buf3);
+    buf.unsplit(buf2);
+    assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+#[test]
+fn bytes_unsplit_overlapping_references() {
+    let mut buf = Bytes::with_capacity(64);
+    buf.extend_from_slice(b"abcdefghijklmnopqrstuvwxyz");
+    let mut buf0010 = buf.slice(0..10);
+    let buf1020 = buf.slice(10..20);
+    let buf0515 = buf.slice(5..15);
+    buf0010.unsplit(buf1020);
+    assert_eq!(b"abcdefghijklmnopqrst", &buf0010[..]);
+    assert_eq!(b"fghijklmno", &buf0515[..]);
+}
+*/
+
 #[test]
 fn bytes_mut_unsplit_basic() {
    let mut buf = BytesMut::with_capacity(64);
@@ -896,7 +874,7 @@ fn from_iter_no_size_hint() {

 fn test_slice_ref(bytes: &Bytes, start: usize, end: usize, expected: &[u8]) {
    let slice = &(bytes.as_ref()[start..end]);
-    let sub = bytes.slice_ref(slice);
+    let sub = bytes.slice_ref(&slice);
    assert_eq!(&sub[..], expected);
 }

@@ -916,7 +894,7 @@ fn slice_ref_empty() {
    let bytes = Bytes::from(&b""[..]);
    let slice = &(bytes.as_ref()[0..0]);

-    let sub = bytes.slice_ref(slice);
+    let sub = bytes.slice_ref(&slice);
    assert_eq!(&sub[..], b"");
 }

@@ -1024,458 +1002,3 @@ fn box_slice_empty() {
    let b = Bytes::from(empty);
    assert!(b.is_empty());
 }
-
-#[test]
-fn bytes_into_vec() {
-    // Test kind == KIND_VEC
-    let content = b"helloworld";
-
-    let mut bytes = BytesMut::new();
-    bytes.put_slice(content);
-
-    let vec: Vec<u8> = bytes.into();
-    assert_eq!(&vec, content);
-
-    // Test kind == KIND_ARC, shared.is_unique() == True
-    let mut bytes = BytesMut::new();
-    bytes.put_slice(b"abcdewe23");
-    bytes.put_slice(content);
-
-    // Overwrite the bytes to make sure only one reference to the underlying
-    // Vec exists.
-    bytes = bytes.split_off(9);
-
-    let vec: Vec<u8> = bytes.into();
-    assert_eq!(&vec, content);
-
-    // Test kind == KIND_ARC, shared.is_unique() == False
-    let prefix = b"abcdewe23";
-
-    let mut bytes = BytesMut::new();
-    bytes.put_slice(prefix);
-    bytes.put_slice(content);
-
-    let vec: Vec<u8> = bytes.split_off(prefix.len()).into();
-    assert_eq!(&vec, content);
-
-    let vec: Vec<u8> = bytes.into();
-    assert_eq!(&vec, prefix);
-}
-
-#[test]
-fn test_bytes_into_vec() {
-    // Test STATIC_VTABLE.to_vec
-    let bs = b"1b23exfcz3r";
-    let vec: Vec<u8> = Bytes::from_static(bs).into();
-    assert_eq!(&*vec, bs);
-
-    // Test bytes_mut.SHARED_VTABLE.to_vec impl
-    eprintln!("1");
-    let mut bytes_mut: BytesMut = bs[..].into();
-
-    // Set kind to KIND_ARC so that after freeze, Bytes will use bytes_mut.SHARED_VTABLE
-    eprintln!("2");
-    drop(bytes_mut.split_off(bs.len()));
-
-    eprintln!("3");
-    let b1 = bytes_mut.freeze();
-    eprintln!("4");
-    let b2 = b1.clone();
-
-    eprintln!("{:#?}", (&*b1).as_ptr());
-
-    // shared.is_unique() = False
-    eprintln!("5");
-    assert_eq!(&*Vec::from(b2), bs);
-
-    // shared.is_unique() = True
-    eprintln!("6");
-    assert_eq!(&*Vec::from(b1), bs);
-
-    // Test bytes_mut.SHARED_VTABLE.to_vec impl where offset != 0
-    let mut bytes_mut1: BytesMut = bs[..].into();
-    let bytes_mut2 = bytes_mut1.split_off(9);
-
-    let b1 = bytes_mut1.freeze();
-    let b2 = bytes_mut2.freeze();
-
-    assert_eq!(Vec::from(b2), bs[9..]);
-    assert_eq!(Vec::from(b1), bs[..9]);
-}
-
-#[test]
-fn test_bytes_into_vec_promotable_even() {
-    let vec = vec![33u8; 1024];
-
-    // Test cases where kind == KIND_VEC
-    let b1 = Bytes::from(vec.clone());
-    assert_eq!(Vec::from(b1), vec);
-
-    // Test cases where kind == KIND_ARC, ref_cnt == 1
-    let b1 = Bytes::from(vec.clone());
-    drop(b1.clone());
-    assert_eq!(Vec::from(b1), vec);
-
-    // Test cases where kind == KIND_ARC, ref_cnt == 2
-    let b1 = Bytes::from(vec.clone());
-    let b2 = b1.clone();
-    assert_eq!(Vec::from(b1), vec);
-
-    // Test cases where vtable = SHARED_VTABLE, kind == KIND_ARC, ref_cnt == 1
-    assert_eq!(Vec::from(b2), vec);
-
-    // Test cases where offset != 0
-    let mut b1 = Bytes::from(vec.clone());
-    let b2 = b1.split_off(20);
-
-    assert_eq!(Vec::from(b2), vec[20..]);
-    assert_eq!(Vec::from(b1), vec[..20]);
-}
-
-#[test]
-fn test_bytes_vec_conversion() {
-    let mut vec = Vec::with_capacity(10);
-    vec.extend(b"abcdefg");
-    let b = Bytes::from(vec);
-    let v = Vec::from(b);
-    assert_eq!(v.len(), 7);
-    assert_eq!(v.capacity(), 10);
-
-    let mut b = Bytes::from(v);
-    b.advance(1);
-    let v = Vec::from(b);
-    assert_eq!(v.len(), 6);
-    assert_eq!(v.capacity(), 10);
-    assert_eq!(v.as_slice(), b"bcdefg");
-}
-
-#[test]
-fn test_bytes_mut_conversion() {
-    let mut b1 = BytesMut::with_capacity(10);
-    b1.extend(b"abcdefg");
-    let b2 = Bytes::from(b1);
-    let v = Vec::from(b2);
-    assert_eq!(v.len(), 7);
-    assert_eq!(v.capacity(), 10);
-
-    let mut b = Bytes::from(v);
-    b.advance(1);
-    let v = Vec::from(b);
-    assert_eq!(v.len(), 6);
-    assert_eq!(v.capacity(), 10);
-    assert_eq!(v.as_slice(), b"bcdefg");
-}
-
-#[test]
-fn test_bytes_capacity_len() {
-    for cap in 0..100 {
-        for len in 0..=cap {
-            let mut v = Vec::with_capacity(cap);
-            v.resize(len, 0);
-            let _ = Bytes::from(v);
-        }
-    }
-}
-
-#[test]
-fn static_is_unique() {
-    let b = Bytes::from_static(LONG);
-    assert!(!b.is_unique());
-}
-
-#[test]
-fn vec_is_unique() {
-    let v: Vec<u8> = LONG.to_vec();
-    let b = Bytes::from(v);
-    assert!(b.is_unique());
-}
-
-#[test]
-fn arc_is_unique() {
-    let v: Vec<u8> = LONG.to_vec();
-    let b = Bytes::from(v);
-    let c = b.clone();
-    assert!(!b.is_unique());
-    drop(c);
-    assert!(b.is_unique());
-}
-
-#[test]
-fn shared_is_unique() {
-    let v: Vec<u8> = LONG.to_vec();
-    let b = Bytes::from(v);
-    let c = b.clone();
-    assert!(!c.is_unique());
-    drop(b);
-    assert!(c.is_unique());
-}
-
-#[test]
-fn mut_shared_is_unique() {
-    let mut b = BytesMut::from(LONG);
-    let c = b.split().freeze();
-    assert!(!c.is_unique());
-    drop(b);
-    assert!(c.is_unique());
-}
-
-#[test]
-fn test_bytesmut_from_bytes_static() {
-    let bs = b"1b23exfcz3r";
-
-    // Test STATIC_VTABLE.to_mut
-    let bytes_mut = BytesMut::from(Bytes::from_static(bs));
-    assert_eq!(bytes_mut, bs[..]);
-}
-
-#[test]
-fn test_bytesmut_from_bytes_bytes_mut_vec() {
-    let bs = b"1b23exfcz3r";
-    let bs_long = b"1b23exfcz3r1b23exfcz3r";
-
-    // Test case where kind == KIND_VEC
-    let mut bytes_mut: BytesMut = bs[..].into();
-    bytes_mut = BytesMut::from(bytes_mut.freeze());
-    assert_eq!(bytes_mut, bs[..]);
-    bytes_mut.extend_from_slice(&bs[..]);
-    assert_eq!(bytes_mut, bs_long[..]);
-}
-
-#[test]
-fn test_bytesmut_from_bytes_bytes_mut_shared() {
-    let bs = b"1b23exfcz3r";
-
-    // Set kind to KIND_ARC so that after freeze, Bytes will use bytes_mut.SHARED_VTABLE
-    let mut bytes_mut: BytesMut = bs[..].into();
-    drop(bytes_mut.split_off(bs.len()));
-
-    let b1 = bytes_mut.freeze();
-    let b2 = b1.clone();
-
-    // shared.is_unique() = False
-    let mut b1m = BytesMut::from(b1);
-    assert_eq!(b1m, bs[..]);
-    b1m[0] = b'9';
-
-    // shared.is_unique() = True
-    let b2m = BytesMut::from(b2);
-    assert_eq!(b2m, bs[..]);
-}
-
-#[test]
-fn test_bytesmut_from_bytes_bytes_mut_offset() {
-    let bs = b"1b23exfcz3r";
-
-    // Test bytes_mut.SHARED_VTABLE.to_mut impl where offset != 0
-    let mut bytes_mut1: BytesMut = bs[..].into();
-    let bytes_mut2 = bytes_mut1.split_off(9);
-
-    let b1 = bytes_mut1.freeze();
-    let b2 = bytes_mut2.freeze();
-
-    let b1m = BytesMut::from(b1);
-    let b2m = BytesMut::from(b2);
-
-    assert_eq!(b2m, bs[9..]);
-    assert_eq!(b1m, bs[..9]);
-}
-
-#[test]
-fn test_bytesmut_from_bytes_promotable_even_vec() {
-    let vec = vec![33u8; 1024];
-
-    // Test case where kind == KIND_VEC
-    let b1 = Bytes::from(vec.clone());
-    let b1m = BytesMut::from(b1);
-    assert_eq!(b1m, vec);
-}
-
-#[test]
-fn test_bytesmut_from_bytes_promotable_even_arc_1() {
-    let vec = vec![33u8; 1024];
-
-    // Test case where kind == KIND_ARC, ref_cnt == 1
-    let b1 = Bytes::from(vec.clone());
-    drop(b1.clone());
-    let b1m = BytesMut::from(b1);
-    assert_eq!(b1m, vec);
-}
-
-#[test]
-fn test_bytesmut_from_bytes_promotable_even_arc_2() {
-    let vec = vec![33u8; 1024];
-
-    // Test case where kind == KIND_ARC, ref_cnt == 2
-    let b1 = Bytes::from(vec.clone());
-    let b2 = b1.clone();
-    let b1m = BytesMut::from(b1);
-    assert_eq!(b1m, vec);
-
-    // Test case where vtable = SHARED_VTABLE, kind == KIND_ARC, ref_cnt == 1
-    let b2m = BytesMut::from(b2);
-    assert_eq!(b2m, vec);
-}
-
-#[test]
-fn test_bytesmut_from_bytes_promotable_even_arc_offset() {
-    let vec = vec![33u8; 1024];
-
-    // Test case where offset != 0
-    let mut b1 = Bytes::from(vec.clone());
-    let b2 = b1.split_off(20);
-    let b1m = BytesMut::from(b1);
-    let b2m = BytesMut::from(b2);
-
-    assert_eq!(b2m, vec[20..]);
-    assert_eq!(b1m, vec[..20]);
-}
-
-#[test]
-fn try_reclaim_empty() {
-    let mut buf = BytesMut::new();
-    assert_eq!(false, buf.try_reclaim(6));
-    buf.reserve(6);
-    assert_eq!(true, buf.try_reclaim(6));
-    let cap = buf.capacity();
-    assert!(cap >= 6);
-    assert_eq!(false, buf.try_reclaim(cap + 1));
-
-    let mut buf = BytesMut::new();
-    buf.reserve(6);
-    let cap = buf.capacity();
-    assert!(cap >= 6);
-    let mut split = buf.split();
-    drop(buf);
-    assert_eq!(0, split.capacity());
-    assert_eq!(true, split.try_reclaim(6));
-    assert_eq!(false, split.try_reclaim(cap + 1));
-}
-
-#[test]
-fn try_reclaim_vec() {
-    let mut buf = BytesMut::with_capacity(6);
-    buf.put_slice(b"abc");
-    // Reclaiming a ludicrous amount of space should calmly return false
-    assert_eq!(false, buf.try_reclaim(usize::MAX));
-
-    assert_eq!(false, buf.try_reclaim(6));
-    buf.advance(2);
-    assert_eq!(4, buf.capacity());
-    // We can reclaim 5 bytes, because the byte in the buffer can be moved to the front. 6 bytes
-    // cannot be reclaimed because there is already one byte stored
-    assert_eq!(false, buf.try_reclaim(6));
-    assert_eq!(true, buf.try_reclaim(5));
-    buf.advance(1);
-    assert_eq!(true, buf.try_reclaim(6));
-    assert_eq!(6, buf.capacity());
-}
-
-#[test]
-fn try_reclaim_arc() {
-    let mut buf = BytesMut::with_capacity(6);
-    buf.put_slice(b"abc");
-    let x = buf.split().freeze();
-    buf.put_slice(b"def");
-    // Reclaiming a ludicrous amount of space should calmly return false
-    assert_eq!(false, buf.try_reclaim(usize::MAX));
-
-    let y = buf.split().freeze();
-    let z = y.clone();
-    assert_eq!(false, buf.try_reclaim(6));
-    drop(x);
-    drop(z);
-    assert_eq!(false, buf.try_reclaim(6));
-    drop(y);
-    assert_eq!(true, buf.try_reclaim(6));
-    assert_eq!(6, buf.capacity());
-    assert_eq!(0, buf.len());
-    buf.put_slice(b"abc");
-    buf.put_slice(b"def");
-    assert_eq!(6, buf.capacity());
-    assert_eq!(6, buf.len());
-    assert_eq!(false, buf.try_reclaim(6));
-    buf.advance(4);
-    assert_eq!(true, buf.try_reclaim(4));
-    buf.advance(2);
-    assert_eq!(true, buf.try_reclaim(6));
-}
-
-#[test]
-fn split_off_empty_addr() {
-    let mut buf = Bytes::from(vec![0; 1024]);
-
-    let ptr_start = buf.as_ptr();
-    let ptr_end = ptr_start.wrapping_add(1024);
-
-    let empty_end = buf.split_off(1024);
-    assert_eq!(empty_end.len(), 0);
-    assert_eq!(empty_end.as_ptr(), ptr_end);
-
-    let _ = buf.split_off(0);
-    assert_eq!(buf.len(), 0);
-    assert_eq!(buf.as_ptr(), ptr_start);
-
-    // Is miri happy about the provenance?
-    let _ = &empty_end[..];
-    let _ = &buf[..];
-}
-
-#[test]
-fn split_to_empty_addr() {
-    let mut buf = Bytes::from(vec![0; 1024]);
-
-    let ptr_start = buf.as_ptr();
-    let ptr_end = ptr_start.wrapping_add(1024);
-
-    let empty_start = buf.split_to(0);
-    assert_eq!(empty_start.len(), 0);
-    assert_eq!(empty_start.as_ptr(), ptr_start);
-
-    let _ = buf.split_to(1024);
-    assert_eq!(buf.len(), 0);
-    assert_eq!(buf.as_ptr(), ptr_end);
-
-    // Is miri happy about the provenance?
-    let _ = &empty_start[..];
-    let _ = &buf[..];
-}
-
-#[test]
-fn split_off_empty_addr_mut() {
-    let mut buf = BytesMut::from([0; 1024].as_slice());
-
-    let ptr_start = buf.as_ptr();
-    let ptr_end = ptr_start.wrapping_add(1024);
-
-    let empty_end = buf.split_off(1024);
-    assert_eq!(empty_end.len(), 0);
-    assert_eq!(empty_end.as_ptr(), ptr_end);
-
-    let _ = buf.split_off(0);
-    assert_eq!(buf.len(), 0);
-    assert_eq!(buf.as_ptr(), ptr_start);
-
-    // Is miri happy about the provenance?
-    let _ = &empty_end[..];
-    let _ = &buf[..];
-}
-
-#[test]
-fn split_to_empty_addr_mut() {
-    let mut buf = BytesMut::from([0; 1024].as_slice());
-
-    let ptr_start = buf.as_ptr();
-    let ptr_end = ptr_start.wrapping_add(1024);
-
-    let empty_start = buf.split_to(0);
-    assert_eq!(empty_start.len(), 0);
-    assert_eq!(empty_start.as_ptr(), ptr_start);
-
-    let _ = buf.split_to(1024);
-    assert_eq!(buf.len(), 0);
-    assert_eq!(buf.as_ptr(), ptr_end);
-
-    // Is miri happy about the provenance?
-    let _ = &empty_start[..];
-    let _ = &buf[..];
-}
@@ -6,7 +6,7 @@
 use std::alloc::{GlobalAlloc, Layout, System};
 use std::ptr;

-use bytes::{Bytes, BytesMut};
+use bytes::Bytes;

 #[global_allocator]
 static ODD: Odd = Odd;
@@ -24,7 +24,8 @@ unsafe impl GlobalAlloc for Odd {
            };
            let ptr = System.alloc(new_layout);
            if !ptr.is_null() {
-                ptr.offset(1)
+                let ptr = ptr.offset(1);
+                ptr
            } else {
                ptr
            }
@@ -66,82 +67,3 @@ fn test_bytes_clone_drop() {
    let b1 = Bytes::from(vec);
    let _b2 = b1.clone();
 }
-
-#[test]
-fn test_bytes_into_vec() {
-    let vec = vec![33u8; 1024];
-
-    // Test cases where kind == KIND_VEC
-    let b1 = Bytes::from(vec.clone());
-    assert_eq!(Vec::from(b1), vec);
-
-    // Test cases where kind == KIND_ARC, ref_cnt == 1
-    let b1 = Bytes::from(vec.clone());
-    drop(b1.clone());
-    assert_eq!(Vec::from(b1), vec);
-
-    // Test cases where kind == KIND_ARC, ref_cnt == 2
-    let b1 = Bytes::from(vec.clone());
-    let b2 = b1.clone();
-    assert_eq!(Vec::from(b1), vec);
-
-    // Test cases where vtable = SHARED_VTABLE, kind == KIND_ARC, ref_cnt == 1
-    assert_eq!(Vec::from(b2), vec);
-
-    // Test cases where offset != 0
-    let mut b1 = Bytes::from(vec.clone());
-    let b2 = b1.split_off(20);
-
-    assert_eq!(Vec::from(b2), vec[20..]);
-    assert_eq!(Vec::from(b1), vec[..20]);
-}
-
-#[test]
-fn test_bytesmut_from_bytes_vec() {
-    let vec = vec![33u8; 1024];
-
-    // Test case where kind == KIND_VEC
-    let b1 = Bytes::from(vec.clone());
-    let b1m = BytesMut::from(b1);
-    assert_eq!(b1m, vec);
-}
-
-#[test]
-fn test_bytesmut_from_bytes_arc_1() {
-    let vec = vec![33u8; 1024];
-
-    // Test case where kind == KIND_ARC, ref_cnt == 1
-    let b1 = Bytes::from(vec.clone());
-    drop(b1.clone());
-    let b1m = BytesMut::from(b1);
-    assert_eq!(b1m, vec);
-}
-
-#[test]
-fn test_bytesmut_from_bytes_arc_2() {
-    let vec = vec![33u8; 1024];
-
-    // Test case where kind == KIND_ARC, ref_cnt == 2
-    let b1 = Bytes::from(vec.clone());
-    let b2 = b1.clone();
-    let b1m = BytesMut::from(b1);
-    assert_eq!(b1m, vec);
-
-    // Test case where vtable = SHARED_VTABLE, kind == KIND_ARC, ref_cnt == 1
-    let b2m = BytesMut::from(b2);
-    assert_eq!(b2m, vec);
-}
-
-#[test]
-fn test_bytesmut_from_bytes_arc_offset() {
-    let vec = vec![33u8; 1024];
-
-    // Test case where offset != 0
-    let mut b1 = Bytes::from(vec.clone());
-    let b2 = b1.split_off(20);
-    let b1m = BytesMut::from(b1);
-    let b2m = BytesMut::from(b2);
-
-    assert_eq!(b2m, vec[20..]);
-    assert_eq!(b1m, vec[..20]);
-}
@@ -1,87 +1,61 @@
 use std::alloc::{GlobalAlloc, Layout, System};
-use std::ptr::null_mut;
-use std::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
+use std::{mem, ptr};

 use bytes::{Buf, Bytes};

 #[global_allocator]
-static LEDGER: Ledger = Ledger::new();
+static LEDGER: Ledger = Ledger;

-const LEDGER_LENGTH: usize = 2048;
+struct Ledger;

-struct Ledger {
-    alloc_table: [(AtomicPtr<u8>, AtomicUsize); LEDGER_LENGTH],
-}
-
-impl Ledger {
-    const fn new() -> Self {
-        const ELEM: (AtomicPtr<u8>, AtomicUsize) =
-            (AtomicPtr::new(null_mut()), AtomicUsize::new(0));
-        let alloc_table = [ELEM; LEDGER_LENGTH];
-
-        Self { alloc_table }
-    }
-
-    /// Iterate over our table until we find an open entry, then insert into said entry
-    fn insert(&self, ptr: *mut u8, size: usize) {
-        for (entry_ptr, entry_size) in self.alloc_table.iter() {
-            // SeqCst is good enough here, we don't care about perf, i just want to be correct!
-            if entry_ptr
-                .compare_exchange(null_mut(), ptr, Ordering::SeqCst, Ordering::SeqCst)
-                .is_ok()
-            {
-                entry_size.store(size, Ordering::SeqCst);
-                break;
-            }
-        }
-    }
-
-    fn remove(&self, ptr: *mut u8) -> usize {
-        for (entry_ptr, entry_size) in self.alloc_table.iter() {
-            // set the value to be something that will never try and be deallocated, so that we
-            // don't have any chance of a race condition
-            //
-            // dont worry, LEDGER_LENGTH is really long to compensate for us not reclaiming space
-            if entry_ptr
-                .compare_exchange(
-                    ptr,
-                    invalid_ptr(usize::MAX),
-                    Ordering::SeqCst,
-                    Ordering::SeqCst,
-                )
-                .is_ok()
-            {
-                return entry_size.load(Ordering::SeqCst);
-            }
-        }
-
-        panic!("Couldn't find a matching entry for {:x?}", ptr);
-    }
-}
+const USIZE_SIZE: usize = mem::size_of::<usize>();

 unsafe impl GlobalAlloc for Ledger {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        let size = layout.size();
-        let ptr = System.alloc(layout);
-        self.insert(ptr, size);
-        ptr
+        if layout.align() == 1 && layout.size() > 0 {
+            // Allocate extra space to stash a record of
+            // how much space there was.
+            let orig_size = layout.size();
+            let size = orig_size + USIZE_SIZE;
+            let new_layout = match Layout::from_size_align(size, 1) {
+                Ok(layout) => layout,
+                Err(_err) => return ptr::null_mut(),
+            };
+            let ptr = System.alloc(new_layout);
+            if !ptr.is_null() {
+                (ptr as *mut usize).write(orig_size);
+                let ptr = ptr.offset(USIZE_SIZE as isize);
+                ptr
+            } else {
+                ptr
+            }
+        } else {
+            System.alloc(layout)
+        }
    }

    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        let orig_size = self.remove(ptr);
+        if layout.align() == 1 && layout.size() > 0 {
+            let off_ptr = (ptr as *mut usize).offset(-1);
+            let orig_size = off_ptr.read();
+            if orig_size != layout.size() {
+                panic!(
+                    "bad dealloc: alloc size was {}, dealloc size is {}",
+                    orig_size,
+                    layout.size()
+                );
+            }

-        if orig_size != layout.size() {
-            panic!(
-                "bad dealloc: alloc size was {}, dealloc size is {}",
-                orig_size,
-                layout.size()
-            );
+            let new_layout = match Layout::from_size_align(layout.size() + USIZE_SIZE, 1) {
+                Ok(layout) => layout,
+                Err(_err) => std::process::abort(),
+            };
+            System.dealloc(off_ptr as *mut u8, new_layout);
        } else {
            System.dealloc(ptr, layout);
        }
    }
 }
-
 #[test]
 fn test_bytes_advance() {
    let mut bytes = Bytes::from(vec![10, 20, 30]);
@@ -103,41 +77,3 @@ fn test_bytes_truncate_and_advance() {
    bytes.advance(1);
    drop(bytes);
 }
-
-/// Returns a dangling pointer with the given address. This is used to store
-/// integer data in pointer fields.
-#[inline]
-fn invalid_ptr<T>(addr: usize) -> *mut T {
-    let ptr = std::ptr::null_mut::<u8>().wrapping_add(addr);
-    debug_assert_eq!(ptr as usize, addr);
-    ptr.cast::<T>()
-}
-
-#[test]
-fn test_bytes_into_vec() {
-    let vec = vec![33u8; 1024];
-
-    // Test cases where kind == KIND_VEC
-    let b1 = Bytes::from(vec.clone());
-    assert_eq!(Vec::from(b1), vec);
-
-    // Test cases where kind == KIND_ARC, ref_cnt == 1
-    let b1 = Bytes::from(vec.clone());
-    drop(b1.clone());
-    assert_eq!(Vec::from(b1), vec);
-
-    // Test cases where kind == KIND_ARC, ref_cnt == 2
-    let b1 = Bytes::from(vec.clone());
-    let b2 = b1.clone();
-    assert_eq!(Vec::from(b1), vec);
-
-    // Test cases where vtable = SHARED_VTABLE, kind == KIND_ARC, ref_cnt == 1
-    assert_eq!(Vec::from(b2), vec);
-
-    // Test cases where offset != 0
-    let mut b1 = Bytes::from(vec.clone());
-    let b2 = b1.split_off(20);
-
-    assert_eq!(Vec::from(b2), vec[20..]);
-    assert_eq!(Vec::from(b1), vec[..20]);
-}
@@ -133,28 +133,6 @@ fn vectored_read() {
    }
 }

-#[test]
-fn chain_growing_buffer() {
-    let mut buff = [' ' as u8; 10];
-    let mut vec = b"wassup".to_vec();
-
-    let mut chained = (&mut buff[..]).chain_mut(&mut vec).chain_mut(Vec::new()); // Required for potential overflow because remaining_mut for Vec is isize::MAX - vec.len(), but for chain_mut is usize::MAX
-
-    chained.put_slice(b"hey there123123");
-
-    assert_eq!(&buff, b"hey there1");
-    assert_eq!(&vec, b"wassup23123");
-}
-
-#[test]
-fn chain_overflow_remaining_mut() {
-    let mut chained = Vec::<u8>::new().chain_mut(Vec::new()).chain_mut(Vec::new());
-
-    assert_eq!(chained.remaining_mut(), usize::MAX);
-    chained.put_slice(&[0; 256]);
-    assert_eq!(chained.remaining_mut(), usize::MAX);
-}
-
 #[test]
 fn chain_get_bytes() {
    let mut ab = Bytes::copy_from_slice(b"ab");
@@ -1,11 +1,11 @@
 #![warn(rust_2018_idioms)]

-use bytes::{buf::IntoIter, Bytes};
+use bytes::Bytes;

 #[test]
 fn iter_len() {
    let buf = Bytes::from_static(b"hello world");
-    let iter = IntoIter::new(buf);
+    let iter = buf.iter();

    assert_eq!(iter.size_hint(), (11, Some(11)));
    assert_eq!(iter.len(), 11);
@@ -13,8 +13,8 @@ fn iter_len() {

 #[test]
 fn empty_iter_len() {
-    let buf = Bytes::new();
-    let iter = IntoIter::new(buf);
+    let buf = Bytes::from_static(b"");
+    let iter = buf.iter();

    assert_eq!(iter.size_hint(), (0, Some(0)));
    assert_eq!(iter.len(), 0);