`Generics` does not tokenize its `WhereClause`

[Aaron1011]

The ToTokens impl for Generics does not tokenize the contained WhereClause - instead, any items which contain a Generics (e.g. ItemStruct) explicitly tokenize the WhereClause in the correct position.

This is a major footgun - if a Generics is extracted from a parsed item and then quote!ed somewhere else, the WhereClause will silently be lost. This can lead to confusing errors, since the lack of a where clause can cause type-checking to fail.

Making Generics include its WhereClause during tokenization would be a breaking change (and there may be drawbacks that I haven't thought of). However, the documentation should clearly state that tokenizing a Generics is lossy, to help prevent confusing errors in downstream crates.

[TonalidadeHidrica]

I definitely think this should be documented. I have just shot my foot, wondering why the constraint is not satisfied, and it was not until I read the code of impl ToToken for Generics that I realized that where clause is actually not turned into tokens, attempting to file a new issue to reach here.

[LikeLakers2]

I just came across this issue, because my procedural macro was panicking for some unknown reason.

Here's the code I was using:

/// Applies the specified bounds to all generic parameters
pub fn apply_bounds(
    generics: Generics,
    _bound_to_add: TypeParamBound,
) -> Generics {
    let (params, where_clause) = (
        generics.params,
        generics.where_clause,
    );

    // (shortened -- this isn't what panics)
    let edited_params = 
        params.into_iter() // ...
        ;

    // The invocation below panics due to `#where_clause` being an "unexpected token".
    parse_quote! {
        <#(#edited_params),*> #where_clause
    }
}

I was able to fix it by changing that parse_quote! invocation to this:

let mut new_generics: Generics = parse_quote! {
    < #(#edited_params),* >
};
new_generics.where_clause = where_clause;

If I might suggest something, it would be to move the WhereClause out of Generics, rather than document this anomaly. I understand this would be a breaking change, however, but having it in structs where it would actually be tokenized would be quite a lot less confusing (especially for those trying to make a Generics via parse_quote!).

If nothing else, the parse_quote! macro could at least have a special case for this, where its panic message will specify to set generics.where_clause separately.

[Imberflur]

I just encountered a bug in my macro code where I assumed the WhereClause would be included and got errors that were difficult to track back to this. It's a bit surprising that Generics implements ToTokens but everything isn't included in the output.