Cache NamedTypes with thisType prefix in Symbols

... rather than the global ctx.uniqueNamedRefs hashtable. This reduces the size of
the hashtable by a bit more than half

Author: odersky

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

@@ -1173,11 +1173,27 @@ object SymDenotations {
     /** The type This(cls), where cls is this class, NoPrefix for all other symbols */
     def thisType(implicit ctx: Context): Type = NoPrefix
 
+    private[this] var cachedRef: NamedType = null
+
+    def namedRef(implicit ctx: Context): NamedType = {
+      if (cachedRef == null) {
+        val initl = initial
+        val thistpe = maybeOwner.thisType
+        if ((initl `ne` this) && (thistpe `eq` initl.maybeOwner.thisType))
+          cachedRef = initial.namedRef
+        else {
+          Stats.record("namedRef create")
+          cachedRef = ctx.uniqueNamedTypes.newType(thistpe, symbol, isTerm)
+        }
+      }
+      cachedRef
+    }
+
     override def typeRef(implicit ctx: Context): TypeRef =
-      TypeRef(owner.thisType, symbol)
+      namedRef.asInstanceOf[TypeRef]
 
     override def termRef(implicit ctx: Context): TermRef =
-      TermRef(owner.thisType, symbol)
+      namedRef.asInstanceOf[TermRef]
 
     /** The variance of this type parameter or type member as an Int, with
      *  +1 = Covariant, -1 = Contravariant, 0 = Nonvariant, or not a type parameter

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

@@ -53,16 +53,33 @@ object Uniques {
       e
     }
 
+    def newType(prefix: Type, designator: Designator, hc: Int, isTerm: Boolean): NamedType =
+      if (isTerm) new CachedTermRef(prefix, designator, hc)
+      else new CachedTypeRef(prefix, designator, hc)
+
+    def newType(prefix: Type, designator: Designator, isTerm: Boolean)(implicit ctx: Context): NamedType =
+      newType(prefix, designator, doHash(null, designator, prefix), isTerm)
+
     def enterIfNew(prefix: Type, designator: Designator, isTerm: Boolean)(implicit ctx: Context): NamedType = {
       val h = doHash(null, designator, prefix)
       if (monitored) recordCaching(h, classOf[NamedType])
-      def newType =
-        if (isTerm) new CachedTermRef(prefix, designator, h)
-        else new CachedTypeRef(prefix, designator, h)
-      if (h == NotCached) newType
+      designator match {
+        case sym: Symbol =>
+          val symd = sym.lastKnownDenotation
+          if (symd != null) {
+            val ref = symd.namedRef
+            if (prefix `eq` ref.prefix) {
+              record("namedRef reuse")
+              return ref
+            }
+          }
+        case _ =>
+      }
+      if (h == NotCached) newType(prefix, designator, h, isTerm)
       else {
         val r = findPrevious(h, prefix, designator)
-        if ((r ne null) && (r.isTerm == isTerm)) r else addEntryAfterScan(newType)
+        if ((r ne null) && (r.isTerm == isTerm)) r
+        else addEntryAfterScan(newType(prefix, designator, h, isTerm))
       }
     }
   }