I'm having quite a tricky case here with generics and method overloading. Check out this example class:

public class Test { public <T> void setValue(Parameter<T> parameter, T value) { } public <T> void setValue(Parameter<T> parameter, Field<T> value) { } public void test() { // This works perfectly. <T> is bound to String // ambiguity between setValue(.., String) and setValue(.., Field) // is impossible as String and Field are incompatible Parameter<String> p1 = getP1(); Field<String> f1 = getF1(); setValue(p1, f1); // This causes issues. <T> is bound to Object // ambiguity between setValue(.., Object) and setValue(.., Field) // is possible as Object and Field are compatible Parameter<Object> p2 = getP2(); Field<Object> f2 = getF2(); setValue(p2, f2); } private Parameter<String> getP1() {...} private Parameter<Object> getP2() {...} private Field<String> getF1() {...} private Field<Object> getF2() {...} }

The above example compiles perfectly in Eclipse (Java 1.6), but not with the Ant javac command (or with the JDK's javac command), where I get this sort of error message on the second invocation of setValue :

reference to setValue is ambiguous, both method setValue(org.jooq.Parameter,T) in Test and method setValue(org.jooq.Parameter,org.jooq.Field) in Test match

According to the specification and to my understanding of how the Java compiler works, the most specific method should always be chosen: http://java.sun.com/docs/books/jls/third_edition/html/expressions.html#20448

In any case, even if <T> is bound to Object , which makes both setValue methods acceptable candidates for invocation, the one with the Field parameter always seems to be more specific. And it works in Eclipse, just not with the JDK's compiler.

UPDATE:

Like this, it would work both in Eclipse and with the JDK compiler (with rawtypes warnings, of course). I understand, that the rules specified in the specs are quite special, when generics are involved. But I find this rather confusing:

public <T> void setValue(Parameter<T> parameter, Object value) { } // Here, it's easy to see that this method is more specific public <T> void setValue(Parameter<T> parameter, Field value) { }

UPDATE 2:

Even with generics, I can create this workaround where I avoid the type <T> being bound to Object at setValue invocation time, by adding an additional, unambiguous indirection called setValue0 . This makes me think that the binding of T to Object is really what's causing all the trouble here:

public <T> void setValue(Parameter<T> parameter, T value) { } public <T> void setValue(Parameter<T> parameter, Field<T> value) { } public <T> void setValue0(Parameter<T> parameter, Field<T> value) { // This call wasn't ambiguous in Java 7 // It is now ambiguous in Java 8! setValue(parameter, value); } public void test() { Parameter<Object> p2 = p2(); Field<Object> f2 = f2(); setValue0(p2, f2); }

Am I misunderstanding something here? Is there a known compiler bug related to this? Or is there a workaround/compiler setting to help me?

Follow-Up:

For those interested, I have filed a bug report both to Oracle and Eclipse. Oracle has accepted the bug, so far, Eclipse has analysed it and rejected it! It looks as though my intuition is right and this is a bug in javac