Help on Incompatible types

Question

Sample 1:
public interface I<T extends I<?>>
  I<? extends I<T>> m1 ();
public class Z<T extends I<?>> implements I<T>
  public I<? extends I<T>> m1 ()
    return m2();
  protected I<? extends I<T>> m2 ()
    return null;
javac Z.javacompiled with no problems
Sample 2:
public interface I<Tx, T extends I<Tx, ?>>
  I<Tx, ? extends I<Tx, T>> m1 ();
public class Z<Tx, T extends I<Tx, ?>> implements I<Tx, T>
  public I<Tx, ? extends I<Tx, T>> m1 ()
    return m2();
  protected I<Tx, ? extends I<Tx, T>> m2 ()
    return null;
javac Z.javaZ.java:5: incompatible types
found : I<Tx,capture of ? extends I<Tx,T>>
required: I<Tx,? extends I<Tx,T>>
return m2();
^
1 error
Well... can anyone help with this? Or at least some explanations why adding second generic generates this problem?

Answer 1

The problem is in the recursion, not in the second type argument. If you changed your first interface from
    public interface I<T extends I<?>> {} to
    public interface I<T extends I<T>> {} you would run into the same error message. For sake of clarity let's discuss the issue using your first example in a slightly simplified form:
    public interface I<T extends I<T>> {}
    public class Z<E>
      public I<? extends I<E>> m1 ()
        return m2();
        /* error: incompatible types
           found   : I<capture of ? extends I<E>>
           required: I<? extends I<E>>
           return m2();
                    ^
      protected I<? extends I<E>> m2 ()
      { return null; }
    }The error message is not awfully helpful, because the "E" is different in both types.
Method m2 returns a reference of type I<capture of ? extends I<E>>, where E extends I<capture of ? extends I<E>>, that is, it returns a concrete instantiation of the interface, namely I<SomeType> with a type that extends I<SomeType> with a type that extends ... continued recursively.
On the other hand, method m1 is supposed to return a reference of type I<? extends I<E>>, where E extends I<? extends I<E>>, that is, it returns a wildcard instantiation of the interface, namely I<? extends I<SomeType>> with a type that extends I<? extends I<SomeType>> with a type that extends ... continued recursively.
And here is the point: The first construct leads to a concrete instantiation like a List<List<List<String>>>. The second construct lead to a recursive wildcard instantiation like List<? extends List<? extends List<?>>>. As soon as the wildcard appears on a nested level, the types are no longer compatible.
It's like assigning a List<List<String>> to a List<List<?>>. It's not permitted because the first is a list of string-lists and the second is a list of mixed-lists. You cannot assign one to the other.
In your example, changing
    public interface I2<Tx, T extends I2<Tx, ?>> to
    public interface I2<Tx, T extends I2<?, ?>>might do the trick.
(As usual, ignore the annoying additional angle brackets.)