Remove duplication from UserFacingPrinter

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/ParseResult.scala → compiler/src/dotty/tools/repl/ParseResult.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 =

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

@@ -4,6 +4,7 @@ import dotc.core.Contexts.Context
 import dotc.core.Symbols.Symbol
 import dotc.core.Denotations.Denotation
 import dotc.reporting.diagnostic.MessageContainer
+import dotc.printing.UserFacingPrinter
 
 import dotc.reporting.{
   StoreReporter,
@@ -17,11 +18,6 @@ package object repl {
     new StoreReporter(null)
     with UniqueMessagePositions with HideNonSensicalMessages
 
-  private[repl] implicit class ListOps[A](val nel: List[A]) extends AnyVal {
-    def intersperse(a: A): List[A] =
-      nel.flatMap(a :: _ :: Nil).tail
-  }
-
   private[repl] implicit class ShowUser(val s: Symbol) extends AnyVal {
     def showUser(implicit ctx: Context): String = {
       val printer = new UserFacingPrinter(ctx)

repl/test-resources/repl/i2554 → compiler/test-resources/repl/i2554

@@ -4,6 +4,4 @@ scala> import foo._
 scala> implicit val shape: Shape[_ <: FlatShapeLevel, Int, Int, _] = null
 implicit val shape: foo.Shape[_ <: foo.FlatShapeLevel, Int, Int, _] = null
 scala> def hint = Shape.tuple2Shape(shape, shape)
-def hint: foo.Shape[foo.FlatShapeLevel, Tuple2[Int, Int], Tuple2[Int, Int],
-  Tuple2
-[_, _]]
+def hint: foo.Shape[foo.FlatShapeLevel, (Int, Int), (Int, Int), ()]

compiler/test-resources/type-printer/functions

@@ -0,0 +1,2 @@
+scala> val toInt: Any => Int = new { def apply(a: Any) = 1; override def toString() = "<func1>" }
+val toInt: Any => Int = <func1>

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -197,7 +197,7 @@ class CompilationTests extends ParallelTesting {
     compileDir("../compiler/src/dotty/tools/dotc/config", picklingOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/parsing", picklingOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/printing", picklingOptions) +
-    compileDir("../repl/src/dotty/tools/repl", picklingOptions) +
+    compileDir("../compiler/src/dotty/tools/repl", picklingOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/rewrite", picklingOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/transform", picklingOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/typer", picklingOptions) +

compiler/test/dotty/tools/dotc/reporting/ErrorMessagesTests.scala

@@ -365,7 +365,7 @@ class ErrorMessagesTests extends ErrorMessagesTest {
   @Test def methodDoesNotTakePrameters =
     checkMessagesAfter("frontend") {
       """
-        |object Scope{
+        |object Scope {
         |  def foo = ()
         |  foo()
         |}

project/Build.scala

@@ -130,6 +130,7 @@ object Build {
     javaSource        in Compile    := baseDirectory.value / "src",
     javaSource        in Test       := baseDirectory.value / "test",
     resourceDirectory in Compile    := baseDirectory.value / "resources",
+    resourceDirectory in Test       := baseDirectory.value / "test-resources",
 
     // Prevent sbt from rewriting our dependencies
     ivyScala ~= (_ map (_ copy (overrideScalaVersion = false)))
@@ -407,7 +408,6 @@ object Build {
     settings(commonBootstrappedSettings).
     settings(dottyDocSettings)
 
-
   lazy val `dotty-bot` = project.in(file("bot")).
     settings(commonScala2Settings).
     settings(