← Back to branch summary

~ubuntu-branches/debian/sid/scala/sid

« back to all changes in this revision

Viewing changes to src/compiler/scala/tools/nsc/ast/NodePrinters.scala

  • Committer: Package Import Robot
  • Author(s): Emmanuel Bourg, Mehdi Dogguy, Lucas Satabin, Frank S. Thomas, Emmanuel Bourg
  • Date: 2015-06-05 23:52:59 UTC
  • mfrom: (1.2.11)
  • Revision ID: package-import@ubuntu.com-20150605235259-wk00vgk83dh8o19g
Tags: 2.10.5-1
http://bugs.debian.org/744278
http://bugs.debian.org/754935
http://bugs.debian.org/724704
* Team upload.

[ Mehdi Dogguy ]
* New upstream release (Closes: #744278).

[ Lucas Satabin ]
* Update patches
* Update the clean target
* Update paths of elements to install
* Update watch file

[ Frank S. Thomas ]
* Remove myself from Uploaders.

[ Emmanuel Bourg ]
* The package has been adopted by the Java Team (Closes: #754935)
* Patched the build to avoid downloading libraries from the Internet
* Replaced the minified JavaScript files with unobfuscated ones
* No longer build scala-partest.jar until diffutils is packaged or replaced
* debian/watch: Fixed the versions matched (x.y.z instead of x.y.z..z)
* debian/rules:
  - Added the missing get-orig-source target (Closes: #724704)
  - Improved the clean target
* debian/control:
  - Build depend on scala (>= 2.10) and bnd
  - Use canonical URLs for the Vcs-* fields
  - Standards-Version updated to 3.9.6 (no changes)
* Switch to debhelper level 9

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/compiler/scala/tools/nsc/ast/NodePrinters.scala
1
1
/* NSC -- new Scala compiler
2
 
 * Copyright 2005-2011 LAMP/EPFL
 
2
 * Copyright 2005-2013 LAMP/EPFL
3
3
 * @author  Martin Odersky
4
4
 */
5
5
 
6
6
package scala.tools.nsc
7
7
package ast
8
8
 
9
 
import compat.Platform.EOL
 
9
import scala.compat.Platform.EOL
10
10
import symtab.Flags._
 
11
import scala.language.postfixOps
11
12
 
12
 
/** The object <code>nodePrinter</code> converts the internal tree
13
 
 *  representation to a string formatted as a Scala expression.
 
13
/** The object `nodePrinter` converts the internal tree
 
14
 *  representation to a string.
14
15
 *
15
16
 *  @author  Stephane Micheloud
16
 
 *  @version 1.0
 
17
 *  @author  Paul Phillips
17
18
 */
18
19
abstract class NodePrinters {
19
 
 
20
20
  val global: Global
21
21
  import global._
22
22
 
25
25
  }
26
26
  var infolevel = InfoLevel.Quiet
27
27
 
28
 
  object nodeToString extends Function1[Tree, String] {
 
28
  def nodeToString: Tree => String = nodeToRegularString
 
29
 
 
30
  object nodeToRegularString extends DefaultPrintAST with (Tree => String) {
 
31
    def apply(tree: Tree) = stringify(tree)
 
32
  }
 
33
 
 
34
  trait DefaultPrintAST extends PrintAST {
 
35
    val printPos = settings.Xprintpos.value || settings.Yposdebug.value
 
36
 
 
37
    def showNameAndPos(tree: NameTree) = showPosition(tree) + showName(tree.name)
 
38
    def showDefTreeName(tree: DefTree) = showName(tree.name)
 
39
    def showPosition(tree: Tree)       = if (printPos) tree.pos.show else ""
 
40
    def showFlags(tree: MemberDef)     = flagsToString(tree.symbol.flags | tree.mods.flags)
 
41
    def showLiteral(lit: Literal)      = showPosition(lit) + lit.value.escapedStringValue
 
42
    def showTypeTree(tt: TypeTree)     = showPosition(tt) + "<tpt>" + emptyOrComment(showType(tt))
 
43
    def showName(name: Name)           = name match {
 
44
      case nme.EMPTY | tpnme.EMPTY => "<empty>"
 
45
      case name                    => "\"" + name + "\""
 
46
    }
 
47
 
 
48
    def showSymbol(tree: Tree): String = {
 
49
      val sym = tree.symbol
 
50
      if (sym == null || sym == NoSymbol) ""
 
51
      else sym.defString + sym.locationString
 
52
    }
 
53
    def showType(tree: Tree): String = {
 
54
      val tpe = tree.tpe
 
55
      if (tpe == null || tpe == NoType) ""
 
56
      else "tree.tpe=" + tpe
 
57
    }
 
58
 
 
59
    def showAttributes(tree: Tree): String = {
 
60
      if (infolevel == InfoLevel.Quiet) ""
 
61
      else {
 
62
        try   { List(showSymbol(tree), showType(tree)) filterNot (_ == "") mkString ", " trim }
 
63
        catch { case ex: Throwable => "sym= <error> " + ex.getMessage }
 
64
      }
 
65
    }
 
66
  }
 
67
 
 
68
  trait PrintAST {
29
69
    private val buf = new StringBuilder
30
 
 
31
 
    def apply(tree: Tree): String = {
32
 
      def traverse(tree: Tree, level: Int, comma: Boolean) {
33
 
        def println(s: String) {
34
 
          for (i <- 0 until level) buf.append("  ")
35
 
          buf.append(s)
36
 
          buf.append(EOL)
37
 
        }
38
 
        def printcln(s: String) {
39
 
          for (i <- 0 until level) buf.append("  ")
40
 
          buf.append(s)
41
 
          if (comma) buf.append(",")
42
 
          buf.append(EOL)
43
 
        }
44
 
        def annotationInfoToString(annot: AnnotationInfo): String = {
45
 
          val str = new StringBuilder
46
 
          str.append(annot.atp.toString())
47
 
          if (!annot.args.isEmpty)
48
 
            str.append(annot.args.mkString("(", ",", ")"))
49
 
          if (!annot.assocs.isEmpty)
50
 
            for (((name, value), index) <- annot.assocs.zipWithIndex) {
51
 
              if (index > 0)
52
 
                str.append(", ")
53
 
              str.append(name).append(" = ").append(value)
54
 
            }
55
 
          str.toString
56
 
        }
57
 
        def symflags(tree: Tree): String = {
58
 
          val buf = new StringBuffer
59
 
          val sym = tree.symbol
60
 
          buf append flagsToString(sym.flags)
61
 
 
62
 
          val annots = ", annots=" + (
63
 
            if (!sym.annotations.isEmpty)
64
 
              sym.annotations.map(annotationInfoToString).mkString("[", ",", "]")
65
 
            else
66
 
              tree.asInstanceOf[MemberDef].mods.annotations)
67
 
          (if (buf.length() > 2) buf.substring(3)
68
 
          else "0") + ", // flags=" + flagsToString(sym.flags) + annots
69
 
        }
70
 
 
71
 
        def nodeinfo(tree: Tree): String =
72
 
          if (infolevel == InfoLevel.Quiet) ""
73
 
          else {
74
 
            val buf = new StringBuilder(" // sym=" + tree.symbol)
75
 
            if (tree.hasSymbol) {
76
 
              if (tree.symbol.isPrimaryConstructor)
77
 
                buf.append(", isPrimaryConstructor")
78
 
              else if (tree.symbol.isConstructor)
79
 
                buf.append(", isConstructor")
80
 
              if (tree.symbol != NoSymbol)
81
 
                buf.append(", sym.owner=" + tree.symbol.owner)
82
 
              buf.append(", sym.tpe=" + tree.symbol.tpe)
83
 
            }
84
 
            buf.append(", tpe=" + tree.tpe)
85
 
            if (tree.tpe != null) {
86
 
              var sym = tree.tpe.termSymbol
87
 
              if (sym == NoSymbol) sym = tree.tpe.typeSymbol
88
 
              buf.append(", tpe.sym=" + sym)
89
 
              if (sym != NoSymbol) {
90
 
                buf.append(", tpe.sym.owner=" + sym.owner)
91
 
                if ((infolevel > InfoLevel.Normal) &&
92
 
                    !(sym.owner eq definitions.ScalaPackageClass) &&
93
 
                    !sym.isModuleClass && !sym.isPackageClass &&
94
 
                    !sym.isJavaDefined) {
95
 
                  val members = for (m <- tree.tpe.decls.toList)
96
 
                    yield m.toString() + ": " + m.tpe + ", "
97
 
                  buf.append(", tpe.decls=" + members)
98
 
                }
99
 
              }
100
 
            }
101
 
            buf.toString
102
 
          }
103
 
        def nodeinfo2(tree: Tree): String =
104
 
          (if (comma) "," else "") + nodeinfo(tree)
105
 
 
106
 
        def applyCommon(name: String, tree: Tree, fun: Tree, args: List[Tree]) {
107
 
          println(name + "(" + nodeinfo(tree))
108
 
          traverse(fun, level + 1, true)
109
 
          if (args.isEmpty)
110
 
            println("  Nil // no argument")
111
 
          else {
112
 
            val n = args.length
113
 
            println("  List( // " + n + " arguments(s)")
114
 
            for (i <- 0 until n)
115
 
              traverse(args(i), level + 2, i < n-1)
116
 
            println("  )")
117
 
          }
118
 
          printcln(")")
119
 
        }
120
 
 
121
 
        tree match {
122
 
          case AppliedTypeTree(tpt, args) => applyCommon("AppliedTypeTree", tree, tpt, args)
123
 
          case Apply(fun, args)           => applyCommon("Apply", tree, fun, args)
124
 
          case ApplyDynamic(fun, args)    => applyCommon("ApplyDynamic", tree, fun, args)
125
 
 
126
 
          case Block(stats, expr) =>
127
 
            println("Block(" + nodeinfo(tree))
128
 
            if (stats.isEmpty)
129
 
              println("  List(), // no statement")
130
 
            else {
131
 
              val n = stats.length
132
 
              println("  List( // " + n + " statement(s)")
133
 
              for (i <- 0 until n)
134
 
                traverse(stats(i), level + 2, i < n-1)
135
 
              println("  ),")
136
 
            }
137
 
            traverse(expr, level + 1, false)
138
 
            printcln(")")
139
 
          case ClassDef(mods, name, tparams, impl) =>
140
 
            println("ClassDef(" + nodeinfo(tree))
141
 
            println("  " + symflags(tree))
142
 
            println("  \"" + name + "\",")
143
 
            if (tparams.isEmpty)
144
 
              println("  List(), // no type parameter")
145
 
            else {
146
 
              val n = tparams.length
147
 
              println("  List( // " + n + " type parameter(s)")
148
 
              for (i <- 0 until n)
149
 
                traverse(tparams(i), level + 2, i < n-1)
150
 
              println("  ),")
151
 
            }
152
 
            traverse(impl, level + 1, false)
153
 
            printcln(")")
154
 
          case DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
155
 
            println("DefDef(" + nodeinfo(tree))
156
 
            println("  " + symflags(tree))
157
 
            println("  \"" + name + "\",")
158
 
            if (tparams.isEmpty)
159
 
              println("  List(), // no type parameter")
160
 
            else {
161
 
              val n = tparams.length
162
 
              println("  List( // " + n + " type parameter(s)")
163
 
              for (i <- 0 until n)
164
 
                traverse(tparams(i), level + 2, i < n-1)
165
 
              println("  ),")
166
 
            }
167
 
            val n = vparamss.length
168
 
            if (n == 1 && vparamss(0).isEmpty)
169
 
              println("  List(List()), // no parameter")
170
 
            else {
171
 
              println("  List(")
172
 
              for (i <- 0 until n) {
173
 
                val m = vparamss(i).length
174
 
                println("    List( // " + m + " parameter(s)")
175
 
                for (j <- 0 until m)
176
 
                  traverse(vparamss(i)(j), level + 3, j < m-1)
177
 
                println("    )")
178
 
              }
179
 
              println("  ),")
180
 
            }
181
 
            println("  " + tpt + ",")
182
 
            traverse(rhs, level + 1, false)
183
 
            printcln(")")
184
 
          case EmptyTree =>
185
 
            printcln("EmptyTree")
186
 
          case Ident(name) =>
187
 
            printcln("Ident(\"" + name + "\")" + nodeinfo2(tree))
188
 
          case Literal(value) =>
189
 
            printcln("Literal(" + value + ")")
190
 
          case New(tpt) =>
191
 
            println("New(" + nodeinfo(tree))
192
 
            traverse(tpt, level + 1, false)
193
 
            printcln(")")
194
 
          case Select(qualifier, selector) =>
195
 
            println("Select(" + nodeinfo(tree))
196
 
            traverse(qualifier, level + 1, true)
197
 
            printcln("  \"" + selector + "\")")
198
 
          case Super(qual, mix) =>
199
 
            println("Super(\"" + mix + "\")" + nodeinfo(tree))
200
 
            traverse(qual, level + 1, true)
201
 
          case Template(parents, self, body) =>
202
 
            println("Template(" + nodeinfo(tree))
203
 
            println("  " + parents.map(p =>
204
 
                if (p.tpe ne null) p.tpe.typeSymbol else "null-" + p
205
 
              ) + ", // parents")
206
 
            traverse(self, level + 1, true)
207
 
            if (body.isEmpty)
208
 
              println("  List() // no body")
209
 
            else {
210
 
              val n = body.length
211
 
              println("  List( // body")
212
 
              for (i <- 0 until n)
213
 
                traverse(body(i), level + 2, i < n-1)
214
 
              println("  )")
215
 
            }
216
 
            printcln(")")
217
 
          case This(qual) =>
218
 
            println("This(\"" + qual + "\")" + nodeinfo2(tree))
219
 
          case TypeApply(fun, args) =>
220
 
            println("TypeApply(" + nodeinfo(tree))
221
 
            traverse(fun, level + 1, true)
222
 
            if (args.isEmpty)
223
 
              println("  List() // no argument")
224
 
            else {
225
 
              val n = args.length
226
 
              println("  List(")
227
 
              for (i <- 0 until n)
228
 
                traverse(args(i), level + 1, i < n-1)
229
 
              println("  )")
230
 
            }
231
 
            printcln(")")
232
 
          case TypeTree() =>
233
 
            printcln("TypeTree()" + nodeinfo2(tree))
234
 
          case Typed(expr, tpt) =>
235
 
            println("Typed(" + nodeinfo(tree))
236
 
            traverse(expr, level + 1, true)
237
 
            traverse(tpt, level + 1, false)
238
 
            printcln(")")
239
 
          case ValDef(mods, name, tpt, rhs) =>
240
 
            println("ValDef(" + nodeinfo(tree))
241
 
            println("  " + symflags(tree))
242
 
            println("  \"" + name + "\",")
243
 
            traverse(tpt, level + 1, true)
244
 
            traverse(rhs, level + 1, false)
245
 
            printcln(")")
246
 
          case PackageDef(pid, stats) =>
247
 
            println("PackageDef(")
248
 
            traverse(pid, level + 1, false)
249
 
            println(",\n")
250
 
            for (stat <- stats)
251
 
              traverse(stat, level + 1, false)
252
 
            printcln(")")
253
 
          case _ =>
254
 
            tree match {
255
 
              case p: Product =>
256
 
                if (p.productArity != 0) {
257
 
                  println(p.productPrefix+"(")
258
 
                  for (elem <- (0 until p.productArity) map p.productElement) {
259
 
                    def printElem(elem: Any, level: Int): Unit = elem match {
260
 
                      case t: Tree =>
261
 
                        traverse(t, level, false)
262
 
                      case xs: List[_] =>
263
 
                        print("List(")
264
 
                        for (x <- xs) printElem(x, level+1)
265
 
                        printcln(")")
266
 
                      case _ =>
267
 
                        println(elem.toString)
268
 
                    }
269
 
                    printElem(elem, level+1)
270
 
                  }
271
 
                  printcln(")")
272
 
                } else printcln(p.productPrefix)
273
 
            }
274
 
        }
275
 
      }
276
 
      buf setLength 0
277
 
      traverse(tree, 0, false)
 
70
    private var level = 0
 
71
 
 
72
    def showName(name: Name): String
 
73
    def showPosition(tree: Tree): String
 
74
    def showNameAndPos(tree: NameTree): String
 
75
    def showDefTreeName(defTree: DefTree): String
 
76
    def showFlags(tree: MemberDef): String
 
77
    def showLiteral(lit: Literal): String
 
78
    def showTypeTree(tt: TypeTree): String
 
79
    def showAttributes(tree: Tree): String  // symbol and type
 
80
 
 
81
    def showRefTreeName(tree: Tree): String = {
 
82
      tree match {
 
83
        case SelectFromTypeTree(qual, name) => showRefTreeName(qual) + "#" + showName(name)
 
84
        case Select(qual, name)             => showRefTreeName(qual) + "." + showName(name)
 
85
        case id @ Ident(name)               => showNameAndPos(id)
 
86
        case _                              => "" + tree
 
87
      }
 
88
    }
 
89
    def showRefTree(tree: RefTree): String = {
 
90
      def prefix0 = showRefTreeName(tree.qualifier)
 
91
      def prefix = if (prefix0 == "") "" else (tree match {
 
92
        case SelectFromTypeTree(_, _) => prefix0 + "#"
 
93
        case Select(_, _)             => prefix0 + "."
 
94
        case _                        => ""
 
95
      })
 
96
      prefix + showNameAndPos(tree) + emptyOrComment(showAttributes(tree))
 
97
    }
 
98
 
 
99
    def emptyOrComment(s: String) = if (s == "") "" else " // " + s
 
100
 
 
101
    def stringify(tree: Tree): String = {
 
102
      buf.clear()
 
103
      if (settings.XshowtreesStringified.value) buf.append(tree.toString + EOL)
 
104
      if (settings.XshowtreesCompact.value) {
 
105
        buf.append(showRaw(tree, printIds = settings.uniqid.value, printTypes = settings.printtypes.value))
 
106
      } else {
 
107
        level = 0
 
108
        traverse(tree)
 
109
      }
278
110
      buf.toString
279
111
    }
 
112
    def traverseAny(x: Any) {
 
113
      x match {
 
114
        case t: Tree      => traverse(t)
 
115
        case xs: List[_]  => printMultiline("List", "")(xs foreach traverseAny)
 
116
        case _            => println("" + x)
 
117
      }
 
118
    }
 
119
    def println(s: String) = printLine(s, "")
 
120
 
 
121
    def printLine(value: String, comment: String) {
 
122
      buf append "  " * level
 
123
      buf append value
 
124
      if (comment != "") {
 
125
        if (value != "")
 
126
          buf append " "
 
127
 
 
128
        buf append "// "
 
129
        buf append comment
 
130
      }
 
131
      buf append EOL
 
132
    }
 
133
 
 
134
    def annotationInfoToString(annot: AnnotationInfo): String = {
 
135
      val str = new StringBuilder
 
136
      str.append(annot.atp.toString())
 
137
      if (!annot.args.isEmpty)
 
138
        str.append(annot.args.mkString("(", ",", ")"))
 
139
      if (!annot.assocs.isEmpty)
 
140
        for (((name, value), index) <- annot.assocs.zipWithIndex) {
 
141
          if (index > 0)
 
142
            str.append(", ")
 
143
          str.append(name).append(" = ").append(value)
 
144
        }
 
145
      str.toString
 
146
    }
 
147
    def printModifiers(tree: MemberDef) {
 
148
      // SI-5885: by default this won't print annotations of not yet initialized symbols
 
149
      val annots0 = tree.symbol.annotations match {
 
150
        case Nil  => tree.mods.annotations
 
151
        case xs   => xs map annotationInfoToString
 
152
      }
 
153
      val annots = annots0 match {
 
154
        case Nil  => ""
 
155
        case xs   => " " + xs.mkString("@{ ", ", ", " }")
 
156
      }
 
157
      val flagString = showFlags(tree) match {
 
158
        case ""   => "0"
 
159
        case s    => s
 
160
      }
 
161
      println(flagString + annots)
 
162
    }
 
163
 
 
164
    def applyCommon(tree: Tree, fun: Tree, args: List[Tree]) {
 
165
      printMultiline(tree) {
 
166
        traverse(fun)
 
167
        traverseList("Nil", "argument")(args)
 
168
      }
 
169
    }
 
170
 
 
171
    def treePrefix(tree: Tree) = showPosition(tree) + tree.productPrefix
 
172
    def printMultiline(tree: Tree)(body: => Unit) {
 
173
      printMultiline(treePrefix(tree), showAttributes(tree))(body)
 
174
    }
 
175
    def printMultiline(prefix: String, comment: String)(body: => Unit) {
 
176
      printLine(prefix + "(", comment)
 
177
      indent(body)
 
178
      println(")")
 
179
    }
 
180
 
 
181
    @inline private def indent[T](body: => T): T = {
 
182
      level += 1
 
183
      try body
 
184
      finally level -= 1
 
185
    }
 
186
 
 
187
    def traverseList(ifEmpty: String, what: String)(trees: List[Tree]) {
 
188
      if (trees.isEmpty)
 
189
        println(ifEmpty)
 
190
      else if (trees.tail.isEmpty)
 
191
        traverse(trees.head)
 
192
      else {
 
193
        printLine("", trees.length + " " + what + "s")
 
194
        trees foreach traverse
 
195
      }
 
196
    }
 
197
 
 
198
    def printSingle(tree: Tree, name: Name) {
 
199
      println(treePrefix(tree) + "(" + showName(name) + ")" + showAttributes(tree))
 
200
    }
 
201
 
 
202
    def traverse(tree: Tree) {
 
203
      showPosition(tree)
 
204
 
 
205
      tree match {
 
206
        case AppliedTypeTree(tpt, args) => applyCommon(tree, tpt, args)
 
207
        case ApplyDynamic(fun, args)    => applyCommon(tree, fun, args)
 
208
        case Apply(fun, args)           => applyCommon(tree, fun, args)
 
209
 
 
210
        case Throw(Ident(name)) =>
 
211
          printSingle(tree, name)
 
212
 
 
213
        case b @ Bind(name, body) =>
 
214
          printMultiline(tree) {
 
215
            println(showDefTreeName(b))
 
216
            traverse(body)
 
217
          }
 
218
 
 
219
        case ld @ LabelDef(name, params, rhs) =>
 
220
          printMultiline(tree) {
 
221
            showNameAndPos(ld)
 
222
            traverseList("()", "params")(params)
 
223
            traverse(rhs)
 
224
          }
 
225
 
 
226
        case Function(vparams, body) =>
 
227
          printMultiline(tree) {
 
228
            traverseList("()", "parameter")(vparams)
 
229
            traverse(body)
 
230
          }
 
231
        case Try(block, catches, finalizer) =>
 
232
          printMultiline(tree) {
 
233
            traverse(block)
 
234
            traverseList("{}", "case")(catches)
 
235
            if (finalizer ne EmptyTree)
 
236
              traverse(finalizer)
 
237
          }
 
238
 
 
239
        case Match(selector, cases) =>
 
240
          printMultiline(tree) {
 
241
            traverse(selector)
 
242
            traverseList("", "case")(cases)
 
243
          }
 
244
        case CaseDef(pat, guard, body) =>
 
245
          printMultiline(tree) {
 
246
            traverse(pat)
 
247
            if (guard ne EmptyTree)
 
248
              traverse(guard)
 
249
            traverse(body)
 
250
          }
 
251
        case Block(stats, expr) =>
 
252
          printMultiline(tree) {
 
253
            traverseList("{}", "statement")(stats)
 
254
            traverse(expr)
 
255
          }
 
256
        case cd @ ClassDef(mods, name, tparams, impl) =>
 
257
          printMultiline(tree) {
 
258
            printModifiers(cd)
 
259
            println(showDefTreeName(cd))
 
260
            traverseList("[]", "type parameter")(tparams)
 
261
            traverse(impl)
 
262
          }
 
263
        case md @ ModuleDef(mods, name, impl) =>
 
264
          printMultiline(tree) {
 
265
            printModifiers(md)
 
266
            println(showDefTreeName(md))
 
267
            traverse(impl)
 
268
          }
 
269
        case dd @ DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
 
270
          printMultiline(tree) {
 
271
            printModifiers(dd)
 
272
            println(showDefTreeName(dd))
 
273
            traverseList("[]", "type parameter")(tparams)
 
274
            vparamss match {
 
275
              case Nil        => println("Nil")
 
276
              case Nil :: Nil => println("List(Nil)")
 
277
              case ps  :: Nil =>
 
278
                printLine("", "1 parameter list")
 
279
                ps foreach traverse
 
280
              case pss        =>
 
281
                printLine("", pss.length + " parameter lists")
 
282
                pss foreach (ps => traverseList("()", "parameter")(ps))
 
283
            }
 
284
            traverse(tpt)
 
285
            traverse(rhs)
 
286
          }
 
287
        case EmptyTree =>
 
288
          println(showName(nme.EMPTY))
 
289
        case lit @ Literal(value) =>
 
290
          println(showLiteral(lit))
 
291
        case New(tpt) =>
 
292
          printMultiline(tree)(traverse(tpt))
 
293
        case Super(This(qual), mix) =>
 
294
          println("Super(This(" + showName(qual) + "), " + showName(mix) + ")")
 
295
        case Super(qual, mix) =>
 
296
          printMultiline(tree) {
 
297
            traverse(qual)
 
298
            showName(mix)
 
299
          }
 
300
        case Template(parents, self, body) =>
 
301
          printMultiline(tree) {
 
302
            val ps0 = parents map { p =>
 
303
              if (p.tpe eq null) p match {
 
304
                case x: RefTree => showRefTree(x)
 
305
                case x          => showPosition(x) + x
 
306
              }
 
307
              else showName(newTypeName(p.tpe.typeSymbol.fullName))
 
308
            }
 
309
            printLine(ps0 mkString ", ", "parents")
 
310
            traverse(self)
 
311
            traverseList("{}", "statement")(body)
 
312
          }
 
313
        case This(qual) =>
 
314
          printSingle(tree, qual)
 
315
        case TypeApply(fun, args) =>
 
316
          printMultiline(tree) {
 
317
            traverse(fun)
 
318
            traverseList("[]", "type argument")(args)
 
319
          }
 
320
        case tt @ TypeTree() =>
 
321
          println(showTypeTree(tt))
 
322
 
 
323
        case Typed(expr, tpt) =>
 
324
          printMultiline(tree) {
 
325
            traverse(expr)
 
326
            traverse(tpt)
 
327
          }
 
328
        case vd @ ValDef(mods, name, tpt, rhs) =>
 
329
          printMultiline(tree) {
 
330
            printModifiers(vd)
 
331
            println(showDefTreeName(vd))
 
332
            traverse(tpt)
 
333
            traverse(rhs)
 
334
          }
 
335
        case td @ TypeDef(mods, name, tparams, rhs) =>
 
336
          printMultiline(tree) {
 
337
            printModifiers(td)
 
338
            println(showDefTreeName(td))
 
339
            traverseList("[]", "type parameter")(tparams)
 
340
            traverse(rhs)
 
341
          }
 
342
 
 
343
        case PackageDef(pid, stats) =>
 
344
          printMultiline("PackageDef", "")(pid :: stats foreach traverse)
 
345
 
 
346
        case _ =>
 
347
          tree match {
 
348
            case t: RefTree               => println(showRefTree(t))
 
349
            case t if t.productArity == 0 => println(treePrefix(t))
 
350
            case t                        => printMultiline(tree)(tree.productIterator foreach traverseAny)
 
351
          }
 
352
      }
 
353
    }
280
354
  }
281
355
 
282
356
  def printUnit(unit: CompilationUnit) {