fix: use autocfg to detect rustc version (#7)

* feat: autocfg

* ci: general improvement

remove targets, add toolchains, introduce cargo-hack

* feat: bump to 0.2.1

Author: AsakuraMizu

.github/workflows/ci.yml

@@ -8,26 +8,29 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        rust-toolchain: [nightly]
-        targets: [x86_64-unknown-linux-gnu, x86_64-unknown-none, riscv64gc-unknown-none-elf, aarch64-unknown-none-softfloat]
+        rust-toolchain: 
+        - nightly
+        - nightly-2025-05-20
+        - nightly-2025-12-12
+        - stable
+    env:
+      RUSTC_BOOTSTRAP: "${{ matrix.rust-toolchain == 'stable' && '1' || '' }}"
     steps:
     - uses: actions/checkout@v4
     - uses: dtolnay/rust-toolchain@nightly
       with:
         toolchain: ${{ matrix.rust-toolchain }}
         components: rust-src, clippy, rustfmt
-        targets: ${{ matrix.targets }}
     - name: Check rust version
       run: rustc --version --verbose
     - name: Check code format
-      run: cargo fmt --all -- --check
+      run: cargo fmt --all --check
+
+    - uses: taiki-e/install-action@cargo-hack
     - name: Clippy
-      run: cargo clippy --target ${{ matrix.targets }} --all-features -- -A clippy::new_without_default
-    - name: Build
-      run: cargo build --target ${{ matrix.targets }} --all-features
+      run: cargo hack clippy --feature-powerset
     - name: Unit test
-      if: ${{ matrix.targets == 'x86_64-unknown-linux-gnu' }}
-      run: cargo test --target ${{ matrix.targets }} -- --nocapture
+      run: cargo hack test --feature-powerset -- --nocapture
 
   doc:
     runs-on: ubuntu-latest

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "axio"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 authors = ["Yuekai Jia <equation618@gmail.com>"]
 description = "`std::io`-like I/O traits for `no_std` environment"
@@ -17,3 +17,6 @@ default = []
 
 [dependencies]
 axerrno = "0.1"
+
+[build-dependencies]
+autocfg = "1"

build.rs

@@ -0,0 +1,16 @@
+fn main() {
+    autocfg::emit_possibility("borrowedbuf_init");
+    autocfg::rerun_path("build.rs");
+
+    let ac = autocfg::new();
+    let code = r#"
+        #![no_std]
+        #![feature(core_io_borrowed_buf)]
+        pub fn probe() {
+            let _ = core::io::BorrowedBuf::init_len;
+        }
+    "#;
+    if ac.probe_raw(code).is_ok() {
+        autocfg::emit("borrowedbuf_init");
+    }
+}

src/lib.rs

@@ -3,6 +3,7 @@
 #![cfg_attr(not(doc), no_std)]
 #![feature(doc_cfg)]
 #![feature(core_io_borrowed_buf)]
+#![cfg_attr(not(borrowedbuf_init), feature(maybe_uninit_fill))]
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
@@ -67,6 +68,11 @@ pub fn default_read_to_end<R: Read + ?Sized>(
         }
     }
 
+    #[cfg(borrowedbuf_init)]
+    let mut initialized = 0; // Extra initialized bytes from previous loop iteration
+    #[cfg(borrowedbuf_init)]
+    let mut consecutive_short_reads = 0;
+
     loop {
         if buf.len() == buf.capacity() && buf.capacity() == start_cap {
             // The buffer might be an exact fit. Let's read into a probe buffer
@@ -92,15 +98,35 @@ pub fn default_read_to_end<R: Read + ?Sized>(
         spare = &mut spare[..buf_len];
         let mut read_buf: BorrowedBuf<'_> = spare.into();
 
+        #[cfg(borrowedbuf_init)]
+        // SAFETY: These bytes were initialized but not filled in the previous loop
+        unsafe {
+            read_buf.set_init(initialized);
+        }
+
         let mut cursor = read_buf.unfilled();
         // Difference from `std`: We don't have a `read_buf` method that returns both data and an error, so we return early on error.
-        let n = r.read(unsafe { cursor.as_mut().assume_init_mut() })?;
-        assert!(n <= cursor.capacity());
-        unsafe {
+        #[cfg(borrowedbuf_init)]
+        {
+            let n = r.read(cursor.ensure_init().init_mut())?;
             cursor.advance(n);
         }
+        #[cfg(not(borrowedbuf_init))]
+        {
+            // SAFETY: We do not uninitialize any part of the buffer.
+            let n = r.read(unsafe { cursor.as_mut().write_filled(0) })?;
+            assert!(n <= cursor.capacity());
+            // SAFETY: We've initialized the entire buffer, and `read` can't make it uninitialized.
+            unsafe {
+                cursor.advance(n);
+            }
+        }
 
+        #[cfg(borrowedbuf_init)]
+        let unfilled_but_initialized = cursor.init_mut().len();
         let bytes_read = cursor.written();
+        #[cfg(borrowedbuf_init)]
+        let was_fully_initialized = read_buf.init_len() == buf_len;
 
         // SAFETY: BorrowedBuf's invariants mean this much memory is initialized.
         unsafe {
@@ -112,8 +138,32 @@ pub fn default_read_to_end<R: Read + ?Sized>(
             return Ok(buf.len() - start_len);
         }
 
+        #[cfg(borrowedbuf_init)]
+        if bytes_read < buf_len {
+            consecutive_short_reads += 1;
+        } else {
+            consecutive_short_reads = 0;
+        }
+
+        #[cfg(borrowedbuf_init)]
+        {
+            // store how much was initialized but not filled
+            initialized = unfilled_but_initialized;
+        }
+
         // Use heuristics to determine the max read size if no initial size hint was provided
         if size_hint.is_none() {
+            #[cfg(borrowedbuf_init)]
+            // The reader is returning short reads but it doesn't call ensure_init().
+            // In that case we no longer need to restrict read sizes to avoid
+            // initialization costs.
+            // When reading from disk we usually don't get any short reads except at EOF.
+            // So we wait for at least 2 short reads before uncapping the read buffer;
+            // this helps with the Windows issue.
+            if !was_fully_initialized && consecutive_short_reads > 1 {
+                max_read_size = usize::MAX;
+            }
+
             // we have passed a larger buffer than previously and the
             // reader still hasn't returned a short read
             if buf_len >= max_read_size && bytes_read == buf_len {