No exemplo a seguir, por que o compilador é capaz de inferir os argumentos genéricos para a primeira chamada aFoo.create() emFoo.test(), mas não é capaz de fazê-lo no segundo? Estou usando o Java 6.

public class Nonsense {
    public static class Bar {
        private static void func(Foo<String> arg) { }
    }

    public static class Foo<T> {

        public static <T> Foo<T> create() {
            return new Foo<T>();
        }

        private static void test() {
            Foo<String> foo2 = Foo.create(); // compiles
            Bar.func(Foo.create());          // won't compile
            Bar.func(Foo.<String>create());  // fixes the prev line
        }
    }
}

(O erro de compilação éO método func (Nonsense.Foo) no tipo Nonsense.Bar não é aplicável para os argumentos (Nonsense.Foo)).

Nota: Eu entendo o erro do compilador pode ser corrigido pela terceira linha em teste () - estou curioso para saber se existe uma limitação específica que impede que o compilador seja capaz de inferir o tipo. istoaparece para mim, que há contexto suficiente para isso aqui.