Rewrite inline generic bounds

[jquesada2016]

Currently, the following doesn't compile, but perhaps should:

#[component]
fn MyGenericComponent<T: Debug>(cx: Scope, prop: T) -> impl IntoView {}

The above does not work because the generics need to be rewritten to be:

fn MyGenericComponent<T>(cx: Scope, prop: T) -> impl IntoView
where
  T: Debug
{}

Likewise, this doesn't compile either:

#423 fn Comp(cx: Scope, prop: impl Fn() + 'static) -> impl IntoView {}

In this case, for each impl inline trait, we'd need to rewrite it with some anonymous type name:

fn Comp<__0: Debug>(cx: Scope, prop: __0) -> impl IntoView
where
  __0: Debug
{}

[jquesada2016]

In my opinion, the easiest way to implement this, is to use recursive #[component] calls, where the first thing the macro does is to check if there are generics, and if so, rewrite them to the following output:

#[component]
fn Comp(cx: Scop, prop impl Fn()) -> impl IntoView {}

should expand to exactly

#[component]
fn Comp<__0>(cx: Scope, prop: __0) -> impl IntoView
where
  __0: Fn()
{}

This way, the compiler will invoke the macro again and continue as normal.

Of course, in any recursion problem, we need a base case to stop recursion. In this case, we'd just check to see if there are any generics of the previous form we'd need to transform. If there are non, then we continue as normal.

[gbj]

Oh I would genuinely love to have both these generic patterns available: I think impl Trait props would be an especially powerful feature.

Do you want to take a try at this?