Concrete mode: There is no way to just generate an implementation for Impl<T>, without also implementing for some T

[audunhalland]

This relates to the definition of dependency "leaf nodes".

[audunhalland]

i.e. you have to write

#[entrait(Foo)]
fn foo(deps: &()) -> i32 {
    unimplemented!()
}

which generates a impl<T: Foo> Foo for Impl<T> and a useless, incorrect impl Foo for () which panics.

(assuming you want an implementation for a type that isn't (), but the type you want lives in a downstream crate.)

Maybe this can be referred to as delegating implementation.

The core of the issue seems to be that it appears ridiculous that you annotate a function, but that function ends up not being used. Instead we could just annotate the full trait:

#[implement_for_impl] // <- invent some attribute
trait Foo {
    fn foo(&self) -> i32;
}

[audunhalland]

Fixed in 0.4. The solution is to to use an empty #[entrait] attribute on a trait.