Merge pull request #3032 from dotty-staging/topic/harmonize-printers

Remove duplication from `UserFacingPrinter`

Author: felixmulder

build.sbt

@@ -18,7 +18,6 @@ val `dotty-bench-bootstrapped` = Build.`dotty-bench-bootstrapped`
 val `scala-library` = Build.`scala-library`
 val `scala-compiler` = Build.`scala-compiler`
 val `scala-reflect` = Build.`scala-reflect`
-val `dotty-repl` = Build.`dotty-repl`
 val scalap = Build.scalap
 val dist = Build.dist
 val `dist-bootstrapped` = Build.`dist-bootstrapped`

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

@@ -662,6 +662,11 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   override protected def keyString(sym: Symbol): String = {
     val flags = sym.flagsUNSAFE
     if (sym.isType && sym.owner.isTerm) ""
+    else if (sym.isPackageObject) "package object"
+    else if (flags.is(Module) && flags.is(Case)) "case object"
+    else if (sym.isClass && flags.is(Case)) "case class"
+    else if (flags is Module) "object"
+    else if (sym.isTerm && !flags.is(Param) && flags.is(Implicit)) "implicit val"
     else super.keyString(sym)
   }
 

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

@@ -0,0 +1,71 @@
+package dotty.tools.dotc
+package printing
+
+import core._
+import Constants.Constant, Contexts.Context, Denotations._, Flags._, Names._
+import NameOps._, StdNames._, Decorators._, Scopes.Scope, Types._, Texts._
+import SymDenotations.NoDenotation, Symbols.{ Symbol, ClassSymbol, defn }
+
+class UserFacingPrinter(_ctx: Context) extends RefinedPrinter(_ctx) {
+
+  private[this] def getPkgCls(path: String) =
+    _ctx.requiredPackage(path).moduleClass.asClass
+
+  private lazy val collectionPkg = getPkgCls("scala.collection")
+  private lazy val immutablePkg  = getPkgCls("scala.collection.immutable")
+  private lazy val scalaPkg      = defn.ScalaPackageClass
+  private lazy val javaLangPkg   = defn.JavaLangPackageVal.moduleClass.asClass
+
+  def standardPkg(pkgSym: Symbol) = pkgSym match {
+    case `scalaPkg` | `collectionPkg` | `immutablePkg` | `javaLangPkg` => true
+    case _ => false
+  }
+
+  def wrappedName(pkgSym: Symbol) =
+    pkgSym.name.toTermName == nme.EMPTY_PACKAGE ||
+    pkgSym.name.isReplWrapperName
+
+  def wellKnownPkg(pkgSym: Symbol) = standardPkg(pkgSym) || wrappedName(pkgSym)
+
+  override protected def keyString(sym: Symbol): String =
+    if (sym.flagsUNSAFE is Package) "" else super.keyString(sym)
+
+  override def nameString(name: Name): String =
+    if (name.isReplAssignName) name.decode.toString.takeWhile(_ != '$')
+    else name.decode.toString
+
+  override def toText(sym: Symbol): Text =
+    if (sym.name.isReplAssignName) nameString(sym.name)
+    else keyString(sym) ~~ nameString(sym.name.stripModuleClassSuffix)
+
+  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)
+  }
+
+  override def toText(const: Constant): Text = Str(const.value.toString)
+
+  override def toText(tp: Type): Text = tp match {
+    case ExprType(result) => ":" ~~ toText(result)
+    case tp: ConstantType => toText(tp.value)
+    case tp: TypeRef => tp.info match {
+      case TypeAlias(alias) => toText(alias)
+      case _ => toText(tp.info)
+    }
+    case tp: ClassInfo => {
+      if (wellKnownPkg(tp.cls.owner)) nameString(tp.cls.name)
+      else {
+        def printPkg(sym: ClassSymbol): Text =
+          if (sym.owner == defn.RootClass || wrappedName(sym.owner))
+            nameString(sym.name.stripModuleClassSuffix)
+          else
+            printPkg(sym.owner.asClass) ~ "." ~ toText(sym)
+
+        printPkg(tp.cls.owner.asClass) ~ "." ~ nameString(tp.cls.name)
+      }
+    }
+    case tp => super.toText(tp)
+  }
+}

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

@@ -20,4 +20,10 @@ package object printing {
    *  -Xprint will print `sym.name` instead of `sym.originalName`
    */
   val XprintMode = new Key[Unit]
+
+  /** @pre `nel` is non-empty list */
+  private[printing] implicit class ListOps[A](val nel: List[A]) extends AnyVal {
+    def intersperse(a: A): List[A] =
+      nel.flatMap(a :: _ :: Nil).tail
+  }
 }

repl/src/dotty/tools/repl/AbstractFileClassLoader.scala renamed to compiler/src/dotty/tools/repl/AbstractFileClassLoader.scala

@@ -95,7 +95,7 @@ case object Help extends Command {
 
 object ParseResult {
 
-  private[this] val CommandExtract = """(:[\S]+)\s*(.*)""".r
+  @sharable private[this] val CommandExtract = """(:[\S]+)\s*(.*)""".r
 
   /** Extract a `ParseResult` from the string `sourceCode` */
   def apply(sourceCode: String)(implicit ctx: Context): ParseResult =