Eclipse - `invito aperto hierarchy` interrompere la ricerca nella catena lambda

Question

Ecco il mio codice di esempio Java:

public class Test { 

    public static void main(String[] args) { 
     methodDepth0(
      ()-> 
       methodDepth1(
        ()-> 
         methodDepth2() 
       ) 
     ); 
    } 

    static Object methodDepth2() { 
     return null; 
    } 

    interface MyIF { 
     void call(); 
    } 

    static void methodDepth0(MyIF myIf){ 
     myIf.call(); 
    } 

    interface MyIF2 { 
     void call(); 
    } 

    static void methodDepth1(MyIF2 myIf2){ 
     myIf2.call(); 
    } 
} 

Quando apro gerarchia di richiamo del metodo methodDepth2() da Eclipse (4.4), open call hierarchy interrompere la ricerca successiva chiamante:

Quello che mi aspetto è come aprire gerarchia di richiamo del metodo methodDepth1() che mostrano fino a che il metodo main.

Answer 1

Da quello che posso dire la mancanza di profondità della gerarchia di chiamata è dovuta alla (ri) valutazione del codice in fase di esecuzione. È spiegato in 15.27.4 Run-Time Evaluation of Lambda Expressions nella specifica del linguaggio Java.

In fase di esecuzione, la valutazione di un'espressione lambda è simile alla valutazione di un'espressione di creazione di un'istanza di classe, in quanto il completamento normale produce un riferimento a un oggetto. La valutazione di un'espressione lambda è distinta dall'esecuzione del corpo lambda.

Answer 2

Come la seconda immagine mostra chiaramente, Eclipse è in grado di rintracciare la gerarchia di richiamo attraverso la chiamata di metodo myIf.call() all'interno methodDepth0. Questo è corretto, perché il metodo (esterno) lambda implementa MyIF.call().

Il fatto che lo stesso modello non funzioni nel prossimo livello di annidamento sembra un bug. Si prega di considerare filing a bug per JDT/UI. TIA.

Basta notare, che per lambda di attuazione i tipi di libreria come Consumer<T>, il numero di chi chiama in accept(T) in un'area di lavoro possono facilmente diventare ingestibile, simile a qualsiasi gerarchia di richiamo attraverso, ad esempio, Runnable.run() - ma che non mette in discussione l'utilità generale delle gerarchie di chiamata attraverso lambda.