Cosa sono <stable> e <accessor> quando si esegue Scalac -Xprint: typer?

Question

Ho scritto un po 'di Scala

object SquareNumbers extends App { 
    val numbers = List(1,2,3,4,5) 
    val squares = numbers map (i => i * i) 
    println (squares) 
} 

ed eseguirlo tramite scalac come così:

$ scalac -Xprint:typer SquareNumbers.scala 
[[syntax trees at end of      typer]] // SquareNumbers.scala 
package <empty> { 
    object SquareNumbers extends Object with App { 
    def <init>(): SquareNumbers.type = { 
     SquareNumbers.super.<init>(); 
    () 
    }; 
    private[this] val numbers: List[Int] = immutable.this.List.apply[Int](1, 2, 3, 4, 5); 
    <stable> <accessor> def numbers: List[Int] = SquareNumbers.this.numbers; 
    private[this] val squares: List[Int] = SquareNumbers.this.numbers.map[Int, List[Int]](((i: Int) => i.*(i)))(immutable.this.List.canBuildFrom[Int]); 
    <stable> <accessor> def squares: List[Int] = SquareNumbers.this.squares; 
    scala.this.Predef.println(SquareNumbers.this.squares) 
    } 
} 

La mia domanda è, quali sono <stable> e <accessor> in uscita? Come si chiamano (come in, hanno un nome collettivo) e cosa fanno?

A occhio e croce, direi che significava che erano vals invece di Vars, e intendo dire che si trattava di un richiamabile al di fuori dell'oggetto ...

Answer 1

Questi sono interni (cioè non a vista sul nuova API di riflessione 2.10) bandiere. Il compilatore ufficiale ScalaDoc site sembra essere giù, ma si può vedere la fonte Scala per details:

final val STABLE = 1 << 22 // functions that are assumed to be stable 
          // (typically, access methods for valdefs) 
          // or classes that do not contain abstract types. 

And:

final val ACCESSOR = 1 << 27 // a value or variable accessor (getter or setter) 

Più tardi in quel file si può trovare il mapping tra gli identificatori (ad es STABLE) e le stringhe stampate (<stable>), elenchi di quali flag vengono visualizzati in quali fasi, ecc.

Answer 2

Il significato di ACCESSOR è abbastanza ovvio, ma quello di STABILE non lo è.

AFAICT, STABILE denota un getter di un campo immutabile (cioè un val), o un parametro di metodo, che è simile immutabile nell'ambito del metodo. Immagino che questo sia usato per ottimizzare eliminando le rivalutazioni.