Fix late-bound lifetime warning

PR #35 introduced a warning in one of the examples. We were passing all
generic parameters to the inner function, including lifetimes. But
passing late-bound lifetimes won't be allowed in the future. This
commit simply ignores lifetime parameters. AFAICT this should never be
a problem. Passing lifetimes explicitly hardly ever makes sense. The
only case I can think of where the changes of this commit could break
anything is in this function:

    fn foo<'a>() -> &'a i32 { ... }

But functions with an early-bound lifetime (return type) and no
late-bound ones are extremely rare and special. So for now we can
ignore them. In particular, determining which lifetime parameters are
early- and which are late-bound is extremely difficult.

Lastly, const parameters are not yet correctly passed to the inner
function. This needs to be fixed in the future, when const parameters
are a thing.

Author: LukasKalbertodt

src/gen.rs

@@ -430,9 +430,19 @@ fn gen_method_item(
     // Generate the list of argument used to call the method.
     let args = get_arg_list(sig.decl.inputs.iter())?;
 
-    // Builds turbofish with generic types
-    let (_, generic_types, _) = sig.decl.generics.split_for_impl();
-    let generic_types = generic_types.as_turbofish();
+    // Builds turbofish with generic types (without lifetimes)
+    let generic_types = sig.decl.generics
+        .type_params()
+        .map(|param| {
+            let name = &param.ident;
+            quote! { #name , }
+        })
+        .collect::<TokenStream2>();
+    let generic_types = if generic_types.is_empty() {
+        generic_types
+    } else {
+        quote ! { ::<#generic_types> }
+    };
 
     // Generate the body of the function. This mainly depends on the self type,
     // but also on the proxy type.
@@ -452,14 +462,14 @@ fn gen_method_item(
         // Receiver `self` (by value)
         SelfType::Value => {
             // The proxy type is a Box.
-            quote! { (*self).#name#generic_types(#args) }
+            quote! { (*self).#name #generic_types(#args) }
         }
 
         // `&self` or `&mut self` receiver
         SelfType::Ref | SelfType::Mut => {
             // The proxy type could be anything in the `Ref` case, and `&mut`
             // or Box in the `Mut` case.
-            quote! { (*self).#name#generic_types(#args) }
+            quote! { (*self).#name #generic_types(#args) }
         }
     };