Hash-cons applied types in their own table

Author: odersky

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

@@ -608,15 +608,19 @@ object Contexts {
     /** A table for hash consing unique refined types */
     private[dotc] val uniqueRefinedTypes = new RefinedUniques // @!!! replace with uniqueAppliedTypes
 
+    /** A table for hash consing unique refined types */
+    private[dotc] val uniqueAppliedTypes = new AppliedUniques
+
     /** A table for hash consing unique named types */
     private[core] val uniqueNamedTypes = new NamedTypeUniques
 
     /** A table for hash consing unique type bounds */
-    private[core] val uniqueTypeAliases = new TypeAliasUniques
+    private[core] val uniqueTypeAliases = new TypeAliasUniques // @!!! replace
 
     private def uniqueSets = Map(
         "uniques" -> uniques,
         "uniqueRefinedTypes" -> uniqueRefinedTypes,
+        "uniqueAppliedTypes" -> uniqueAppliedTypes,
         "uniqueNamedTypes" -> uniqueNamedTypes,
         "uniqueTypeAliases" -> uniqueTypeAliases)
 

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

@@ -3177,30 +3177,18 @@ object Types {
     def derivedAppliedType(tycon: Type, args: List[Type])(implicit ctx: Context): Type =
       if ((tycon eq this.tycon) && (args eq this.args)) this
       else tycon.appliedTo(args)
-
-    override def computeHash = doHash(tycon, args)
-
-    protected def checkInst(implicit ctx: Context): this.type = {
-      def check(tycon: Type): Unit = tycon.stripTypeVar match {
-        case tycon: TypeRef =>
-        case _: TypeParamRef | _: ErrorType | _: WildcardType =>
-        case _: TypeLambda =>
-          assert(!args.exists(_.isInstanceOf[TypeBounds]), s"unreduced type apply: $this")
-        case tycon: AnnotatedType =>
-          check(tycon.underlying)
-        case _ =>
-          assert(false, s"illegal type constructor in $this")
-      }
-      if (Config.checkHKApplications) check(tycon)
-      this
-    }
   }
 
-  final class CachedAppliedType(tycon: Type, args: List[Type]) extends AppliedType(tycon, args)
+  final class CachedAppliedType(tycon: Type, args: List[Type], hc: Int) extends AppliedType(tycon, args) {
+    myHash = hc
+    override def computeHash = unsupported("computeHash")
+  }
 
   object AppliedType {
-    def apply(tycon: Type, args: List[Type])(implicit ctx: Context) =
-      unique(new CachedAppliedType(tycon, args)).checkInst
+    def apply(tycon: Type, args: List[Type])(implicit ctx: Context) = {
+      assertUnerased()
+      ctx.base.uniqueAppliedTypes.enterIfNew(tycon, args)
+    }
   }
 
   object ClassRef {

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

@@ -91,6 +91,37 @@ object Uniques {
     }
   }
 
+
+  final class AppliedUniques extends HashSet[AppliedType](Config.initialUniquesCapacity) with Hashable {
+    override def hash(x: AppliedType): Int = x.hash
+
+    private def findPrevious(h: Int, tycon: Type, args: List[Type]): AppliedType = {
+      var e = findEntryByHash(h)
+      while (e != null) {
+        def sameArgs(args1: List[Type], args2: List[Type]): Boolean = {
+          val empty1 = args1.isEmpty
+          val empty2 = args2.isEmpty
+          if (empty1) empty2
+          else (!empty2 && (args1.head eq args2.head) && sameArgs(args1.tail, args2.tail))
+        }
+        if ((e.tycon eq tycon) && sameArgs(e.args, args)) return e
+        e = nextEntryByHash(h)
+      }
+      e
+    }
+
+    def enterIfNew(tycon: Type, args: List[Type]): AppliedType = {
+      val h = doHash(tycon, args)
+      def newType = new CachedAppliedType(tycon, args, h)
+      if (monitored) recordCaching(h, classOf[CachedAppliedType])
+      if (h == NotCached) newType
+      else {
+        val r = findPrevious(h, tycon, args)
+        if (r ne null) r else addEntryAfterScan(newType)
+      }
+    }
+  }
+
   final class RefinedUniques extends HashSet[RefinedType](Config.initialUniquesCapacity) with Hashable {
     override val hashSeed = classOf[CachedRefinedType].hashCode // some types start life as CachedRefinedTypes, need to have same hash seed
     override def hash(x: RefinedType): Int = x.hash