Statement with generics fails to compile in one line, compiles in two lines

FULL PRODUCT VERSION :


ADDITIONAL OS VERSION INFORMATION :
Linux work-laptop 2.6.35-27-generic #48-Ubuntu SMP Tue Feb 22 20:25:46 UTC 2011 x86_64 GNU/Linux

A DESCRIPTION OF THE PROBLEM :
I submitted this as a bug before but included the wrong version of the code which works fine, and the bug was marked "Not Reproducible":
http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7028331

This report has the correct, non-working code in it.

The compiler seems to get confused when dealing with lower bounded wildcards in generics. The code example given demonstrates the problem. The error message indicates that the compiler thinks the type should be one thing, when it seems plain that it should be another, and in fact "reminding" the compiler of the correct type via a variable declaration seems to make it happy.

STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
Compile the given source code.

EXPECTED VERSUS ACTUAL BEHAVIOR :
EXPECTED -
Success
ACTUAL -
Failure--see error message

ERROR MESSAGES/STACK TRACES THAT OCCUR :
<T>contains(java.util.List<T>,T) in com.foo.Foo cannot be applied to (java.util.List<java.util.Comparator<? super java.lang.Object>>,com.foo.Foo.SomeComparator<java.lang.String>)

REPRODUCIBILITY :
This bug can be reproduced always.

---------- BEGIN SOURCE ----------
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class Foo {
    public static void main(String[] args) {
        boolean b = contains(
                buildList(new SomeComparator<String>("bar")),
                new SomeComparator<String>("x"));
        System.out.println(b);
    }

    public static <T> boolean contains(List<T> objects, T customer ) {
        return objects.contains( customer );
    }

    public static <T> List<Comparator<? super T>> buildList(Comparator<? super T>... comparator) {
        return Arrays.asList(comparator);
    }

    private static class SomeComparator<T> implements Comparator<T> {
        public SomeComparator(T arg) {}
        public int compare(T o1, T o2) { return 0; }
    }
}
---------- END SOURCE ----------

CUSTOMER SUBMITTED WORKAROUND :
"Help" the compiler recognize the correct type by splitting the problem line (first line of the main method) into two lines, like so:
        List<Comparator<? super String>> list = buildList(new SomeComparator<String>("bar"));
        boolean b = contains(
                list,
                new SomeComparator<String>("x"));