Move handling of #[nested] to Visitor

[taiki-e]

In the current implementation, enum is generated for each #[auto_enum] and #[nested] is only effective on the last expression of each branch. This PR changes #[nested] to be applicable to all branches in each branch.

#[nested] can be used basically in the same place as #[auto_enum], except that #[nested] cannot be used in functions.

Examples

#[auto_enum(Iterator)]
let z = if x {
    #[nested]
    let z = if y { 
        iter.map(|i| /* do something */)
    } else {
        iter.flat_map(|i| /* do something */)
    };
    // do something
    z
} else {
    std::iter::empty()
}

#[auto_enum(Iterator)]
let z = if x {
    #[nested]
    let z = match y { 
        Some(iter) => iter.flat_map(|i| /* do something */),
        None => make_new_iter().map(|i| /* do something */),
    };
    // do something
    z
} else {
    std::iter::empty()
}

Closes #64

[taiki-e]

bors r+

[bors]

Build succeeded

• style (clippy)
• style (rustdoc)
• style (rustfmt)
• test (1.31.0)
• test (beta)
• test (nightly)
• test (stable)

[Boscop]

@taiki-e Thanks! Does this mean that no matter how many nested levels there are (#[nested] within #[nested]), only 1 enum will be generated (all branches' types (all leaves of the branch-tree) will be unified into 1 enum)?

[taiki-e]

@Boscop

Does this mean that no matter how many nested levels there are (#[nested] within #[nested]), only 1 enum will be generated (all branches' types (all leaves of the branch-tree) will be unified into 1 enum)?

Yeah, #[nested] is a marker that indicates which expression should be wrapped, and has no role in creating an enum.

For example, the example in description of this PR generates the following code:

let z = {
    // 1 enum with 3 variants is generated.
    enum Enum<V1, V2, V3> {
        V1(V1),
        V2(V2),
        V3(V3),
    }
    // impl<V1, V2, V3> Iterator for Enum<V1, V2, V3> { ...
    if x {
        // If #[nested] is contained in a branch, the generation of 
        // a variant that wrap this entire branch is skipped.
        let z = if y {
            // Instead, each branch of the expression that #[nested]
            // is used is wrapped with a variant.
            Enum::V2(iter.map(|i| /* ... */))
        } else {
            Enum::V3(iter.flat_map(|i| /* ... */))
        };
        z
    } else {
        // Expressions that do not contain #[nested] are wrapped directly.
        Enum::V1(std::iter::empty())
    }
}

Also, if there is extra wrapping such as the following code, a compilation error will occur.

  match e {
        0 => Enum::A(0_u8),
        _ => Enum::B(match e {
            1 => Enum::C(0_u16),
            _ => Enum::D(0_u32),
        }),
    }

https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=acc7936b1d54de286eb018a7b72a06ff