refactor printers

Author: bishabosha

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

@@ -22,20 +22,22 @@ class OutlinePrinter private (_ctx: Context) extends RefinedPrinter(_ctx) {
 
   /* Typical patterns seen in output of typer for Java code, plus the output of unpickling an ELIDED tree */
   def isElidableExpr[T <: Untyped](tree: Tree[T]): Boolean = tree match {
+    case tree if tree.isEmpty => false
     case tree: Ident[T] if tree.name == nme.WILDCARD => true // `ELIDED exprType`
     case tree: Literal[T] => true // e.g. `()`
     case tree: Select[T] if tree.symbol == defn.Predef_undefined => true // e.g. `Predef.???`
     case Apply(Select(tree: New[T], nme.CONSTRUCTOR), Nil)
     if tree.tpt.typeOpt.typeSymbol.is(Module) => true // e.g. `new foo.Foo$()` (rhs of a module val)
-    case _ => false
+    case _ =>
+      sys.error(s"Unexpected tree in OutlinePrinter: ${tree.show}, $tree")
+      false
   }
 
-  def elideExpr[T <: Untyped](tree: Tree[T], original: => Text): Text =
-    if isElidableExpr(tree) then Str("_") else original
+  override protected def rhsValDef[T <: Untyped](tree: ValDef[T]): Text =
+    if isElidableExpr(tree.rhs) then " = " ~ "elided" ~ "[" ~ toText(tree.tpt) ~ "]"
+    else super.rhsValDef(tree)
 
-  override protected def rhsValDef[T <: Untyped](rhs: Tree[T], original: => Text): Text =
-    elideExpr(rhs, original)
-
-  override protected def rhsDefDef[T <: Untyped](rhs: Tree[T], original: => Text): Text =
-    elideExpr(rhs, original)
+  override protected def rhsDefDef[T <: Untyped](tree: DefDef[T]): Text =
+    if isElidableExpr(tree.rhs) then " = " ~ "elided" ~ "["  ~ toText(tree.tpt) ~ "]"
+    else super.rhsDefDef(tree)
 }

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

@@ -29,8 +29,6 @@ import dotty.tools.dotc.util.SourcePosition
 import dotty.tools.dotc.ast.untpd.{MemberDef, Modifiers, PackageDef, RefTree, Template, TypeDef, ValOrDefDef}
 import cc.{CaptureSet, CapturingType, toCaptureSet, IllegalCaptureRef}
 
-import scala.annotation.unused
-
 class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
   /** A stack of enclosing DefDef, TypeDef, or ClassDef, or ModuleDefs nodes */
@@ -922,7 +920,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     dclTextOr(tree) {
       modText(tree.mods, tree.symbol, keywordStr(if (tree.mods.is(Mutable)) "var" else "val"), isType = false) ~~
         valDefText(nameIdText(tree)) ~ optAscription(tree.tpt) ~
-        withEnclosingDef(tree) { optText(tree.rhs)(rhs => " = " ~ rhsValDef(tree.rhs, rhs)) }
+        withEnclosingDef(tree) { rhsValDef(tree) }
     }
   }
 
@@ -979,19 +977,18 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
         coreSig
         ~ optAscription(tree.tpt)
-        ~ optText(tree.rhs)(rhs =>
-            " = " ~ rhsDefDef(tree.rhs, keywordText("macro ").provided(tree.symbol.isScala2Macro) ~ rhs))
+        ~ rhsDefDef(tree)
       }
     }
   }
 
   /** Inspect the rhs of a ValDef, overridden in OutlinePrinter */
-  protected def rhsValDef[T <: Untyped](@unused("override may inspect rhs") rhs: Tree[T], original: => Text): Text =
-    original
+  protected def rhsValDef[T <: Untyped](tree: ValDef[T]): Text =
+    optText(tree.rhs)(" = " ~ _)
 
   /** Inspect the rhs of a DefDef, overridden in OutlinePrinter */
-  protected def rhsDefDef[T <: Untyped](@unused("override may inspect rhs") rhs: Tree[T], original: => Text): Text =
-    original
+  protected def rhsDefDef[T <: Untyped](tree: DefDef[T]): Text =
+    optText(tree.rhs)(" = " ~ keywordText("macro ").provided(tree.symbol.isScala2Macro) ~ _)
 
   protected def toTextTemplate(impl: Template, ofNew: Boolean = false): Text = {
     val Template(constr @ DefDef(_, paramss, _, _), _, self, _) = impl

compiler/src/dotty/tools/dotc/transform/Pickler.scala

@@ -87,8 +87,8 @@ class Pickler extends Phase {
     Pickler.ParallelPickling && !ctx.settings.YtestPickler.value &&
     !ctx.settings.YjavaTasty.value // disable parallel pickling when `-Yjava-tasty` is set (internal testing only)
 
-  private def adjustPrinter(ictx: Context): Context =
-    if ictx.compilationUnit.typedAsJava then
+  private def adjustPrinter(ictx: Context, isOutline: Boolean): Context =
+    if isOutline then
       // use special printer because Java parser will use `Predef.???` as rhs,
       // which conflicts with the unpickling of ELIDED as `Ident(nme.WILDCARD).withType(tpe)`
       // In the future we could modify the typer/parser to elide the rhs in the same way.
@@ -105,7 +105,7 @@ class Pickler extends Phase {
       tree <- sliceTopLevel(unit.tpdTree, cls)
     do
       if ctx.settings.YtestPickler.value then
-        beforePickling(cls) = tree.show(using adjustPrinter(ctx))
+        beforePickling(cls) = tree.show(using adjustPrinter(ctx, unit.typedAsJava))
 
       val sourceRelativePath =
         val reference = ctx.settings.sourceroot.value
@@ -260,7 +260,7 @@ class Pickler extends Phase {
       val freshUnit = CompilationUnit(rootCtx.compilationUnit.source)
       freshUnit.needsCaptureChecking = unit.needsCaptureChecking
       freshUnit.knowsPureFuns = unit.knowsPureFuns
-      inContext(adjustPrinter(rootCtx.fresh.setCompilationUnit(freshUnit))):
+      inContext(adjustPrinter(rootCtx.fresh.setCompilationUnit(freshUnit), unit.typedAsJava)):
         testSame(i"$unpickled%\n%", beforePickling(cls), cls)
 
   private def testSame(unpickled: String, previous: String, cls: ClassSymbol)(using Context) =