Create DecompilerPrinter and ReplPrinter

Author: nicolasstucki

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

@@ -6,6 +6,7 @@ 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.
@@ -36,15 +37,17 @@ class DecompilationPrinter extends Phase {
   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
 
     out.println(doubleLine)
     out.println(unit.source)
     out.println(line)
 
-    out.println(unit.tpdTree.show)
+    val printer = new DecompilerPrinter(ctx)
+
+    out.println(printer.toText(unit.tpdTree).mkString(pageWidth, printLines))
     out.println(line)
 
     if (ctx.settings.printTasty.value) {

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

@@ -0,0 +1,64 @@
+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 modText(mods: untpd.Modifiers, kw: String): Text = { // DD
+    val suppressKw = if (enclDefIsClass) mods is ParamAndLocal else mods is Param
+    var flagMask =
+      if (ctx.settings.YdebugFlags.value) AnyFlags
+      else if (suppressKw) PrintableFlags &~ Private
+      else PrintableFlags
+    if (homogenizedView && mods.flags.isTypeFlags) flagMask &~= Implicit // drop implicit from classes
+    val flags = mods.flags & flagMask
+    val flagsText = if (flags.isEmpty) "" else keywordStr((mods.flags & flagMask).toString)
+    val annotations = mods.annotations.filter(_.tpe != defn.SourceFileAnnotType)
+    Text(annotations.map(annotText), " ") ~~ flagsText ~~ (Str(kw) provided !suppressKw)
+  }
+
+  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 " = ") ~ _)
+      }
+    }
+  }
+}