I wonder what is your use case for this? I had the idea about it in #3 but I had no real use case in mind, so I would be very interested about knowing it if there is :)

Self-referencing interface would need a generic envelope

interface Self<T extends Self<? extends T>> {}

@GenerateEnvelope(generic = true) will provide an envelope which could be nested like so

class Impl implements Self<Impl> {}
class Wrap1 extends SelfEnvelope<Impl, Self<Impl>> {
    public Wrap1(final Self<Impl> wrapped) {
        super(wrapped);
    }
}
class Wrap2 extends SelfEnvelope<Impl, Self<Impl>> {
    public Wrap2(final Self<Impl> wrapped) {
        super(wrapped);
    }
}
final Self<Impl> env4 = new Wrap1(new Wrap2(new Wrap1(new Impl())));

While non-generic will be bounded to Impl and will not accept itself.

@andreoss I have not forgotten about this PR :)

@andreoss I'm not clear about the example you gave me above.

Why can't you just write:

class Impl implements Self<Impl> {}
class Wrap1<T extends Self<? extends T>> extends SelfEnvelope<T> {
    public Wrap1(final Self<T> wrapped) {
        super(wrapped);
    }
}
class Wrap2<T extends Self<? extends T>> extends SelfEnvelope<T> {
    public Wrap2(final Self<T> wrapped) {
        super(wrapped);
    }
}
final Self<Impl> env4 = new Wrap1(new Wrap2(new Wrap1(new Impl())));

It works perfectly well.

By the way, I believe this kind of pattern is more usually wrote like this (without the ? extends):

interface Self<T extends Self<T>> {}

I have created an issue at javapoet asking about it: square/javapoet#793

@andreoss could you try using NameAllocator (see square/javapoet#793) instead of using some adhoc method to generate a fresh name? I think W, as you proposed, is a correct default name.