update MSRV to 1.70, use OnceLock, remove doc_auto_cfg

Author: sunshowers

.github/workflows/ci.yml

@@ -46,17 +46,10 @@ jobs:
     strategy:
       matrix:
         os: [ ubuntu-latest ]
-        # 1.39 is the MSRV
-        # The rest correspond to version gating in build.rs.
+        # 1.70 is the MSRV
         rust-version:
-          - version: 1.39
-            build-features-excluded: 'tokio1'
-          - version: 1.51
-            build-features-excluded: ''
-          - version: 1.61
-            build-features-excluded: ''
-          - version: stable
-            build-features-excluded: ''
+          - "1.70"
+          - stable
       fail-fast: false
     env:
       RUSTFLAGS: -D warnings
@@ -73,11 +66,11 @@ jobs:
           cargo hack build --feature-powerset \
             --exclude-features "${{ matrix.rust-version.build-features-excluded }}"
       - name: Test
-        # Dev dependencies have an MSRV > 1.39.
+        # Dev dependencies have an MSRV > 1.70.
         if: ${{ matrix.rust-version.version == 'stable' }}
         run: cargo hack test --feature-powerset
       - name: Test with updated Cargo.lock
-        # Dev dependencies have an MSRV > 1.39.
+        # Dev dependencies have an MSRV > 1.70.
         if: ${{ matrix.rust-version.version == 'stable' }}
         run: |
           cargo update

Cargo.lock

@@ -10,14 +10,16 @@ readme = "README.md"
 repository = "https://github.com/sunshowers-code/buf-list"
 rust-version = "1.39"
 
+[lints]
+rust.unexpected_cfgs = { level = "warn", check-cfg = ["cfg(doc_cfg)"] }
+
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg=doc_cfg"]
 
 [dependencies]
 bytes = "1.3.0"
 futures-io-03 = { package = "futures-io", version = "0.3.25", optional = true }
-once_cell = "1.4.0"
 tokio = { version = "1.0.0", features = ["io-std"], optional = true }
 
 [dev-dependencies]

Cargo.toml

