Replace (usize, Option<usize>) with custom type SizeHint and eliminate try_size_hint().

The `SizeHint` type provides these advantages:

* Easier to construct by composition, using `&` and `|` or methods.
* More self-explanatory.
* Distinguishes between “unknown size” and “known to be unbounded”
  to aid debugging.

Since this is a breaking change to the trait, this commit also makes the
closely related change of combining `try_size_hint()` and `size_hint()`
into a single fallible function. This will make it easier to correctly
implement the trait.

Also, while I was touching the macro code, I made all the crate paths
absolute (`::arbitrary`), as they should be for the maximum compatibility.

Author: kpreid

derive/src/lib.rs

@@ -64,7 +64,7 @@ fn expand_derive_arbitrary(input: syn::DeriveInput) -> Result<TokenStream> {
             }
 
             #[automatically_derived]
-            impl #impl_generics arbitrary::Arbitrary<#lifetime_without_bounds> for #name #ty_generics #where_clause {
+            impl #impl_generics ::arbitrary::Arbitrary<#lifetime_without_bounds> for #name #ty_generics #where_clause {
                 #arbitrary_method
                 #size_hint_method
             }
@@ -141,7 +141,7 @@ fn add_trait_bounds(mut generics: Generics, lifetime: LifetimeParam) -> Generics
         if let GenericParam::Type(type_param) = param {
             type_param
                 .bounds
-                .push(parse_quote!(arbitrary::Arbitrary<#lifetime>));
+                .push(parse_quote!(::arbitrary::Arbitrary<#lifetime>));
         }
     }
     generics
@@ -156,7 +156,7 @@ fn with_recursive_count_guard(
         if guard_against_recursion {
             #recursive_count.with(|count| {
                 if count.get() > 0 {
-                    return Err(arbitrary::Error::NotEnoughData);
+                    return Err(::arbitrary::Error::NotEnoughData);
                 }
                 count.set(count.get() + 1);
                 Ok(())
@@ -194,11 +194,11 @@ fn gen_arbitrary_method(
             with_recursive_count_guard(recursive_count, quote! { Ok(#ident #arbitrary_take_rest) });
 
         Ok(quote! {
-            fn arbitrary(u: &mut arbitrary::Unstructured<#lifetime>) -> arbitrary::Result<Self> {
+            fn arbitrary(u: &mut ::arbitrary::Unstructured<#lifetime>) -> ::arbitrary::Result<Self> {
                 #body
             }
 
-            fn arbitrary_take_rest(mut u: arbitrary::Unstructured<#lifetime>) -> arbitrary::Result<Self> {
+            fn arbitrary_take_rest(mut u: ::arbitrary::Unstructured<#lifetime>) -> ::arbitrary::Result<Self> {
                 #take_rest_body
             }
         })
@@ -225,7 +225,7 @@ fn gen_arbitrary_method(
                 // Use a multiply + shift to generate a ranged random number
                 // with slight bias. For details, see:
                 // https://lemire.me/blog/2016/06/30/fast-random-shuffling
-                Ok(match (u64::from(<u32 as arbitrary::Arbitrary>::arbitrary(#unstructured)?) * #count) >> 32 {
+                Ok(match (u64::from(<u32 as ::arbitrary::Arbitrary>::arbitrary(#unstructured)?) * #count) >> 32 {
                     #(#variants,)*
                     _ => unreachable!()
                 })
@@ -279,11 +279,11 @@ fn gen_arbitrary_method(
                 let arbitrary_take_rest = arbitrary_enum_method(recursive_count, quote! { &mut u }, &variants_take_rest);
 
                 quote! {
-                    fn arbitrary(u: &mut arbitrary::Unstructured<#lifetime>) -> arbitrary::Result<Self> {
+                    fn arbitrary(u: &mut ::arbitrary::Unstructured<#lifetime>) -> ::arbitrary::Result<Self> {
                         #arbitrary
                     }
 
-                    fn arbitrary_take_rest(mut u: arbitrary::Unstructured<#lifetime>) -> arbitrary::Result<Self> {
+                    fn arbitrary_take_rest(mut u: ::arbitrary::Unstructured<#lifetime>) -> ::arbitrary::Result<Self> {
                         #arbitrary_take_rest
                     }
                 }
@@ -344,9 +344,9 @@ fn construct_take_rest(fields: &Fields) -> Result<TokenStream> {
             FieldConstructor::Default => quote!(::core::default::Default::default()),
             FieldConstructor::Arbitrary => {
                 if idx + 1 == fields.len() {
-                    quote! { arbitrary::Arbitrary::arbitrary_take_rest(u)? }
+                    quote! { ::arbitrary::Arbitrary::arbitrary_take_rest(u)? }
                 } else {
-                    quote! { arbitrary::Arbitrary::arbitrary(&mut u)? }
+                    quote! { ::arbitrary::Arbitrary::arbitrary(&mut u)? }
                 }
             }
             FieldConstructor::With(function_or_closure) => quote!((#function_or_closure)(&mut u)?),
@@ -364,25 +364,25 @@ fn gen_size_hint_method(input: &DeriveInput) -> Result<TokenStream> {
                 determine_field_constructor(f).map(|field_constructor| {
                     match field_constructor {
                         FieldConstructor::Default | FieldConstructor::Value(_) => {
-                            quote!(Ok((0, Some(0))))
+                            quote!(Ok(::arbitrary::SizeHint::exactly(0)))
                         }
                         FieldConstructor::Arbitrary => {
-                            quote! { <#ty as arbitrary::Arbitrary>::try_size_hint(depth) }
+                            quote! { <#ty as ::arbitrary::Arbitrary>::size_hint(depth) }
                         }
 
                         // Note that in this case it's hard to determine what size_hint must be, so size_of::<T>() is
                         // just an educated guess, although it's gonna be inaccurate for dynamically
                         // allocated types (Vec, HashMap, etc.).
                         FieldConstructor::With(_) => {
-                            quote! { Ok((::core::mem::size_of::<#ty>(), None)) }
+                            quote! { Ok(::arbitrary::SizeHint::at_least(::core::mem::size_of::<#ty>())) }
                         }
                     }
                 })
             })
             .collect::<Result<Vec<TokenStream>>>()
             .map(|hints| {
                 quote! {
-                    Ok(arbitrary::size_hint::and_all(&[
+                    Ok(::arbitrary::SizeHint::and_all(&[
                         #( #hints? ),*
                     ]))
                 }
@@ -392,13 +392,8 @@ fn gen_size_hint_method(input: &DeriveInput) -> Result<TokenStream> {
         size_hint_fields(fields).map(|hint| {
             quote! {
                 #[inline]
-                fn size_hint(depth: usize) -> (usize, ::core::option::Option<usize>) {
-                    Self::try_size_hint(depth).unwrap_or_default()
-                }
-
-                #[inline]
-                fn try_size_hint(depth: usize) -> ::core::result::Result<(usize, ::core::option::Option<usize>), arbitrary::MaxRecursionReached> {
-                    arbitrary::size_hint::try_recursion_guard(depth, |depth| #hint)
+                fn size_hint(depth: usize) -> ::core::result::Result<::arbitrary::SizeHint, ::arbitrary::MaxRecursionReached> {
+                    ::arbitrary::SizeHint::recursion_guard(depth, |depth| #hint)
                 }
             }
         })
@@ -418,15 +413,12 @@ fn gen_size_hint_method(input: &DeriveInput) -> Result<TokenStream> {
             .collect::<Result<Vec<TokenStream>>>()
             .map(|variants| {
                 quote! {
-                    fn size_hint(depth: usize) -> (usize, ::core::option::Option<usize>) {
-                        Self::try_size_hint(depth).unwrap_or_default()
-                    }
                     #[inline]
-                    fn try_size_hint(depth: usize) -> ::core::result::Result<(usize, ::core::option::Option<usize>), arbitrary::MaxRecursionReached> {
-                        Ok(arbitrary::size_hint::and(
-                            <u32 as arbitrary::Arbitrary>::try_size_hint(depth)?,
-                            arbitrary::size_hint::try_recursion_guard(depth, |depth| {
-                                Ok(arbitrary::size_hint::or_all(&[ #( #variants? ),* ]))
+                    fn size_hint(depth: usize) -> ::core::result::Result<::arbitrary::SizeHint, ::arbitrary::MaxRecursionReached> {
+                        Ok(::arbitrary::SizeHint::and(
+                            <u32 as ::arbitrary::Arbitrary>::size_hint(depth)?,
+                            ::arbitrary::SizeHint::recursion_guard(depth, |depth| {
+                                Ok(::arbitrary::SizeHint::or_all(&[ #( #variants? ),* ]))
                             })?,
                         ))
                     }
@@ -438,7 +430,7 @@ fn gen_size_hint_method(input: &DeriveInput) -> Result<TokenStream> {
 fn gen_constructor_for_field(field: &Field) -> Result<TokenStream> {
     let ctor = match determine_field_constructor(field)? {
         FieldConstructor::Default => quote!(::core::default::Default::default()),
-        FieldConstructor::Arbitrary => quote!(arbitrary::Arbitrary::arbitrary(u)?),
+        FieldConstructor::Arbitrary => quote!(::arbitrary::Arbitrary::arbitrary(u)?),
         FieldConstructor::With(function_or_closure) => quote!((#function_or_closure)(u)?),
         FieldConstructor::Value(value) => quote!(#value),
     };

src/foreign/alloc/borrow.rs

@@ -1,5 +1,5 @@
 use {
-    crate::{size_hint, Arbitrary, Result, Unstructured},
+    crate::{Arbitrary, Result, SizeHint, Unstructured},
     std::borrow::{Cow, ToOwned},
 };
 
@@ -13,14 +13,9 @@ where
     }
 
     #[inline]
-    fn size_hint(depth: usize) -> (usize, Option<usize>) {
-        Self::try_size_hint(depth).unwrap_or_default()
-    }
-
-    #[inline]
-    fn try_size_hint(depth: usize) -> Result<(usize, Option<usize>), crate::MaxRecursionReached> {
-        size_hint::try_recursion_guard(depth, |depth| {
-            <<A as ToOwned>::Owned as Arbitrary>::try_size_hint(depth)
+    fn size_hint(depth: usize) -> Result<SizeHint, crate::MaxRecursionReached> {
+        SizeHint::recursion_guard(depth, |depth| {
+            <<A as ToOwned>::Owned as Arbitrary>::size_hint(depth)
         })
     }
 }

src/foreign/alloc/boxed.rs

@@ -1,5 +1,5 @@
 use {
-    crate::{size_hint, Arbitrary, Result, Unstructured},
+    crate::{Arbitrary, MaxRecursionReached, Result, SizeHint, Unstructured},
     std::boxed::Box,
 };
 
@@ -12,13 +12,8 @@ where
     }
 
     #[inline]
-    fn size_hint(depth: usize) -> (usize, Option<usize>) {
-        Self::try_size_hint(depth).unwrap_or_default()
-    }
-
-    #[inline]
-    fn try_size_hint(depth: usize) -> Result<(usize, Option<usize>), crate::MaxRecursionReached> {
-        size_hint::try_recursion_guard(depth, <A as Arbitrary>::try_size_hint)
+    fn size_hint(depth: usize) -> Result<SizeHint, crate::MaxRecursionReached> {
+        SizeHint::recursion_guard(depth, <A as Arbitrary>::size_hint)
     }
 }
 
@@ -35,8 +30,8 @@ where
     }
 
     #[inline]
-    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
-        (0, None)
+    fn size_hint(_depth: usize) -> Result<SizeHint, MaxRecursionReached> {
+        Ok(SizeHint::at_least(0))
     }
 }
 
@@ -46,7 +41,7 @@ impl<'a> Arbitrary<'a> for Box<str> {
     }
 
     #[inline]
-    fn size_hint(depth: usize) -> (usize, Option<usize>) {
+    fn size_hint(depth: usize) -> Result<SizeHint, MaxRecursionReached> {
         <String as Arbitrary>::size_hint(depth)
     }
 }

src/foreign/alloc/collections/binary_heap.rs

@@ -1,5 +1,5 @@
 use {
-    crate::{Arbitrary, Result, Unstructured},
+    crate::{Arbitrary, MaxRecursionReached, Result, SizeHint, Unstructured},
     std::collections::binary_heap::BinaryHeap,
 };
 
@@ -16,7 +16,7 @@ where
     }
 
     #[inline]
-    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
-        (0, None)
+    fn size_hint(_depth: usize) -> Result<SizeHint, MaxRecursionReached> {
+        Ok(SizeHint::at_least(0))
     }
 }

src/foreign/alloc/collections/btree_map.rs

@@ -1,5 +1,5 @@
 use {
-    crate::{Arbitrary, Result, Unstructured},
+    crate::{Arbitrary, MaxRecursionReached, Result, SizeHint, Unstructured},
     std::collections::btree_map::BTreeMap,
 };
 
@@ -17,7 +17,7 @@ where
     }
 
     #[inline]
-    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
-        (0, None)
+    fn size_hint(_depth: usize) -> Result<SizeHint, MaxRecursionReached> {
+        Ok(SizeHint::at_least(0))
     }
 }

src/foreign/alloc/collections/btree_set.rs

@@ -1,5 +1,5 @@
 use {
-    crate::{Arbitrary, Result, Unstructured},
+    crate::{Arbitrary, MaxRecursionReached, Result, SizeHint, Unstructured},
     std::collections::btree_set::BTreeSet,
 };
 
@@ -16,7 +16,7 @@ where
     }
 
     #[inline]
-    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
-        (0, None)
+    fn size_hint(_depth: usize) -> Result<SizeHint, MaxRecursionReached> {
+        Ok(SizeHint::at_least(0))
     }
 }

src/foreign/alloc/collections/linked_list.rs

@@ -1,5 +1,5 @@
 use {
-    crate::{Arbitrary, Result, Unstructured},
+    crate::{Arbitrary, MaxRecursionReached, Result, SizeHint, Unstructured},
     std::collections::linked_list::LinkedList,
 };
 
@@ -16,7 +16,7 @@ where
     }
 
     #[inline]
-    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
-        (0, None)
+    fn size_hint(_depth: usize) -> Result<SizeHint, MaxRecursionReached> {
+        Ok(SizeHint::at_least(0))
     }
 }

src/foreign/alloc/collections/vec_deque.rs

@@ -1,5 +1,5 @@
 use {
-    crate::{Arbitrary, Result, Unstructured},
+    crate::{Arbitrary, MaxRecursionReached, Result, SizeHint, Unstructured},
     std::collections::vec_deque::VecDeque,
 };
 
@@ -16,7 +16,7 @@ where
     }
 
     #[inline]
-    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
-        (0, None)
+    fn size_hint(_depth: usize) -> Result<SizeHint, MaxRecursionReached> {
+        Ok(SizeHint::at_least(0))
     }
 }

src/foreign/alloc/ffi/c_str.rs

@@ -1,5 +1,5 @@
 use {
-    crate::{Arbitrary, Result, Unstructured},
+    crate::{Arbitrary, MaxRecursionReached, Result, SizeHint, Unstructured},
     std::ffi::CString,
 };
 
@@ -13,7 +13,7 @@ impl<'a> Arbitrary<'a> for CString {
     }
 
     #[inline]
-    fn size_hint(depth: usize) -> (usize, Option<usize>) {
+    fn size_hint(depth: usize) -> Result<SizeHint, MaxRecursionReached> {
         <Vec<u8> as Arbitrary>::size_hint(depth)
     }
 }

src/foreign/alloc/rc.rs

@@ -1,5 +1,5 @@
 use {
-    crate::{size_hint, Arbitrary, Result, Unstructured},
+    crate::{Arbitrary, MaxRecursionReached, Result, SizeHint, Unstructured},
     std::rc::Rc,
 };
 
@@ -12,13 +12,8 @@ where
     }
 
     #[inline]
-    fn size_hint(depth: usize) -> (usize, Option<usize>) {
-        Self::try_size_hint(depth).unwrap_or_default()
-    }
-
-    #[inline]
-    fn try_size_hint(depth: usize) -> Result<(usize, Option<usize>), crate::MaxRecursionReached> {
-        size_hint::try_recursion_guard(depth, <A as Arbitrary>::try_size_hint)
+    fn size_hint(depth: usize) -> Result<SizeHint, crate::MaxRecursionReached> {
+        SizeHint::recursion_guard(depth, <A as Arbitrary>::size_hint)
     }
 }
 
@@ -35,8 +30,8 @@ where
     }
 
     #[inline]
-    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
-        (0, None)
+    fn size_hint(_depth: usize) -> Result<SizeHint, MaxRecursionReached> {
+        Ok(SizeHint::at_least(0))
     }
 }
 
@@ -46,7 +41,7 @@ impl<'a> Arbitrary<'a> for Rc<str> {
     }
 
     #[inline]
-    fn size_hint(depth: usize) -> (usize, Option<usize>) {
+    fn size_hint(depth: usize) -> Result<SizeHint, MaxRecursionReached> {
         <&str as Arbitrary>::size_hint(depth)
     }
 }

src/foreign/alloc/string.rs

@@ -1,5 +1,5 @@
 use {
-    crate::{Arbitrary, Result, Unstructured},
+    crate::{Arbitrary, MaxRecursionReached, Result, SizeHint, Unstructured},
     std::string::String,
 };
 
@@ -13,7 +13,7 @@ impl<'a> Arbitrary<'a> for String {
     }
 
     #[inline]
-    fn size_hint(depth: usize) -> (usize, Option<usize>) {
+    fn size_hint(depth: usize) -> Result<SizeHint, MaxRecursionReached> {
         <&str as Arbitrary>::size_hint(depth)
     }
 }