Inizializzazione di oggetti Java con operatore di diamanti terribile prestazioni di compilazione javac

Question

Sto utilizzando l'operatore di diamante per avviare oggetti all'interno di un elenco. Tuttavia, con l'aumentare del numero di oggetti dell'array, il tempo di compilazione aumenta da pochi secondi ad alcune ore. La mia auto-eclisse ha reso la mia eclisse non reattiva. Ho poi notato che si tratta di un problema di javac. Quando sostituisco tutto <> con <String, List<Category>>, il tempo di compilazione risale a pochi secondi. È qualcosa che sto facendo male o è solo un problema di prestazioni Java?

Ecco il mio codice che avrà ore Java per compilare (o crash javac v8u25):

List<Pair<String, List<Category>>> categoryMappings = null; 

    public void reloadStaticData() {     
     // Left one is the provider's category and right one is ours 
     try(UoW luow = CoreModule.getInstance(UoW.class)) { 
     CategoryRepo categoryRepo = luow.getCategoryRepo(); 
     categoryMappings = Arrays.asList(

        // Nightlife 
        new ImmutablePair<>("Bars", Arrays.asList(categoryRepo.findByName("Bar & Pubs").get())), 
        new ImmutablePair<>("Ski-Bar", Arrays.asList(categoryRepo.findByName("Bar & Pubs").get())), 
        new ImmutablePair<>("Bar", Arrays.asList(categoryRepo.findByName("Bar & Pubs").get())), 
        new ImmutablePair<>("Beer", Arrays.asList(categoryRepo.findByName("Bar & Pubs").get())), 
        new ImmutablePair<>("Pubs", Arrays.asList(categoryRepo.findByName("Bar & Pubs").get())), 
        new ImmutablePair<>("Clubs", Arrays.asList(categoryRepo.findByName("Bar & Pubs").get())), 
        new ImmutablePair<>("Dance", Arrays.asList(categoryRepo.findByName("Bar & Pubs").get() 
          ,categoryRepo.findByName("Clubs").get())),  
        // if I got more than 20 of these ImmutablePairs, javac crashes or takes hours to compile 
    ); 
     } 
    } 

Edit: Come Sotirios accennato nei commenti che sembra essere un problema segnalato in JDK :

inferenza di tipo esponenziale le prestazioni di compilazione: https://bugs.openjdk.java.net/browse/JDK-8055984

tipo prestazioni inferenza di regressione: https://bugs.openjdk.java.net/browse/JDK-8048838

Answer 1

Attualmente sto lavorando su JEP-215 Tiered attribution. L'obiettivo di questo JEP è migliorare il codice di attribuzione in javac e come effetto collaterale per migliorare le prestazioni del compilatore. Ad esempio il codice elencato nel bug JDK-8055984 è compilato da "normale" Javac9 in: un sacco di tempo! L'attuale versione dell'attribuzione tiered la compila in ~ 2.5 secondi, che è molto meglio. Il codice di attribuzione a livelli non è ancora pubblico. Spero che sarà così presto. Nel frattempo questo tipo di relazioni o rapporti sono davvero utili.

Edit: se qualcuno vuole dare una prova di attribuzione più livelli, ancora in sviluppo, si prega di controllare questo annuncio: tiered attribution for all

Answer 2

Change

List<Pair<String, List<Category>>> categoryMappings = null; 

a

List<? extends Pair<String, List<Category>>> categoryMappings = null; 

vedere se questo lo accelera. Il mio JDK/IDE (IntelliJ) non compilerà altrimenti lo snippet di codice.