Adding additional lifetime constraints to a trait impl

[Nemo157]

I just tried implementing std::convert::From for a reference to a struct that has a lifetime parameter in a proc_macro_derive, it took a while, but I eventually came up with something that "worked"

let a = syn::LifetimeDef::new("'a");
let mut b = syn::LifetimeDef::new("'b");
b.bounds.push(a.lifetime.clone());
let mut generics = ast.generics.clone();
generics.lifetimes.push(a.clone());
generics.lifetimes.push(b.clone());
let (impl_generics, _, _) = generics.split_for_impl();
let (_, ty_generics, where_clause) = ast.generics.split_for_impl();
let a = a.lifetime;
let b = b.lifetime;
quote! {
    impl #impl_generics ::std::convert::From<&#a ::clap::ArgMatches<#b>> for #ident #ty_generics #where_clause {
        fn from(#matches: &#a ::clap::ArgMatches<#b>) -> Self {
            #body
        }
    }
}

I feel like there must be a better way to do this, maybe some kind of enhanced split_for_impl that supports injecting extra lifetimes. (I also just realised this would probably fail if the struct passed in had a 'a or 'b lifetime, I assume there's no hygiene in proc_macro_derives at all 😮)

[dtolnay]

I would love to make this better. I agree with you that there must be a way.

Two things that might help in this case are a way to parse generics from a string:

let arg_matches_generics = parse_generics("<'_a, '_b: '_a>").unwrap();

and a way to combine two generics:

let generics = arg_matches_generics.merge(ast.generics);

But even with both of those, your conceptually simple code would still be tricky to write correctly so I think we can do even better. Let's both keep thinking.

[dtolnay]

This is somewhat better in the upcoming 0.12 release.

let mut generics = ast.generics.clone();
generics.params.push(parse_quote!('_a));
generics.params.push(parse_quote!('_b: '_a));

[Arnavion]

generics.params.push(parse_quote!('_a));

If generics.params already contains a syn::GenericParam::Type then pushing lifetimes at the end emits <T, 'a> and results in lifetime parameters must be declared prior to type parameters.

In 0.11 and the early days of 0.12, syn::Generics had two separate fields for lifetime parameters and type parameters, so one could push the new lifetime into the former and get correct output.

It could still work if Punctuated gave a way to insert(0) into its internal Vec so that one could prepend the lifetime, but it doesn't.

So it seems the easiest way is to create a new Punctuated with std::iter::once(parse_quote!('__a))).chain(generic.params).collect() ?

[mystor]

I'd also be open to doing some error correction work in the ToTokens implementation here. We could print out the generics in 2 passes with the first printing out all lifetime parameters.

In general we try not to let well-formed syn syntax trees produce malformed rust syntax when calling ToTokens.

[Arnavion]

(0.12.4 has Punctuated::insert, but also emits the generic parameters in the correct order so that the original suggestion works unchanged.)

[Soft]

About the question of lifetime hygiene, is there a good way to guarantee that the added lifetimes do not conflict with existing ones? I guess I could just go over generics.params and try to come up with a new name for a lifetime but that approach seems rather messy.

[dtolnay]

I am going to call this done as of Syn 0.15 and recommend the approach in #90 (comment). Lifetimes now get printed before type parameters even if you push them on the end of the parameter list (fixed in #321).