Switch to core implicit prelude and only use std where required

By default, all modules in a crate will have the `std::prelude` included implicitly. By marking the crate as `no_std` and then manually adding `std` back using `extern crate std`, we ensure usage of `std` is explicit rather than implicit.

Additionally, we can swap most imports from `std` to `core` and `alloc`. `std` is mostly re-exports of those two crates, so only `std::error` and `std::io` remain used. Further, `std::error` is only used to preserve MSRV, `core::error` provides the same trait.

Author: bushrat011899

src/bufreader.rs

@@ -8,10 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::cmp;
 use std::io;
 use std::io::prelude::*;
-use std::mem;
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+use core::cmp;
+use core::mem;
 
 pub struct BufReader<R> {
     inner: R,
@@ -20,11 +22,11 @@ pub struct BufReader<R> {
     cap: usize,
 }
 
-impl<R> ::std::fmt::Debug for BufReader<R>
+impl<R> ::core::fmt::Debug for BufReader<R>
 where
-    R: ::std::fmt::Debug,
+    R: ::core::fmt::Debug,
 {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
+    fn fmt(&self, fmt: &mut ::core::fmt::Formatter) -> Result<(), ::core::fmt::Error> {
         fmt.debug_struct("BufReader")
             .field("reader", &self.inner)
             .field(

src/deflate/bufread.rs

@@ -1,6 +1,6 @@
 use std::io;
 use std::io::prelude::*;
-use std::mem;
+use core::mem;
 
 use crate::zio;
 use crate::{Compress, Decompress};
@@ -255,6 +255,7 @@ mod test {
     use crate::deflate::write;
     use crate::Compression;
     use std::io::{Read, Write};
+    use alloc::vec::Vec;
 
     // DeflateDecoder consumes one deflate archive and then returns 0 for subsequent reads, allowing any
     // additional data to be consumed by the caller.
@@ -274,7 +275,7 @@ mod test {
         let mut decoder = DeflateDecoder::new(compressed.as_slice());
         let decoded_bytes = decoder.read_to_end(&mut output).unwrap();
         assert_eq!(decoded_bytes, output.len());
-        let actual = std::str::from_utf8(&output).expect("String parsing error");
+        let actual = core::str::from_utf8(&output).expect("String parsing error");
         assert_eq!(
             actual, expected,
             "after decompression we obtain the original input"

src/deflate/mod.rs

@@ -5,6 +5,8 @@ pub mod write;
 #[cfg(test)]
 mod tests {
     use std::io::prelude::*;
+    use alloc::string::ToString;
+    use alloc::vec::Vec;
 
     use rand::{rng, Rng};
 

src/deflate/read.rs

@@ -1,5 +1,6 @@
 use std::io;
 use std::io::prelude::*;
+use alloc::vec::Vec;
 
 use super::bufread;
 use crate::bufreader::BufReader;

src/deflate/write.rs

@@ -329,6 +329,8 @@ impl<W: Read + Write> Read for DeflateDecoder<W> {
 mod tests {
     use super::*;
     use crate::Compression;
+    use alloc::string::String;
+    use alloc::vec::Vec;
 
     const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
         Hello World Hello World Hello World Hello World Hello World \

src/ffi/c.rs

@@ -1,9 +1,10 @@
 //! Implementation for C backends.
-use std::fmt;
-use std::marker;
-use std::mem::MaybeUninit;
-use std::os::raw::{c_int, c_uint};
-use std::ptr;
+use alloc::boxed::Box;
+use core::ffi::{c_int, c_uint};
+use core::fmt;
+use core::marker;
+use core::mem::MaybeUninit;
+use core::ptr;
 
 use super::*;
 use crate::mem;
@@ -71,11 +72,11 @@ impl Drop for StreamWrapper {
 mod allocator {
     use super::*;
 
-    use std::alloc::{self, Layout};
-    use std::convert::TryFrom;
-    use std::os::raw::c_void;
+    use core::alloc::Layout;
+    use core::convert::TryFrom;
+    use core::ffi::c_void;
 
-    const ALIGN: usize = std::mem::align_of::<usize>();
+    const ALIGN: usize = core::mem::align_of::<usize>();
 
     fn align_up(size: usize, align: usize) -> usize {
         (size + align - 1) & !(align - 1)
@@ -90,7 +91,7 @@ mod allocator {
             .checked_mul(item_size)
             .and_then(|i| usize::try_from(i).ok())
             .map(|size| align_up(size, ALIGN))
-            .and_then(|i| i.checked_add(std::mem::size_of::<usize>()))
+            .and_then(|i| i.checked_add(core::mem::size_of::<usize>()))
         {
             Some(i) => i,
             None => return ptr::null_mut(),
@@ -105,7 +106,7 @@ mod allocator {
         unsafe {
             // Allocate the data, and if successful store the size we allocated
             // at the beginning and then return an offset pointer.
-            let ptr = alloc::alloc(layout) as *mut usize;
+            let ptr = ::alloc::alloc::alloc(layout) as *mut usize;
             if ptr.is_null() {
                 return ptr as *mut c_void;
             }
@@ -122,7 +123,7 @@ mod allocator {
             let ptr = (address as *mut usize).offset(-1);
             let size = *ptr;
             let layout = Layout::from_size_align_unchecked(size, ALIGN);
-            alloc::dealloc(ptr as *mut u8, layout)
+            ::alloc::alloc::dealloc(ptr as *mut u8, layout)
         }
     }
 }
@@ -158,8 +159,8 @@ impl<D: Direction> Stream<D> {
         ErrorMessage(if msg.is_null() {
             None
         } else {
-            let s = unsafe { std::ffi::CStr::from_ptr(msg) };
-            std::str::from_utf8(s.to_bytes()).ok()
+            let s = unsafe { core::ffi::CStr::from_ptr(msg) };
+            core::str::from_utf8(s.to_bytes()).ok()
         })
     }
 }
@@ -418,8 +419,8 @@ pub use self::c_backend::*;
 #[allow(bad_style)]
 #[allow(unused_imports)]
 mod c_backend {
-    use std::mem;
-    use std::os::raw::{c_char, c_int};
+    use core::ffi::{c_char, c_int};
+    use core::mem;
 
     #[cfg(feature = "zlib-ng")]
     use libz_ng_sys as libz;

src/ffi/miniz_oxide.rs

@@ -1,7 +1,8 @@
 //! Implementation for `miniz_oxide` rust backend.
 
-use std::convert::TryInto;
-use std::fmt;
+use alloc::boxed::Box;
+use core::convert::TryInto;
+use core::fmt;
 
 use ::miniz_oxide::deflate::core::CompressorOxide;
 use ::miniz_oxide::inflate::stream::InflateState;

src/ffi/mod.rs

@@ -2,7 +2,7 @@
 
 use crate::mem::{CompressError, DecompressError, FlushCompress, FlushDecompress, Status};
 use crate::Compression;
-use std::mem::MaybeUninit;
+use core::mem::MaybeUninit;
 
 fn initialize_buffer(output: &mut [MaybeUninit<u8>]) -> &mut [u8] {
     // SAFETY: Here we zero-initialize the output and cast it to [u8]
@@ -81,8 +81,8 @@ pub use self::miniz_oxide::*;
 #[cfg(not(feature = "any_impl"))]
 compile_error!("No compression backend selected; enable one of `zlib`, `zlib-ng`, `zlib-rs`, or the default `rust_backend` feature.");
 
-impl std::fmt::Debug for ErrorMessage {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::Debug for ErrorMessage {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         self.get().fmt(f)
     }
 }

src/ffi/zlib_rs.rs

@@ -17,7 +17,7 @@
 //! With zlib_rs the state is not self-referential and hence no boxing is needed. The `new` methods
 //! internally do allocate space for the (de)compression state.
 
-use std::fmt;
+use core::fmt;
 
 use ::zlib_rs::{DeflateFlush, InflateError, InflateFlush};
 

src/gz/bufread.rs

@@ -1,7 +1,8 @@
-use std::cmp;
 use std::io;
 use std::io::prelude::*;
-use std::mem;
+use alloc::vec::Vec;
+use core::cmp;
+use core::mem;
 
 use super::{corrupt, read_into, GzBuilder, GzHeader, GzHeaderParser};
 use crate::crc::CrcReader;
@@ -458,6 +459,7 @@ mod test {
     use crate::gz::write;
     use crate::Compression;
     use std::io::{Read, Write};
+    use alloc::vec::Vec;
 
     // GzDecoder consumes one gzip member and then returns 0 for subsequent reads, allowing any
     // additional data to be consumed by the caller.
@@ -477,7 +479,7 @@ mod test {
         let mut decoder = GzDecoder::new(compressed.as_slice());
         let decoded_bytes = decoder.read_to_end(&mut output).unwrap();
         assert_eq!(decoded_bytes, output.len());
-        let actual = std::str::from_utf8(&output).expect("String parsing error");
+        let actual = core::str::from_utf8(&output).expect("String parsing error");
         assert_eq!(
             actual, expected,
             "after decompression we obtain the original input"