Packages

•  package root

  Definition Classes

  root

•  package scala

  Definition Classes

  root

•  package reflect

  Definition Classes

  scala

•  package api

  EXPERIMENTAL

  EXPERIMENTAL

  The Scala Reflection API (located in scala-reflect.jar).

  In Scala 2.10.0, the Scala Reflection API and its implementation have an "experimental" status. This means that the API and the docs are not complete and can be changed in binary- and source-incompatible manner in 2.10.1. This also means that the implementation has some known issues.

  The following types are the backbone of the Scala Reflection API, and serve as a good starting point for information about Scala Reflection:

  • scala.reflect.api.Symbols
  • scala.reflect.api.Types
  • scala.reflect.api.Mirrors
  • scala.reflect.api.Universe

  For more information about Scala Reflection, see the Reflection Guide

  Definition Classes

  reflect

•  trait Printers extends AnyRef

  EXPERIMENTAL

  EXPERIMENTAL

  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), TypeName("C"), List(), Template(
      List(Ident(TypeName("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(), TermName("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), TypeName("C"), List(), Template[3](
      List(Ident[4](TypeName("AnyRef"))),
      noSelfType,
      List(
        DefDef[2](Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree[3](),
          Block[1](List(
            Apply[4](Select[5](Super[6](This[3](TypeName("C")), tpnme.EMPTY), ...))),
            Literal[1](Constant(())))),
        DefDef[2](Modifiers(), TermName("x"), List(), List(), TypeTree[7](),
          Literal[8](Constant(2))))))),
    Literal[1](Constant(())))
  [1] TypeRef(ThisType(scala), scala.Unit, List())
  [2] NoType
  [3] TypeRef(NoPrefix, TypeName("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(TypeName("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), TypeName("AnyRef"), List())),
    Scope(
      TermName("x"),
      TermName("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), TypeName("AnyRef")#691#TPE, List())),
    Scope(
      TermName("x")#2540#METH,
      TermName("y")#2541#GET))

  For more details about Printers and other aspects of Scala reflection, see the Reflection Guide

  Definition Classes

  api

• BooleanFlag
• TreePrinter

scala.reflect.api.Printers

TreePrinter