Don't disambiguate between terms and types

An ExplainingTypePrinter would disambiguate between a class
and its companion object, like this:

   {message involving C and C'}

   where    C   is a class ...
            C'  is an object

I believe this is not necessessary, as types and terms should be
distinguishable from the context in which they appear.

Author: odersky

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

@@ -106,22 +106,32 @@ object Formatting {
 
   private type Recorded = AnyRef /*Symbol | ParamRef | SkolemType */
 
-  private class Seen extends mutable.HashMap[String, List[Recorded]] {
+  private case class SeenKey(str: String, isType: Boolean)
+  private class Seen extends mutable.HashMap[SeenKey, List[Recorded]] {
 
-    override def default(key: String) = Nil
+    override def default(key: SeenKey) = Nil
 
-    def record(str: String, entry: Recorded)(implicit ctx: Context): String = {
+    def record(str: String, isType: Boolean, entry: Recorded)(implicit ctx: Context): String = {
+
+      /** If `e1` is an alias of another class of the same name, return the other
+       *  class symbol instead. This normalization avoids recording e.g. scala.List
+       *  and scala.collection.immutable.List as two different types
+       */
       def followAlias(e1: Recorded): Recorded = e1 match {
         case e1: Symbol if e1.isAliasType =>
           val underlying = e1.typeRef.underlyingClassRef(refinementOK = false).typeSymbol
           if (underlying.name == e1.name) underlying else e1
         case _ => e1
       }
+      val key = SeenKey(str, isType)
+      val existing = apply(key)
       lazy val dealiased = followAlias(entry)
-      var alts = apply(str).dropWhile(alt => dealiased ne followAlias(alt))
+
+      // alts: The alternatives in `existing` that are equal, or follow (an alias of) `entry`
+      var alts = existing.dropWhile(alt => dealiased ne followAlias(alt))
       if (alts.isEmpty) {
-        alts = entry :: apply(str)
-        update(str, alts)
+        alts = entry :: existing
+        update(key, alts)
       }
       str + "'" * (alts.length - 1)
     }
@@ -135,13 +145,13 @@ object Formatting {
 
     override def simpleNameString(sym: Symbol): String =
       if (useSourceModule(sym)) simpleNameString(sym.sourceModule)
-      else seen.record(super.simpleNameString(sym), sym)
+      else seen.record(super.simpleNameString(sym), sym.isType, sym)
 
     override def ParamRefNameString(param: ParamRef): String =
-      seen.record(super.ParamRefNameString(param), param)
+      seen.record(super.ParamRefNameString(param), param.isInstanceOf[TypeParamRef], param)
 
     override def toTextRef(tp: SingletonType): Text = tp match {
-      case tp: SkolemType => seen.record(tp.repr.toString, tp)
+      case tp: SkolemType => seen.record(tp.repr.toString, isType = true, tp)
       case _ => super.toTextRef(tp)
     }
 
@@ -207,10 +217,13 @@ object Formatting {
     }
 
     val toExplain: List[(String, Recorded)] = seen.toList.flatMap {
-      case (str, entry :: Nil) =>
-        if (needsExplanation(entry)) (str, entry) :: Nil else Nil
-      case (str, entries) =>
-        entries.map(alt => (seen.record(str, alt), alt))
+      case (key, entry :: Nil) =>
+        if (needsExplanation(entry)) (key.str, entry) :: Nil else Nil
+      case (key, entries) =>
+        for (alt <- entries) yield {
+          val tickedString = seen.record(key.str, key.isType, alt)
+          (tickedString, alt)
+        }
     }.sortBy(_._1)
 
     def columnar(parts: List[(String, String)]): List[String] = {

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

@@ -298,7 +298,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
     }
   }
 
-  /** The string representation of this type used as a prefix */
+  /** The string representation of this type used as a prefix, including separator */
   protected def toTextPrefix(tp: Type): Text = controlled {
     homogenize(tp) match {
       case NoPrefix => ""