Nested generics -- confusing

Question

Why does the commented line not compile? Why does it need the extra specialization?
public class D<E>
    public M1<M2<E>> foo() { return null; }
    public M2<E> bar() { return null; }
    public static void f1()
        D<String>d = null;
        M2<String> m2 = d.bar();
        M1<M2<String>> m1 = d.foo();
    public static void f2()
        D<? extends String>d = null;
        M2<? extends String> m2 = d.bar();
        //M1<M2<? extends String>> m1 = d.foo(); // doesn't work!                                               
        M1<? extends M2<? extends String>> m1 = d.foo();
class M1<T>{}
class M2<S>{}

Answer 1

It does a good job of preventing this sort of trickery.
    public static void f2()
        D<? extends Number>d = null;
        class M3 extends M2<Double> {}
        // M1<M2<? extends Number>> m1 = new M1<M3>();
        M1<? extends M2<? extends Number>> m1 = new M1<M3>();
    }Or, for a more concrete example:
class D<E>
    List<List<E>> woo = new LinkedList<List<E>>();
    public List<List<E>> foo() {
         return woo;
    public void bar(List<E> list) {
         woo.add(list);
    public static void f2() {
        D<Double> d = new D<Double>();
        d.bar(new DoubleList());
        D<? extends Number> e = d;
        //List<List<? extends Number>> m1 = d.foo();
        List<? extends List<? extends Number>> m2 = d.foo();
class DoubleList extends LinkedList<Double> {}I haven't been able to find anything that would actually break type-safety if that were allowed, but this comes close, I think.