@@ -83,27 +83,10 @@ impl<T: AsRef<BufList>> Cursor<T> {
     ///
     /// let reference = cursor.get_ref();
     /// ```
-    #[cfg(const_fn_trait_bounds)]
     pub const fn get_ref(&self) -> &T {
         &self.inner
     }
 
-    /// Gets a reference to the underlying value in this cursor.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use buf_list::{BufList, Cursor};
-    ///
-    /// let cursor = Cursor::new(BufList::new());
-    ///
-    /// let reference = cursor.get_ref();
-    /// ```
-    #[cfg(not(const_fn_trait_bounds))]
-    pub fn get_ref(&self) -> &T {
-        &self.inner
-    }
-
     /// Returns the current position of this cursor.
     ///
     /// # Examples
@@ -123,35 +106,10 @@ impl<T: AsRef<BufList>> Cursor<T> {
     /// cursor.seek(SeekFrom::Current(-1)).unwrap();
     /// assert_eq!(cursor.position(), 1);
     /// ```
-    #[cfg(const_fn_trait_bounds)]
     pub const fn position(&self) -> u64 {
         self.data.pos
     }
 
-    /// Returns the current position of this cursor.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use buf_list::{BufList, Cursor};
-    /// use std::io::prelude::*;
-    /// use std::io::SeekFrom;
-    ///
-    /// let mut cursor = Cursor::new(BufList::from(&[1, 2, 3, 4, 5][..]));
-    ///
-    /// assert_eq!(cursor.position(), 0);
-    ///
-    /// cursor.seek(SeekFrom::Current(2)).unwrap();
-    /// assert_eq!(cursor.position(), 2);
-    ///
-    /// cursor.seek(SeekFrom::Current(-1)).unwrap();
-    /// assert_eq!(cursor.position(), 1);
-    /// ```
-    #[cfg(not(const_fn_trait_bounds))]
-    pub fn position(&self) -> u64 {
-        self.data.pos
-    }
-
     /// Sets the position of this cursor.
     ///
     /// # Examples
@@ -206,7 +164,6 @@ impl<T: AsRef<BufList>> io::Seek for Cursor<T> {
         self.data.seek_impl(self.inner.as_ref(), style)
     }
 
-    #[cfg(seek_convenience)]
     fn stream_position(&mut self) -> io::Result<u64> {
         Ok(self.data.pos)
     }
@@ -366,7 +323,7 @@ impl CursorData {
         Ok(())
     }
 
-    fn fill_buf_impl<'a>(&'a self, list: &'a BufList) -> &[u8] {
+    fn fill_buf_impl<'a>(&'a self, list: &'a BufList) -> &'a [u8] {
         const EMPTY_SLICE: &[u8] = &[];
         match self.get_chunk_and_pos(list) {
             Some((chunk, chunk_pos)) => &chunk.as_ref()[chunk_pos..],

build.rs

@@ -3,11 +3,11 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use bytes::{Buf, BufMut, Bytes, BytesMut};
-use once_cell::sync::OnceCell;
 use std::{
     collections::VecDeque,
     io::IoSlice,
     iter::{FromIterator, FusedIterator},
+    sync::OnceLock,
 };
 
 /// Data composed of a list of [`Bytes`] chunks.
@@ -20,7 +20,7 @@ pub struct BufList {
 
     /// An index of chunks and their start positions. There's an additional index at the end, which
     /// is the length of the list (list.num_bytes()).
-    start_pos: OnceCell<Box<[u64]>>,
+    start_pos: OnceLock<Box<[u64]>>,
 }
 
 impl BufList {
@@ -50,7 +50,7 @@ impl BufList {
     pub fn with_capacity(capacity: usize) -> Self {
         Self {
             bufs: VecDeque::with_capacity(capacity),
-            start_pos: OnceCell::new(),
+            start_pos: OnceLock::new(),
         }
     }
 
@@ -133,8 +133,8 @@ impl BufList {
     /// assert_eq!(buf_list.num_chunks(), 2);
     /// ```
     pub fn push_chunk<B: Buf>(&mut self, mut data: B) -> Bytes {
-        // mutable borrow acquired, invalidate oncecell
-        self.start_pos = OnceCell::new();
+        // mutable borrow acquired, invalidate the OnceLock
+        self.start_pos = OnceLock::new();
 
         let len = data.remaining();
         // `data` is (almost) certainly a `Bytes`, so `copy_to_bytes` should
@@ -155,8 +155,8 @@ impl BufList {
 
 impl<B: Buf> Extend<B> for BufList {
     fn extend<T: IntoIterator<Item = B>>(&mut self, iter: T) {
-        // mutable borrow acquired, invalidate oncecell
-        self.start_pos = OnceCell::new();
+        // mutable borrow acquired, invalidate the OnceLock
+        self.start_pos = OnceLock::new();
 
         for buf in iter.into_iter() {
             self.push_chunk(buf);
@@ -231,8 +231,8 @@ impl Buf for BufList {
     }
 
     fn advance(&mut self, mut amt: usize) {
-        // mutable borrow acquired, invalidate oncecell
-        self.start_pos = OnceCell::new();
+        // mutable borrow acquired, invalidate the OnceLock
+        self.start_pos = OnceLock::new();
 
         while amt > 0 {
             let rem = self.bufs[0].remaining();
@@ -254,8 +254,8 @@ impl Buf for BufList {
     }
 
     fn copy_to_bytes(&mut self, len: usize) -> Bytes {
-        // mutable borrow acquired, invalidate oncecell
-        self.start_pos = OnceCell::new();
+        // mutable borrow acquired, invalidate the OnceLock
+        self.start_pos = OnceLock::new();
 
         // If the length of the requested `Bytes` is <= the length of the front
         // buffer, we can just use its `copy_to_bytes` implementation (which is

src/cursor/mod.rs

@@ -4,8 +4,7 @@
 
 #![forbid(unsafe_code)]
 #![warn(missing_docs)]
-#![cfg_attr(doc_cfg, feature(doc_cfg, doc_auto_cfg, doc_cfg_hide))]
-#![cfg_attr(doc_cfg, doc(cfg_hide(const_fn_trait_bounds)))]
+#![cfg_attr(doc_cfg, feature(doc_cfg))]
 
 //! A segmented list of [`bytes::Bytes`] chunks.
 //!