Specialize hash-consing of WithFixedSym types

Author: odersky

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

@@ -609,9 +609,13 @@ object Contexts {
     /** A table for hash consing unique named types */
     private[core] val uniqueNamedTypes = new NamedTypeUniques
 
+    /** A table for hash consing unique symbolic named types */
+    private[core] val uniqueWithFixedSyms = new WithFixedSymUniques
+
     private def uniqueSets = Map(
         "uniques" -> uniques,
         "uniqueAppliedTypes" -> uniqueAppliedTypes,
+        "uniqueWithFixedSyms" -> uniqueWithFixedSyms,
         "uniqueNamedTypes" -> uniqueNamedTypes)
 
     /** A map that associates label and size of all uniques sets */

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

@@ -2020,7 +2020,7 @@ object Types {
       case that: WithFixedSym => this.prefix == that.prefix && (this.fixedSym eq that.fixedSym)
       case _ => false
     }
-    override def computeHash = doHash(fixedSym, prefix)
+    override def computeHash = unsupported("computeHash")
   }
 
   final class CachedTermRef(prefix: Type, name: TermName, hc: Int) extends TermRef(prefix, name) {
@@ -2036,8 +2036,12 @@ object Types {
   }
 
   // Those classes are non final as Linker extends them.
-  class TermRefWithFixedSym(prefix: Type, name: TermName, val fixedSym: TermSymbol) extends TermRef(prefix, name) with WithFixedSym
-  class TypeRefWithFixedSym(prefix: Type, name: TypeName, val fixedSym: TypeSymbol) extends TypeRef(prefix, name) with WithFixedSym
+  class TermRefWithFixedSym(prefix: Type, name: TermName, val fixedSym: TermSymbol, hc: Int) extends TermRef(prefix, name) with WithFixedSym {
+    myHash = hc
+  }
+  class TypeRefWithFixedSym(prefix: Type, name: TypeName, val fixedSym: TypeSymbol, hc: Int) extends TypeRef(prefix, name) with WithFixedSym {
+    myHash = hc
+  }
 
   /** Assert current phase does not have erasure semantics */
   private def assertUnerased()(implicit ctx: Context) =
@@ -2094,7 +2098,7 @@ object Types {
      *  with given prefix, name, and signature
      */
     def withFixedSym(prefix: Type, name: TermName, sym: TermSymbol)(implicit ctx: Context): TermRef =
-      unique(new TermRefWithFixedSym(prefix, name, sym))
+      ctx.uniqueWithFixedSyms.enterIfNew(prefix, name, sym).asInstanceOf[TermRef]
 
     /** Create a term ref referring to given symbol with given name, taking the signature
      *  from the symbol if it is completed, or creating a term ref without
@@ -2148,7 +2152,7 @@ object Types {
      *  with given prefix, name, and symbol.
      */
     def withFixedSym(prefix: Type, name: TypeName, sym: TypeSymbol)(implicit ctx: Context): TypeRef =
-      unique(new TypeRefWithFixedSym(prefix, name, sym))
+      ctx.uniqueWithFixedSyms.enterIfNew(prefix, name, sym).asInstanceOf[TypeRef]
 
     /** Create a type ref referring to given symbol with given name.
      *  This is very similar to TypeRef(Type, Symbol),

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

@@ -1,7 +1,7 @@
 package dotty.tools.dotc
 package core
 
-import Types._, Contexts._, util.Stats._, Hashable._, Names._
+import Types._, Symbols._, Contexts._, util.Stats._, Hashable._, Names._
 import config.Config
 import util.HashSet
 
@@ -54,7 +54,7 @@ object Uniques {
 
     def enterIfNew(prefix: Type, name: Name): NamedType = {
       val h = doHash(name, prefix)
-      if (monitored) recordCaching(h, classOf[CachedTermRef])
+      if (monitored) recordCaching(h, classOf[NamedType])
       def newType =
         if (name.isTypeName) new CachedTypeRef(prefix, name.asTypeName, h)
         else new CachedTermRef(prefix, name.asTermName, h)
@@ -66,6 +66,32 @@ object Uniques {
     }
   }
 
+  final class WithFixedSymUniques extends HashSet[WithFixedSym](Config.initialUniquesCapacity) with Hashable {
+    override def hash(x: WithFixedSym): Int = x.hash
+
+    private def findPrevious(h: Int, prefix: Type, sym: Symbol): NamedType = {
+      var e = findEntryByHash(h)
+      while (e != null) {
+        if ((e.prefix eq prefix) && (e.fixedSym eq sym)) return e
+        e = nextEntryByHash(h)
+      }
+      e
+    }
+
+    def enterIfNew(prefix: Type, name: Name, sym: Symbol): NamedType = {
+      val h = doHash(sym, prefix)
+      if (monitored) recordCaching(h, classOf[WithFixedSym])
+      def newType =
+        if (name.isTypeName) new TypeRefWithFixedSym(prefix, name.asTypeName, sym.asInstanceOf[TypeSymbol], h)
+        else new TermRefWithFixedSym(prefix, name.asTermName, sym.asInstanceOf[TermSymbol], h)
+      if (h == NotCached) newType
+      else {
+        val r = findPrevious(h, prefix, sym)
+        if (r ne null) r else addEntryAfterScan(newType)
+      }
+    }
+  }
+
   final class AppliedUniques extends HashSet[AppliedType](Config.initialUniquesCapacity) with Hashable {
     override def hash(x: AppliedType): Int = x.hash