Create DecompilerPrinter and ReplPrinter

.gitignore

@@ -71,3 +71,5 @@ compiler/test/debug/Gen.jar
 compiler/before-pickling.txt
 compiler/after-pickling.txt
 *.dotty-ide-version
+
+*.decompiled.out

compiler/src/dotty/tools/dotc/decompiler/DecompilationPrinter.scala

@@ -1,9 +1,13 @@
 package dotty.tools.dotc
 package decompiler
 
+import java.io.{OutputStream, PrintStream}
+
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.tasty.TastyPrinter
+import dotty.tools.dotc.printing.DecompilerPrinter
+import dotty.tools.io.{File, Path}
 
 /** Phase that prints the trees in all loaded compilation units.
  *
@@ -14,23 +18,41 @@ class DecompilationPrinter extends Phase {
   override def phaseName: String = "decompilationPrinter"
 
   override def run(implicit ctx: Context): Unit = {
-    val unit = ctx.compilationUnit
+    val outputDir = ctx.settings.outputDir.value
+    if (outputDir == ".") printToOutput(System.out)
+    else {
+      var os: OutputStream = null
+      var ps: PrintStream = null
+      try {
+        os = File(outputDir + ".decompiled").outputStream()
+        ps = new PrintStream(os)
+        printToOutput(ps)
+      } finally {
+        if (os ne null) os.close()
+        if (ps ne null) ps.close()
+      }
+    }
+  }
 
+  private def printToOutput(out: PrintStream)(implicit ctx: Context): Unit = {
+    val unit = ctx.compilationUnit
     val pageWidth = ctx.settings.pageWidth.value
-
+    val printLines = ctx.settings.printLines.value
     val doubleLine = "=" * pageWidth
     val line = "-" * pageWidth
 
-    println(doubleLine)
-    println(unit.source)
-    println(line)
+    out.println(doubleLine)
+    out.println(unit.source)
+    out.println(line)
+
+    val printer = new DecompilerPrinter(ctx)
 
-    println(unit.tpdTree.show)
-    println(line)
+    out.println(printer.toText(unit.tpdTree).mkString(pageWidth, printLines))
+    out.println(line)
 
     if (ctx.settings.printTasty.value) {
       new TastyPrinter(unit.pickled.head._2).printContents()
-      println(line)
+      out.println(line)
     }
   }
 }

compiler/src/dotty/tools/dotc/printing/DecompilerPrinter.scala

@@ -0,0 +1,54 @@
+package dotty.tools.dotc.printing
+
+import dotty.tools.dotc.ast.Trees.{Closure, DefDef, Untyped, ValDef}
+import dotty.tools.dotc.ast.untpd.{PackageDef, Template, TypeDef}
+import dotty.tools.dotc.ast.{Trees, untpd}
+import dotty.tools.dotc.printing.Texts._
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Symbols._
+
+import scala.language.implicitConversions
+
+class DecompilerPrinter(_ctx: Context) extends RefinedPrinter(_ctx) {
+
+  override protected def filterModTextAnnots(annots: List[untpd.Tree]): List[untpd.Tree] =
+    annots.filter(_.tpe != defn.SourceFileAnnotType)
+
+  override protected def blockText[T >: Untyped](trees: List[Trees.Tree[T]]): Text = {
+    super.blockText(trees.filterNot(_.isInstanceOf[Closure[_]]))
+  }
+
+  override protected def packageDefText(tree: PackageDef): Text = {
+    val stats = tree.stats.filter {
+      case vdef: ValDef[_] => !vdef.symbol.is(Module)
+      case _ => true
+    }
+    val statsText = stats match {
+      case (pdef: PackageDef) :: Nil => toText(pdef)
+      case _ => toTextGlobal(stats, "\n")
+    }
+    val bodyText =
+      if (currentPrecedence == TopLevelPrec) "\n" ~ statsText else " {" ~ statsText ~ "}"
+    keywordStr("package ") ~ toTextPackageId(tree.pid) ~ bodyText
+  }
+
+  override protected def templateText(tree: TypeDef, impl: Template): Text = {
+    val decl =
+      if (!tree.mods.is(Module)) modText(tree.mods, keywordStr(if ((tree).mods is Trait) "trait" else "class"))
+      else modText(tree.mods &~ (Final | Module), keywordStr("object"))
+    decl ~~ typeText(nameIdText(tree)) ~ withEnclosingDef(tree) { toTextTemplate(impl) } ~ ""
+  }
+
+  override protected def defDefToText[T >: Untyped](tree: DefDef[T]): Text = {
+    import untpd.{modsDeco => _, _}
+    dclTextOr(tree) {
+      val printLambda = tree.symbol.isAnonymousFunction
+      val prefix = modText(tree.mods, keywordStr("def")) ~~ valDefText(nameIdText(tree)) provided (!printLambda)
+      withEnclosingDef(tree) {
+        addVparamssText(prefix ~ tparamsText(tree.tparams), tree.vparamss) ~ optAscription(tree.tpt).provided(!printLambda) ~
+          optText(tree.rhs)((if (printLambda) " => " else " = ") ~ _)
+      }
+    }
+  }
+}