Drop uniqueRefinedType and uniqueTypeAlias

With the change to native applied types, both are now quite rare,
so no need for special casing their allocation.

Author: odersky

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

@@ -603,24 +603,16 @@ object Contexts {
       override def hash(x: Type): Int = x.hash
     }
 
-    /** 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 */
+    /** A table for hash consing unique applied 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 // @!!! replace
-
     private def uniqueSets = Map(
         "uniques" -> uniques,
-        "uniqueRefinedTypes" -> uniqueRefinedTypes,
         "uniqueAppliedTypes" -> uniqueAppliedTypes,
-        "uniqueNamedTypes" -> uniqueNamedTypes,
-        "uniqueTypeAliases" -> uniqueTypeAliases)
+        "uniqueNamedTypes" -> uniqueNamedTypes)
 
     /** A map that associates label and size of all uniques sets */
     def uniquesSizes: Map[String, Int] = uniqueSets.mapValues(_.size)

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

@@ -2293,23 +2293,11 @@ object Types {
       if (parent.member(refinedName).exists) derivedRefinedType(parent, refinedName, refinedInfo)
       else parent
 
-    override def equals(that: Any) = that match {
-      case that: RefinedType =>
-        this.parent == that.parent &&
-        this.refinedName == that.refinedName &&
-        this.refinedInfo == that.refinedInfo
-      case _ =>
-        false
-    }
     override def computeHash = doHash(refinedName, refinedInfo, parent)
-    override def toString = s"RefinedType($parent, $refinedName, $refinedInfo)"
   }
 
-  class CachedRefinedType(parent: Type, refinedName: Name, refinedInfo: Type, hc: Int)
-  extends RefinedType(parent, refinedName, refinedInfo) {
-    myHash = hc
-    override def computeHash = unsupported("computeHash")
-  }
+  class CachedRefinedType(parent: Type, refinedName: Name, refinedInfo: Type)
+  extends RefinedType(parent, refinedName, refinedInfo)
 
   object RefinedType {
     @tailrec def make(parent: Type, names: List[Name], infos: List[Type])(implicit ctx: Context): Type =
@@ -2318,7 +2306,7 @@ object Types {
 
     def apply(parent: Type, name: Name, info: Type)(implicit ctx: Context): RefinedType = {
       assert(!ctx.erasedTypes)
-      ctx.base.uniqueRefinedTypes.enterIfNew(parent, name, info).checkInst
+      unique(new CachedRefinedType(parent, name, info)).checkInst
     }
   }
 
@@ -3662,12 +3650,12 @@ object Types {
       if (variance == 0) this
       else if (variance < 0) TypeBounds.lower(alias)
       else TypeBounds.upper(alias)
-  }
 
-  class CachedTypeAlias(alias: Type, variance: Int, hc: Int) extends TypeAlias(alias, variance) {
-    myHash = hc
+    override def computeHash = doHash(variance, alias)
   }
 
+  class CachedTypeAlias(alias: Type, variance: Int) extends TypeAlias(alias, variance)
+
   object TypeBounds {
     def apply(lo: Type, hi: Type)(implicit ctx: Context): TypeBounds =
       unique(new RealTypeBounds(lo, hi))
@@ -3678,7 +3666,7 @@ object Types {
 
   object TypeAlias {
     def apply(alias: Type, variance: Int = 0)(implicit ctx: Context) =
-      ctx.uniqueTypeAliases.enterIfNew(alias, variance)
+      unique(new CachedTypeAlias(alias, variance))
     def unapply(tp: TypeAlias): Option[Type] = Some(tp.alias)
   }
 

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

@@ -66,32 +66,6 @@ object Uniques {
     }
   }
 
-  final class TypeAliasUniques extends HashSet[TypeAlias](Config.initialUniquesCapacity) with Hashable {
-    override def hash(x: TypeAlias): Int = x.hash
-
-    private def findPrevious(h: Int, alias: Type, variance: Int): TypeAlias = {
-      var e = findEntryByHash(h)
-      while (e != null) {
-        if ((e.alias eq alias) && (e.variance == variance)) return e
-        e = nextEntryByHash(h)
-      }
-      e
-    }
-
-    def enterIfNew(alias: Type, variance: Int): TypeAlias = {
-      val h = doHash(variance, alias)
-      if (monitored) recordCaching(h, classOf[TypeAlias])
-      def newAlias = new CachedTypeAlias(alias, variance, h)
-      if (h == NotCached) newAlias
-      else {
-        val r = findPrevious(h, alias, variance)
-        if (r ne null) r
-        else addEntryAfterScan(newAlias)
-      }
-    }
-  }
-
-
   final class AppliedUniques extends HashSet[AppliedType](Config.initialUniquesCapacity) with Hashable {
     override def hash(x: AppliedType): Int = x.hash
 
@@ -121,39 +95,4 @@ object Uniques {
       }
     }
   }
-
-  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
-
-    private def findPrevious(h: Int, parent: Type, refinedName: Name, refinedInfo: Type): RefinedType = {
-      var e = findEntryByHash(h)
-      while (e != null) {
-        if ((e.parent eq parent) && (e.refinedName eq refinedName) && (e.refinedInfo eq refinedInfo))
-          return e
-        e = nextEntryByHash(h)
-      }
-      e
-    }
-
-    def enterIfNew(parent: Type, refinedName: Name, refinedInfo: Type): RefinedType = {
-      val h = doHash(refinedName, refinedInfo, parent)
-      def newType = new CachedRefinedType(parent, refinedName, refinedInfo, h)
-      if (monitored) recordCaching(h, classOf[CachedRefinedType])
-      if (h == NotCached) newType
-      else {
-        val r = findPrevious(h, parent, refinedName, refinedInfo)
-        if (r ne null) r else addEntryAfterScan(newType)
-      }
-    }
-
-    def enterIfNew(rt: RefinedType) = {
-      if (monitored) recordCaching(rt)
-      if (rt.hash == NotCached) rt
-      else {
-        val r = findPrevious(rt.hash, rt.parent, rt.refinedName, rt.refinedInfo)
-        if (r ne null) r else addEntryAfterScan(rt)
-      }
-    }
-  }
 }