Create ReplPrinter

Author: nicolasstucki

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -101,7 +101,6 @@ class ScalaSettings extends Settings.SettingGroup {
   val YplainPrinter = BooleanSetting("-Yplain-printer", "Pretty-print using a plain printer.")
   val YprintSyms = BooleanSetting("-Yprint-syms", "when printing trees print info in symbols instead of corresponding info in trees.")
   val YprintDebug = BooleanSetting("-Yprint-debug", "when printing trees, print some extra information useful for debugging.")
-  val YprintRepl = BooleanSetting("-Yprint-repl", "Print the program removing REPL encodings.")
   val YshowPrintErrors = BooleanSetting("-Yshow-print-errors", "don't suppress exceptions thrown during tree printing.")
   val YtestPickler = BooleanSetting("-Ytest-pickler", "self-test for pickling functionality; should be used with -Ystop-after:pickler")
   val YcheckReentrant = BooleanSetting("-Ycheck-reentrant", "check that compiled program does not contain vars that can be accessed from a global root.")

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

@@ -40,7 +40,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   private[this] var myCtx: Context = _ctx
   private[this] var printPos = ctx.settings.YprintPos.value
   private[this] val printLines = ctx.settings.printLines.value
-  private[this] val YprintRepl = ctx.settings.YprintRepl.value
 
   override protected[this] implicit def ctx: Context = myCtx
 
@@ -193,8 +192,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
               return nameString(tp.symbol)
             case _ =>
           }
-      case ExprType(result) =>
-        return (if (YprintRepl) ": " else "=> ") ~ toText(result)
+      case tp: ExprType =>
+        return exprToText(tp)
       case ErasedValueType(tycon, underlying) =>
         return "ErasedValueType(" ~ toText(tycon) ~ ", " ~ toText(underlying) ~ ")"
       case tp: ClassInfo =>
@@ -226,6 +225,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     super.toText(tp)
   }
 
+  protected def exprToText(tp: ExprType): Text =
+    "=> " ~ toText(tp.resType)
+
   protected def blockText[T >: Untyped](trees: List[Tree[T]]): Text =
     ("{" ~ toText(trees, "\n") ~ "}").close
 
@@ -718,33 +720,12 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         case info: ImportType => return s"import $info.expr.show"
         case _ =>
       }
-    if (YprintRepl) {
-      if (sym.name.isReplAssignName) nameString(sym.name)
-      else keyString(sym) ~~ nameString(sym.name.stripModuleClassSuffix)
-    }
-    else if (sym.is(ModuleClass))
+    if (sym.is(ModuleClass))
       kindString(sym) ~~ (nameString(sym.name.stripModuleClassSuffix) + idString(sym))
     else
       super.toText(sym)
   }
 
-  override def toText(const: Constant): Text =
-    if (!YprintRepl) super.toText(const)
-    else if (const.tag == StringTag) Str('"' + const.value.toString + '"')
-    else Str(const.value.toString)
-
-  override def dclText(sym: Symbol): Text = {
-    if (!YprintRepl) super.dclText(sym)
-    else {
-      toText(sym) ~ {
-        if (sym.is(Method)) toText(sym.info)
-        else if (sym.isType && sym.info.isInstanceOf[TypeAlias]) toText(sym.info)
-        else if (sym.isType || sym.isClass) ""
-        else ":" ~~ toText(sym.info)
-      }
-    }
-  }
-
   override def kindString(sym: Symbol) = {
     val flags = sym.flagsUNSAFE
     if (flags is Package) "package"

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

@@ -0,0 +1,35 @@
+package dotty.tools.dotc.printing
+
+import dotty.tools.dotc.core.Constants
+import dotty.tools.dotc.core.Constants.Constant
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.NameOps._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types.{ExprType, TypeAlias}
+import dotty.tools.dotc.printing.Texts._
+
+import scala.language.implicitConversions
+
+class ReplPrinter(_ctx: Context) extends DecompilerPrinter(_ctx) {
+
+  override protected def exprToText(tp: ExprType): Text =
+    ": " ~ toText(tp.resType)
+
+  override def toText(sym: Symbol): Text =
+    if (sym.name.isReplAssignName) nameString(sym.name)
+    else keyString(sym) ~~ nameString(sym.name.stripModuleClassSuffix)
+
+  override def toText(const: Constant): Text =
+    if (const.tag == Constants.StringTag) Str('"' + const.value.toString + '"')
+    else Str(const.value.toString)
+
+  override def dclText(sym: Symbol): Text = {
+    toText(sym) ~ {
+      if (sym.is(Method)) toText(sym.info)
+      else if (sym.isType && sym.info.isInstanceOf[TypeAlias]) toText(sym.info)
+      else if (sym.isType || sym.isClass) ""
+      else ":" ~~ toText(sym.info)
+    }
+  }
+}

compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala

@@ -4,12 +4,9 @@ package typer
 
 import ast._
 import core._
-import Trees._
 import Types._, ProtoTypes._, Contexts._, Decorators._, Denotations._, Symbols._
-import Applications._, Implicits._, Flags._
+import Implicits._, Flags._
 import util.Positions._
-import printing.{Showable, RefinedPrinter}
-import scala.collection.mutable
 import java.util.regex.Matcher.quoteReplacement
 import reporting.diagnostic.Message
 import reporting.diagnostic.messages._

compiler/src/dotty/tools/repl/package.scala

@@ -2,15 +2,9 @@ package dotty.tools
 
 import dotc.core.Contexts.Context
 import dotc.core.Symbols.Symbol
-import dotc.core.Denotations.Denotation
 import dotc.reporting.diagnostic.MessageContainer
-import dotc.printing.RefinedPrinter
-
-import dotc.reporting.{
-  StoreReporter,
-  UniqueMessagePositions,
-  HideNonSensicalMessages
-}
+import dotc.printing.ReplPrinter
+import dotc.reporting.{HideNonSensicalMessages, StoreReporter, UniqueMessagePositions}
 
 package object repl {
   /** Create empty outer store reporter */
@@ -20,11 +14,9 @@ package object repl {
 
   private[repl] implicit class ShowUser(val s: Symbol) extends AnyVal {
     def showUser(implicit ctx: Context): String = {
-      val ctx2 = ctx.fresh
-      ctx2.setSetting(ctx2.settings.YprintRepl, true)
-      val printer = new RefinedPrinter(ctx2)
+      val printer = new ReplPrinter(ctx)
       val text = printer.dclText(s)
-      text.mkString(ctx2.settings.pageWidth.value, ctx2.settings.printLines.value)
+      text.mkString(ctx.settings.pageWidth.value, ctx.settings.printLines.value)
     }
   }