Improve derived recursion guard

[jcaesar]

As per your invitation.

Turns

fn arbitrary(u: &mut Unstructured) -> Result<Self> {
    RECURSIVE_COUNT_Nah.with(|count| {
        if count.get() > 0 && u.is_empty() {
            return Err(arbitrary::Error::NotEnoughData);
        }
        count.set(count.get() + 1);
        let result = {
            Ok(
                match (u64::from(<u32 as Arbitrary>::arbitrary(u)?) * 2u64) >> 32 {
                    0u64 => Nah::Foo(Arbitrary::arbitrary(u)?, Arbitrary::arbitrary(u)?, Arbitrary::arbitrary(u)?),
                    1u64 => Nah::Bar(Arbitrary::arbitrary(u)?, Arbitrary::arbitrary(u)?),
                    _ => panic!("internal error: entered unreachable code"),
                },
            )
        };
        count.set(count.get() - 1);
        result
    })
}

into

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Self> {                                                                                                          
    let guard_against_recursion = u.is_empty();                                                                      
    if guard_against_recursion {                                                                                                   
        RECURSIVE_COUNT_Nah.with(|count| {                                                                                                      
            if count.get() > 0 {                                                                                                                               
                return Err(arbitrary::Error::NotEnoughData);       
            }                                                                                                                 
            count.set(count.get() + 1);                                                                                                      
            Ok(())                                                                                                                                          
        })?;                                                                                                                                                               
    }                                                                                                                      
    let result = (|| {                                                                                                                    
        Ok(                                                                                                                                              
            match (u64::from(<u32 as Arbitrary>::arbitrary(u)?) * 2u64) >> 32 {                                                                                         
                0u64 => Nah::Foo(Arbitrary::arbitrary(u)?, Arbitrary::arbitrary(u)?, Arbitrary::arbitrary(u)?),         
                1u64 => Nah::Bar(Arbitrary::arbitrary(u)?, Arbitrary::arbitrary(u)?),                                                  
                _ => ::core::panicking::panic("internal error: entered unreachable code"),                                                          
            },                                                                                                                                                     
        )                                                                                                          
    })();                                                                                                                         
    if guard_against_recursion {                                                                                                                 
        RECURSIVE_COUNT_Nah.with(|count| {                                                                                                                    
            count.set(count.get() - 1);        
        });                                                                                                                  
    }                                                                                                                                       
    result                                                                                                                                                 
}     

I've also wrapped the thread local and impl in a const _: () = {…}; to avoid name clashes. I have no idea whether that's the best way of doing it, but it's what serde does.

[fitzgen]

I've also wrapped the thread local and impl in a const _: () = {…}; to avoid name clashes.

What name clashes are possible, given that we add the type name to the recursion guard's name?

[fitzgen]

Is the immediately-invoked closure here to allow passing things like return 42 as expr?

[jcaesar]

Kinda. It is to stop ? in #expr from aborting the outer function before the recursion counter has been decreased again. Ugly hack in the absence of try blocks.

[fitzgen]

Gotcha, thanks, makes sense.

[jcaesar]

What name clashes are possible, given that we add the type name to the recursion guard's name?

#[derive(Arbitrary)]
struct Foo;

struct RECURSIVE_COUNT_Foo: i32 = 42;

Sure, unlikely that anyone runs into this on accident, but since it's easy to prevent…

[fitzgen]

Thanks!