Use types from core where possible

Author: pitdicker

src/error.rs

@@ -1,4 +1,4 @@
-use std::{error, fmt};
+use core::fmt;
 
 /// An enumeration of buffer creation errors
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -32,12 +32,12 @@ impl fmt::Display for Error {
     }
 }
 
-impl error::Error for Error {}
+impl std::error::Error for Error {}
 
 /// A `Result` with the error type fixed as `arbitrary::Error`.
 ///
 /// Either an `Ok(T)` or `Err(arbitrary::Error)`.
-pub type Result<T, E = Error> = std::result::Result<T, E>;
+pub type Result<T, E = Error> = core::result::Result<T, E>;
 
 #[cfg(test)]
 mod tests {

src/lib.rs

@@ -43,15 +43,15 @@ use core::num::{NonZeroU128, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZ
 use core::ops::{Range, RangeBounds, RangeFrom, RangeInclusive, RangeTo, RangeToInclusive};
 use core::str;
 use core::time::Duration;
+use core::ops::Bound;
+use core::sync::atomic::{AtomicBool, AtomicIsize, AtomicUsize};
 use std::borrow::{Cow, ToOwned};
 use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
 use std::ffi::{CString, OsString};
 use std::hash::BuildHasher;
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
-use std::ops::Bound;
 use std::path::PathBuf;
 use std::rc::Rc;
-use std::sync::atomic::{AtomicBool, AtomicIsize, AtomicUsize};
 use std::sync::{Arc, Mutex};
 
 /// Generate arbitrary structured values from raw, unstructured data.
@@ -381,7 +381,7 @@ impl_arbitrary_for_floats! {
 
 impl<'a> Arbitrary<'a> for char {
     fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
-        use std::char;
+        use core::char;
         // The highest unicode code point is 0x11_FFFF
         const CHAR_END: u32 = 0x11_0000;
         // The size of the surrogate blocks
@@ -560,7 +560,7 @@ impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Option<A> {
     }
 }
 
-impl<'a, A: Arbitrary<'a>, B: Arbitrary<'a>> Arbitrary<'a> for std::result::Result<A, B> {
+impl<'a, A: Arbitrary<'a>, B: Arbitrary<'a>> Arbitrary<'a> for core::result::Result<A, B> {
     fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
         Ok(if <bool as Arbitrary<'a>>::arbitrary(u)? {
             Ok(<A as Arbitrary>::arbitrary(u)?)
@@ -1116,9 +1116,9 @@ impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for iter::Empty<A> {
     }
 }
 
-impl<'a, A: ?Sized> Arbitrary<'a> for ::std::marker::PhantomData<A> {
+impl<'a, A: ?Sized> Arbitrary<'a> for core::marker::PhantomData<A> {
     fn arbitrary(_: &mut Unstructured<'a>) -> Result<Self> {
-        Ok(::std::marker::PhantomData)
+        Ok(core::marker::PhantomData)
     }
 
     #[inline]
@@ -1127,9 +1127,9 @@ impl<'a, A: ?Sized> Arbitrary<'a> for ::std::marker::PhantomData<A> {
     }
 }
 
-impl<'a> Arbitrary<'a> for ::std::marker::PhantomPinned {
+impl<'a> Arbitrary<'a> for core::marker::PhantomPinned {
     fn arbitrary(_: &mut Unstructured<'a>) -> Result<Self> {
-        Ok(::std::marker::PhantomPinned)
+        Ok(core::marker::PhantomPinned)
     }
 
     #[inline]
@@ -1138,9 +1138,9 @@ impl<'a> Arbitrary<'a> for ::std::marker::PhantomPinned {
     }
 }
 
-impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for ::std::num::Wrapping<A> {
+impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for core::num::Wrapping<A> {
     fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
-        Arbitrary::arbitrary(u).map(::std::num::Wrapping)
+        Arbitrary::arbitrary(u).map(core::num::Wrapping)
     }
 
     #[inline]

src/size_hint.rs

@@ -42,10 +42,10 @@ pub fn and_all(hints: &[(usize, Option<usize>)]) -> (usize, Option<usize>) {
 /// `lhs` and `rhs` size hints.
 #[inline]
 pub fn or(lhs: (usize, Option<usize>), rhs: (usize, Option<usize>)) -> (usize, Option<usize>) {
-    let lower = std::cmp::min(lhs.0, rhs.0);
+    let lower = core::cmp::min(lhs.0, rhs.0);
     let upper = lhs
         .1
-        .and_then(|lhs| rhs.1.map(|rhs| std::cmp::max(lhs, rhs)));
+        .and_then(|lhs| rhs.1.map(|rhs| core::cmp::max(lhs, rhs)));
     (lower, upper)
 }
 

src/unstructured.rs

@@ -9,9 +9,9 @@
 //! Wrappers around raw, unstructured bytes.
 
 use crate::{Arbitrary, Error, Result};
-use std::marker::PhantomData;
-use std::ops::ControlFlow;
-use std::{mem, ops};
+use core::marker::PhantomData;
+use core::ops::ControlFlow;
+use core::{mem, ops};
 
 /// A source of unstructured data.
 ///
@@ -186,9 +186,9 @@ impl<'a> Unstructured<'a> {
     ///
     /// ```
     /// use arbitrary::{Arbitrary, Result, Unstructured};
-    /// # pub struct MyCollection<T> { _t: std::marker::PhantomData<T> }
+    /// # pub struct MyCollection<T> { _t: core::marker::PhantomData<T> }
     /// # impl<T> MyCollection<T> {
-    /// #     pub fn with_capacity(capacity: usize) -> Self { MyCollection { _t: std::marker::PhantomData } }
+    /// #     pub fn with_capacity(capacity: usize) -> Self { MyCollection { _t: core::marker::PhantomData } }
     /// #     pub fn insert(&mut self, element: T) {}
     /// # }
     ///
@@ -218,7 +218,7 @@ impl<'a> Unstructured<'a> {
         let byte_size = self.arbitrary_byte_size()?;
         let (lower, upper) = <ElementType as Arbitrary>::size_hint(0);
         let elem_size = upper.unwrap_or(lower * 2);
-        let elem_size = std::cmp::max(1, elem_size);
+        let elem_size = core::cmp::max(1, elem_size);
         Ok(byte_size / elem_size)
     }
 
@@ -238,19 +238,19 @@ impl<'a> Unstructured<'a> {
             // We only consume as many bytes as necessary to cover the entire
             // range of the byte string.
             // Note: We cast to u64 so we don't overflow when checking std::u32::MAX + 4 on 32-bit archs
-            let len = if self.data.len() as u64 <= std::u8::MAX as u64 + 1 {
+            let len = if self.data.len() as u64 <= core::u8::MAX as u64 + 1 {
                 let bytes = 1;
                 let max_size = self.data.len() - bytes;
                 let (rest, for_size) = self.data.split_at(max_size);
                 self.data = rest;
                 Self::int_in_range_impl(0..=max_size as u8, for_size.iter().copied())?.0 as usize
-            } else if self.data.len() as u64 <= std::u16::MAX as u64 + 2 {
+            } else if self.data.len() as u64 <= core::u16::MAX as u64 + 2 {
                 let bytes = 2;
                 let max_size = self.data.len() - bytes;
                 let (rest, for_size) = self.data.split_at(max_size);
                 self.data = rest;
                 Self::int_in_range_impl(0..=max_size as u16, for_size.iter().copied())?.0 as usize
-            } else if self.data.len() as u64 <= std::u32::MAX as u64 + 4 {
+            } else if self.data.len() as u64 <= core::u32::MAX as u64 + 4 {
                 let bytes = 4;
                 let max_size = self.data.len() - bytes;
                 let (rest, for_size) = self.data.split_at(max_size);
@@ -520,7 +520,7 @@ impl<'a> Unstructured<'a> {
     /// assert_eq!(buf, [0, 0]);
     /// ```
     pub fn fill_buffer(&mut self, buffer: &mut [u8]) -> Result<()> {
-        let n = std::cmp::min(buffer.len(), self.data.len());
+        let n = core::cmp::min(buffer.len(), self.data.len());
         buffer[..n].copy_from_slice(&self.data[..n]);
         for byte in buffer[n..].iter_mut() {
             *byte = 0;
@@ -764,7 +764,7 @@ impl<'a, ElementType: Arbitrary<'a>> Iterator for ArbitraryTakeRestIter<'a, Elem
 /// Don't implement this trait yourself.
 pub trait Int:
     Copy
-    + std::fmt::Debug
+    + core::fmt::Debug
     + PartialOrd
     + Ord
     + ops::Sub<Self, Output = Self>