Qual è il modo più semplice per usare reify (ottenere un AST di) un'espressione in Scala?

Question

Sto cercando alternative a -print o javap come modo di capire cosa sta facendo il compilatore in Scala. Con la nuova libreria reflection/macros, reify sembra un buon candidato, come mostrato negli macrocosm del retronym . Mostra anche come si faceva, pre-M4.

Quindi la domanda è: qual è la cosa più breve/più semplice che riesco a digitare su REPL di Scala per ottenere l'AST per un'espressione, post-Scala 2.10.0-M4?

Answer 1

Un sacco di cose precedentemente definite nel pacchetto scala.reflect.mirror si sono trasferiti in scala.reflect.runtime.universe:

scala> import scala.reflect.runtime.{universe => u} 
import scala.reflect.runtime.{universe=>u} 

scala> val expr = u reify { 1 to 3 map (_+1) } 
expr: reflect.runtime.universe.Expr[scala.collection.immutable.IndexedSeq[Int]] = Expr[scala.collection.immutable.IndexedSeq[Int]](scala.this.Predef.intWrapper(1).to(3).map(((x$1) => x$1.$plus(1)))(immutable.this.IndexedSeq.canBuildFrom)) 

scala> u show expr.tree 
res57: String = scala.this.Predef.intWrapper(1).to(3).map(((x$1) => x$1.$plus(1)))(immutable.this.IndexedSeq.canBuildFrom) 

scala> u showRaw expr.tree 
res58: String = Apply(Apply(Select(Apply(Select(Apply(Select(Select(This(newTypeName("scala")), newTermName("Predef")), newTermName("intWrapper")), List(Literal(Constant(1)))), newTermName("to")), List(Literal(Constant(3)))), newTermName("map")), List(Function(List(ValDef(Modifiers(<param> <synthetic>), newTermName("x$1"), TypeTree(), EmptyTree)), Apply(Select(Ident(newTermName("x$1")), newTermName("$plus")), List(Literal(Constant(1))))))), List(Select(Select(This(newTypeName("immutable")), newTermName("IndexedSeq")), newTermName("canBuildFrom")))) 

Inoltre è possibile controllare se una stringa che contiene un po 'di codice Scala è un'espressione Scala valido e - ancora meglio - fare un po' valutazione:

Modifica. In 2.10.0-RC1 sono stati rinominati alcuni metodi di ToolBox. parseExpr è ora solo parse e runExpr è ora chiamato eval.

scala> import scala.tools.reflect.ToolBox 
import scala.tools.reflect.ToolBox 

scala> import scala.reflect.runtime.{currentMirror => m} 
import scala.reflect.runtime.{currentMirror=>m} 

scala> val tb = m.mkToolBox() 
tb: scala.tools.reflect.ToolBox[reflect.runtime.universe.type] = scala.tools.reflect.ToolBoxFactory$ToolBoxImpl@9293709 

scala> val tree = tb.parse("1 to 3 map (_+1)") 
tree: tb.u.Tree = 1.to(3).map(((x$1) => x$1.$plus(1))) 

scala> val eval = tb.eval(tree) 
eval: Any = Vector(2, 3, 4) 

La cosa più complicata qui è la rappresentazione ad albero di un'espressione. Quando si desidera utilizzare macro, le macro devono essere definite nello stesso modo mostrato da showRaw. Ma con alcuni metodi di supporto è possibile definire alcuni non così brutto che osserva implementazioni macro:

object IntMacro { 

    import language.experimental.macros 
    import scala.reflect.makro.Context 
    import scala.reflect.NameTransformer.encode 

    def isEven(i: Int): Boolean = macro isEvenImpl 

    def isEvenImpl(c: Context)(i: c.Expr[Int]): c.Expr[Boolean] = { 
    import c.universe._ 
    implicit val cc: c.type = c 

    val `x = i%2` = Apply(Select(i.tree, op("%")), const(2)) 
    val `x == 0` = Apply(Select(`x = i%2`, op("==")), const(0)) 

    c.Expr(`x == 0`) 
    } 

    def op(s: String)(implicit c: Context): c.universe.TermName = 
    c.universe.newTermName(encode(s)) 

    def const(a: Any)(implicit c: Context): List[c.universe.Literal] = 
    List(c.universe.Literal(c.universe.Constant(a))) 
} 

scala> import IntMacro._ 
import IntMacro._ 

scala> isEven(2) 
res60: Boolean = true 

scala> isEven(3) 
res61: Boolean = false 

Ma ora passiamo a problemi con path-dependent-tipi - dobbiamo scrivere i loro percorsi in modo esplicito, se non vogliamo import loro.

Answer 2

C'è migliorare della nuova versione Scala

scala> import scala.tools.reflect.ToolBox 
import scala.tools.reflect.ToolBox 

scala> import scala.reflect.runtime.{currentMirror => m} 
import scala.reflect.runtime.{currentMirror=>m} 

scala> val tb = m.mkToolBox() 
tb: scala.tools.reflect.ToolBox[reflect.runtime.universe.type] = scala.tools.reflect.ToolBoxFactory$ToolBoxImpl@78dc5f15 

scala> val tree = tb.parseExpr("1 to 3 map (_+1)") 
<console>:10: error: value parseExpr is not a member of scala.tools.reflect.ToolBox[reflect.runtime.universe.type] 
     val tree = tb.parseExpr("1 to 3 map (_+1)") 
        ^

scala> val tree = tb.parse("1 to 3 map (_+1)") 
tree: tb.u.Tree = 1.to(3).map(((x$1) => x$1.$plus(1))) 

scala> val eval = tb.eval(tree) 
eval: Any = Vector(2, 3, 4)