Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

256 lines (239 sloc) 9.876 kb
package scala
package reflect
package api
import java.io.{ PrintWriter, StringWriter }
/**
* <span class="badge badge-red" style="float: right;">EXPERIMENTAL</span>
*
* Utilities for nicely printing [[scala.reflect.api.Trees]] and [[scala.reflect.api.Types]].
*
* === Printing Trees ===
* The method `show` displays the "prettified" representation of reflection artifacts.
* This representation provides one with the desugared Java representation of Scala code.
* For example:
*
* {{{
* scala> import scala.reflect.runtime.universe._
* import scala.reflect.runtime.universe._
*
* scala> def tree = reify{ final class C { def x = 2 } }.tree
* tree: reflect.runtime.universe.Tree
*
* scala> show(tree)
* res0: String =
* {
* final class C extends AnyRef {
* def <init>() = {
* super.<init>();
* ()
* };
* def x = 2
* };
* ()
* }
* }}}
*
* The method `showRaw` displays internal structure of a given reflection object
* as a Scala abstract syntax tree (AST), the representation that the Scala typechecker
* operates on.
*
* Note, that while this representation appears to generate correct trees that one
* might think would be possible to use in a macro implementation, this is not usually
* the case. Symbols aren't fully represented (only their names are). Thus, this method
* is best-suited for use simply inspecting ASTs given some valid Scala code.
* {{{
* scala> showRaw(tree)
* res1: String = Block(List(
* ClassDef(Modifiers(FINAL), newTypeName("C"), List(), Template(
* List(Ident(newTypeName("AnyRef"))),
* noSelfType,
* List(
* DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(),
* Block(List(
* Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())),
* Literal(Constant(())))),
* DefDef(Modifiers(), newTermName("x"), List(), List(), TypeTree(),
* Literal(Constant(2))))))),
* Literal(Constant(())))
* }}}
*
* The method `showRaw` can also print [[scala.reflect.api.Types]] next to the artifacts
* being inspected
* {{{
* scala> import scala.tools.reflect.ToolBox // requires scala-compiler.jar
* import scala.tools.reflect.ToolBox
*
* scala> import scala.reflect.runtime.{currentMirror => cm}
* import scala.reflect.runtime.{currentMirror=>cm}
*
* scala> showRaw(cm.mkToolBox().typeCheck(tree), printTypes = true)
* res2: String = Block[1](List(
* ClassDef[2](Modifiers(FINAL), newTypeName("C"), List(), Template[3](
* List(Ident[4](newTypeName("AnyRef"))),
* noSelfType,
* List(
* DefDef[2](Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree[3](),
* Block[1](List(
* Apply[4](Select[5](Super[6](This[3](newTypeName("C")), tpnme.EMPTY), ...))),
* Literal[1](Constant(())))),
* DefDef[2](Modifiers(), newTermName("x"), List(), List(), TypeTree[7](),
* Literal[8](Constant(2))))))),
* Literal[1](Constant(())))
* [1] TypeRef(ThisType(scala), scala.Unit, List())
* [2] NoType
* [3] TypeRef(NoPrefix, newTypeName("C"), List())
* [4] TypeRef(ThisType(java.lang), java.lang.Object, List())
* [5] MethodType(List(), TypeRef(ThisType(java.lang), java.lang.Object, List()))
* [6] SuperType(ThisType(newTypeName("C")), TypeRef(... java.lang.Object ...))
* [7] TypeRef(ThisType(scala), scala.Int, List())
* [8] ConstantType(Constant(2))
* }}}
*
* === Printing Types ===
*
* The method `show`
* {{{
* scala> import scala.reflect.runtime.universe._
* import scala.reflect.runtime.universe._
*
* scala> def tpe = typeOf[{ def x: Int; val y: List[Int] }]
* tpe: reflect.runtime.universe.Type
*
* scala> show(tpe)
* res0: String = scala.AnyRef{def x: Int; val y: scala.List[Int]}
* }}}
*
* Like the method `showRaw` for [[scala.reflect.api.Trees]], `showRaw`
* for [[scala.reflect.api.Types]] provides a visualization of the Scala
* AST operated on by the Scala typechecker.
* {{{
* // showRaw has already been discussed above
* scala> showRaw(tpe)
* res1: String = RefinedType(
* List(TypeRef(ThisType(scala), newTypeName("AnyRef"), List())),
* Scope(
* newTermName("x"),
* newTermName("y")))
* }}}
*
* `printIds` and/or `printKinds` can additionally be supplied as arguments in a call to
* `showRaw` which additionally shows the unique identifiers of symbols.
*
* {{{
* scala> showRaw(tpe, printIds = true, printKinds = true)
* res2: String = RefinedType(
* List(TypeRef(ThisType(scala#2043#PK), newTypeName("AnyRef")#691#TPE, List())),
* Scope(
* newTermName("x")#2540#METH,
* newTermName("y")#2541#GET))
* }}}
*
* For more details about `Printer`s and other aspects of Scala reflection, see the
* [[http://docs.scala-lang.org/overviews/reflection/overview.html Reflection Guide]]
*
* @group ReflectionAPI
*/
trait Printers { self: Universe =>
/** @group Printers */
protected trait TreePrinter {
def print(args: Any*)
protected var printTypes = false
protected var printIds = false
protected var printKinds = false
protected var printMirrors = false
protected var printPositions = false
def withTypes: this.type = { printTypes = true; this }
def withoutTypes: this.type = { printTypes = false; this }
def withIds: this.type = { printIds = true; this }
def withoutIds: this.type = { printIds = false; this }
def withKinds: this.type = { printKinds = true; this }
def withoutKinds: this.type = { printKinds = false; this }
def withMirrors: this.type = { printMirrors = true; this }
def withoutMirrors: this.type = { printMirrors = false; this }
def withPositions: this.type = { printPositions = true; this }
def withoutPositions: this.type = { printPositions = false; this }
}
/** @group Printers */
case class BooleanFlag(value: Option[Boolean])
/** @group Printers */
object BooleanFlag {
import scala.language.implicitConversions
implicit def booleanToBooleanFlag(value: Boolean): BooleanFlag = BooleanFlag(Some(value))
implicit def optionToBooleanFlag(value: Option[Boolean]): BooleanFlag = BooleanFlag(value)
import scala.reflect.internal.settings.MutableSettings
implicit def settingToBooleanFlag(setting: MutableSettings#BooleanSetting): BooleanFlag = BooleanFlag(Some(setting.value))
}
/** @group Printers */
protected def render(what: Any, mkPrinter: PrintWriter => TreePrinter, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None, printPositions: BooleanFlag = None): String = {
val buffer = new StringWriter()
val writer = new PrintWriter(buffer)
val printer = mkPrinter(writer)
printTypes.value.map(printTypes => if (printTypes) printer.withTypes else printer.withoutTypes)
printIds.value.map(printIds => if (printIds) printer.withIds else printer.withoutIds)
printKinds.value.map(printKinds => if (printKinds) printer.withKinds else printer.withoutKinds)
printMirrors.value.map(printMirrors => if (printMirrors) printer.withMirrors else printer.withoutMirrors)
printPositions.value.map(printPositions => if (printPositions) printer.withPositions else printer.withoutPositions)
printer.print(what)
writer.flush()
buffer.toString
}
/** By default trees are printed with `show`
* @group Printers
*/
override protected def treeToString(tree: Tree) = show(tree)
/** Renders a representation of a reflection artifact
* as desugared Scala code.
*
* @group Printers
*/
def show(any: Any, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None, printPositions: BooleanFlag = None): String =
render(any, newTreePrinter(_), printTypes, printIds, printKinds, printMirrors, printPositions)
/** Hook to define what `show(...)` means.
* @group Printers
*/
protected def newTreePrinter(out: PrintWriter): TreePrinter
/**
* Renders the code of the passed tree, so that:
* 1) it can be later compiled by scalac retaining the same meaning,
* 2) it looks pretty.
* At the moment we have handled #1 for unattributed trees and
* later on plan to account for typical idiosyncrasies of the typechecker.
* #2 is more or less okay indentation-wise, but at the moment there's a lot of desugaring
* left in place, and that's what we also plan to improve in the future.
*
* @group Printers
*/
def toCode(tree: Tree) = render(tree, newCodePrinter)
/**
* Hook to define what `toCode(...)` means.
* @group Printers
*/
protected def newCodePrinter(out: PrintWriter): TreePrinter
/** Renders internal structure of a reflection artifact as the
* visualization of a Scala syntax tree.
*
* @group Printers
*/
def showRaw(any: Any, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None, printPositions: BooleanFlag = None): String =
render(any, newRawTreePrinter(_), printTypes, printIds, printKinds, printMirrors, printPositions)
/** Hook to define what `showRaw(...)` means.
* @group Printers
*/
protected def newRawTreePrinter(out: PrintWriter): TreePrinter
/** Renders a prettified representation of a name.
* @group Printers
*/
def show(name: Name): String
/** Renders internal structure of a name.
* @group Printers
*/
def showRaw(name: Name): String = name.toString
/** Renders a prettified representation of a flag set.
* @group Printers
*/
def show(flags: FlagSet): String
/** Renders internal structure of a flag set.
* @group Printers
*/
def showRaw(flags: FlagSet): String = flags.toString
}
Jump to Line
Something went wrong with that request. Please try again.