Lo switch efficiente ha bisogno di auto-qualificazione?

Question

A quanto pare, when espressioni vengono compilate in modo diverso a seconda di come si denota costanti:

object SwitchOverConstants { 
    val foo = 1 
    val bar = 2 
    val baz = 3 

    fun one(x: Int) = when (x) { 
     foo -> "foo" 
     bar -> "bar" 
     baz -> "baz" 
     else -> "else" 
    } 

    fun two(x: Int) = when (x) { 
     SwitchOverConstants.foo -> "foo" 
     SwitchOverConstants.bar -> "bar" 
     SwitchOverConstants.baz -> "baz" 
     else -> "else" 
    } 
} 

Ecco il codice di byte per one:

0: iload_1  
    1: istore_2  
    2: iload_2  
    3: getstatic  #15     // Field foo:I 
    6: if_icmpne  14 
    9: ldc   #34     // String foo 
    11: goto   40 
    14: iload_2  
    15: getstatic  #22     // Field bar:I 
    18: if_icmpne  26 
    21: ldc   #35     // String bar 
    23: goto   40 
    26: iload_2  
    27: getstatic  #27     // Field baz:I 
    30: if_icmpne  38 
    33: ldc   #36     // String baz 
    35: goto   40 
    38: ldc   #38     // String else 
    40: areturn  

E qui è il codice di byte per two:

0: iload_1  
    1: tableswitch { // 1 to 3 
       1: 28 
       2: 33 
       3: 38 
      default: 43 
     } 
    28: ldc   #34     // String foo 
    30: goto   45 
    33: ldc   #35     // String bar 
    35: goto   45 
    38: ldc   #36     // String baz 
    40: goto   45 
    43: ldc   #38     // String else 
    45: areturn  

Come mai ho bisogno di qualificare le costanti con il nome della classe per ottenere una ricerca efficiente della tabella?

Answer 1

È necessario contrassegnare ciascuna costante con il modificatore const, quindi l'ottimizzazione avverrà.

A proposito, nella versione più recente di Kotlin, il bytecode per entrambe le funzioni è identico.