Java type inference: reference is ambiguous in Java 8, but not Java 7

by

The problem is that the type inference has been improved. You have a method like

public <T extends Base> T get() {
    return (T) new Derived();
}

which basically says, “the caller can decide what subclass of Base I return”, which is obvious nonsense. Every compiler should give you an unchecked warning about your type cast (T) here.

Now you have a method call:

set(new Derived(), new Consumer().get());

Recall that your method Consumer.get() says “the caller can decide what I return”. So it’s perfectly correct to assume that there could be a type which extends Base and implement Collection at the same time. So the compiler says “I don’t know whether to call set(Base i, Derived b) or set(Derived d, Collection<? extends Consumer> o)”.

You can “fix” it by calling set(new Derived(), new Consumer().<Derived>get()); but to illustrate the madness of your method, note that you can also change it to

public <X extends Base&Collection<Consumer>> void test() {
    set(new Derived(), new Consumer().<X>get());
}

which will now call set(Derived d, Collection<? extends Consumer> o) without any compiler warning. The actual unsafe operation happened inside the get method.

So the correct fix would be to remove the type parameter from the get method and declare what it really returns, Derived.

By the way, what irritates me, is your claim that this code could be compiled under Java 7. Its limited type inference with nested method calls leads to treating the get method in a nested invocation context like returning Base which can’t be passed to a method expecting a Derived. As a consequence, trying to compile this code using a conforming Java 7 compiler will fail as well, but for different reasons.

More Related Contents:

  1. Generic type inference not working with method chaining?
  2. Why does this generic code compile in java 8?
  3. A peculiar feature of exception type inference in Java 8
  4. Java 8: Reference to [method] is ambiguous [duplicate]
  5. Cannot use Java 8 method with lambda arguments without specifying type arguments
  6. Multiple wildcards on a generic methods makes Java compiler (and me!) very confused
  7. Lambda Expression and generic defined only in method
  8. Reflection type inference on Java 8 Lambdas
  9. Generics compiles and runs in Eclipse, but doesn’t compile in javac
  10. Generic return type upper bound – interface vs. class – surprisingly valid code
  11. Java8: ambiguity with lambdas and overloaded methods
  12. LambdaConversionException with generics: JVM bug?
  13. Why can this generic method with a bound return any type?
  14. Why do Consumers accept lambdas with statement bodies but not expression bodies?
  15. Calling static generic methods
  16. Why does the Java 8 generic type inference pick this overload?
  17. Method in the type Map is not applicable
  18. How to sum values in a Map with a stream?
  19. Collections.emptyList() returns a List?
  20. Why does this Java 8 lambda fail to compile?
  21. Generics compilation error with ternary operator in Java 8, but not in Java 7
  22. Consumer mapped Class in HashMap
  23. Java generics super keyword
  24. Is method reference caching a good idea in Java 8?
  25. Java 8: Lambda-Streams, Filter by Method with Exception
  26. Observer is deprecated in Java 9. What should we use instead of it?
  27. How to dynamically do filtering in Java 8?
  28. incompatible types: inference variable T has incompatible bounds [duplicate]
  29. Why are new java.util.Arrays methods in Java 8 not overloaded for all the primitive types?
  30. Purpose of third argument to ‘reduce’ function in Java 8 functional programming

Leave a Comment