REPL: do not dealias before printing types

Also simplify the mechanism used to avoid printing prefixes. This is now
handled in the PlainPrinter and limited to List, Map, Set, Seq.

Author: smarter

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -357,9 +357,16 @@ class Definitions {
     def newGenericArrayMethod(implicit ctx: Context) = DottyArraysModule.requiredMethod("newGenericArray")
     def newArrayMethod(implicit ctx: Context) = DottyArraysModule.requiredMethod("newArray")
 
+  lazy val ListType = ctx.requiredClassRef("scala.collection.immutable.List")
+  def ListClass(implicit ctx: Context) = ListType.symbol.asClass
   lazy val NilModuleRef = ctx.requiredModuleRef("scala.collection.immutable.Nil")
   def NilModule(implicit ctx: Context) = NilModuleRef.symbol
 
+  lazy val immutableMapType = ctx.requiredClassRef("scala.collection.immutable.Map")
+  def immutableMapClass(implicit ctx: Context) = immutableMapType.symbol.asClass
+  lazy val immutableSetType = ctx.requiredClassRef("scala.collection.immutable.Set")
+  def immutableSetClass(implicit ctx: Context) = immutableSetType.symbol.asClass
+
   lazy val SingletonClass: ClassSymbol =
     // needed as a synthetic class because Scala 2.x refers to it in classfiles
     // but does not define it as an explicit class.

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

@@ -136,6 +136,11 @@ class PlainPrinter(_ctx: Context) extends Printer {
       case _ => Nil
     })
 
+  // Direct references to these symbols are printed without their prefix for convenience,
+  // they are either aliased in scala.Predef or in the scala package object.
+  private[this] lazy val printWithoutPrefix: Set[Symbol] =
+    Set(defn.ListClass, defn.immutableMapClass, defn.immutableSetClass, defn.SeqClass)
+
   def toText(tp: Type): Text = controlled {
     homogenize(tp) match {
       case tp: TypeType =>
@@ -147,7 +152,12 @@ class PlainPrinter(_ctx: Context) extends Printer {
       case tp: TermRef if tp.denot.isOverloaded =>
         "<overloaded " ~ toTextRef(tp) ~ ">"
       case tp: TypeRef =>
-        toTextPrefix(tp.prefix) ~ selectionString(tp)
+        printWithoutPrefix.find(sym => tp.isDirectRef(sym)) match {
+          case Some(sym) =>
+            toText(sym.name)
+          case _ =>
+            toTextPrefix(tp.prefix) ~ selectionString(tp)
+        }
       case tp: TermParamRef =>
         ParamRefNameString(tp) ~ ".type"
       case tp: TypeParamRef =>

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

@@ -11,22 +11,6 @@ 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)
 
@@ -55,22 +39,6 @@ class UserFacingPrinter(_ctx: Context) extends RefinedPrinter(_ctx) {
   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/test-resources/repl/importFromObj

@@ -7,7 +7,7 @@ scala> import o._
 scala> buf += xs
 1 | buf += xs
   |        ^^
-  |        found:    scala.collection.immutable.List[Int](o.xs)
+  |        found:    List[Int](o.xs)
   |        required: Int
   |
 scala> buf ++= xs

compiler/test-resources/type-printer/hkAlias

@@ -0,0 +1,6 @@
+scala> type Identity[T] = T
+// defined alias type Identity = [T] => T
+scala> def foo[T](x: T): Identity[T] = x
+def foo[T](x: T): Identity[T]
+scala> foo(1)
+val res0: Identity[Int] = 1

compiler/test-resources/type-printer/prefixless

@@ -0,0 +1,8 @@
+scala> List(1,2,3)
+val res0: List[Int] = List(1, 2, 3)
+scala> Map("foo" -> 1)
+val res1: Map[String, Int] = Map("foo" -> 1)
+scala> Seq('a','b')
+val res2: Seq[Char] = List(a, b)
+scala> Set(4, 5)
+val res3: Set[Int] = Set(4, 5)

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

@@ -493,7 +493,7 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       val DoesNotConformToBound(tpe, which, bound) :: Nil = messages
       assertEquals("Int", tpe.show)
       assertEquals("upper", which)
-      assertEquals("scala.collection.immutable.List[Int]", bound.show)
+      assertEquals("List[Int]", bound.show)
     }
 
   @Test def doesNotConformToSelfType =