Sample.java

public class Sample {

	public static void main(String[] args) {

		Foo<? extends Bar<?>> foo = new Foo<>();

		// Compiles
		Iterable<?> first = foo.someMethod();
		DedicatedWrapper<? extends Bar<?>> dedicatedWrapper = foo.someOtherMethod();

		// Does not compile:
		// Type mismatch: cannot convert from Iterable<Sample.SomeWrapper<capture#2-of ? extends Sample.Bar<?>>>
		// to Iterable<Sample.SomeWrapper<? extends Sample.Bar<?>>>
		Iterable<SomeWrapper<? extends Bar<?>>> second = foo.someMethod();
	}

	static class Foo<B extends Bar<B>> {

		Iterable<SomeWrapper<B>> someMethod() {
			return Collections.emptySet();
		}

		DedicatedWrapper<B> someOtherMethod() {
			return null;
		}
	}

	interface Bar<B extends Bar<B>> {}

	interface SomeWrapper<B extends Bar<B>> {}

	interface DedicatedWrapper<B extends Bar<B>> extends Iterable<SomeWrapper<B>> {}
}

I think it boils down to the fact that the compiler doesn't know that the first and second ? in this line refer to the same thing Foo<? extends Bar<?>> foo = new Foo<>();

In the past when I've had this kind of problem I've extracted the method and added a real generic:

public static void main(String[] args) {
	typed();
}

private static <T extends Bar<T>> void typed() {
	Foo<T> foo = new Foo<>();

	// Compiles
	Iterable<?> first = foo.someMethod();
	DedicatedWrapper<T> dedicatedWrapper = foo.someOtherMethod();

	// Compiles
	Iterable<SomeWrapper<T>> second = foo.someMethod();
}