Drop TypeHashSet

Use a normal util.HashSet instead

Author: odersky

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

@@ -5532,15 +5532,11 @@ object Types {
     def apply(x: Unit, tp: Type): Unit = foldOver(p(tp), tp)
   }
 
-  class TypeHashSet extends util.HashSet[Type](64):
-    override def hash(x: Type): Int = System.identityHashCode(x)
-    override def isEqual(x: Type, y: Type) = x.eq(y)
-
   class NamedPartsAccumulator(p: NamedType => Boolean, excludeLowerBounds: Boolean = false)
     (using Context) extends TypeAccumulator[mutable.Set[NamedType]] {
     override def stopAtStatic: Boolean = false
     def maybeAdd(x: mutable.Set[NamedType], tp: NamedType): mutable.Set[NamedType] = if (p(tp)) x += tp else x
-    val seen = TypeHashSet()
+    val seen = util.HashSet[Type]()
     def apply(x: mutable.Set[NamedType], tp: Type): mutable.Set[NamedType] =
       if (seen contains tp) x
       else {

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -28,7 +28,7 @@ import Trees._
 import transform.SymUtils._
 import transform.TypeUtils._
 import Hashable._
-import util.{SourceFile, NoSource}
+import util.{SourceFile, NoSource, IdentityHashMap}
 import config.{Config, Feature}
 import Feature.migrateTo3
 import config.Printers.{implicits, implicitsDetailed}
@@ -289,7 +289,7 @@ object Implicits:
    *  @param outerCtx  the next outer context that makes visible further implicits
    */
   class ContextualImplicits(val refs: List[ImplicitRef], val outerImplicits: ContextualImplicits)(initctx: Context) extends ImplicitRefs(initctx) {
-    private val eligibleCache = new java.util.IdentityHashMap[Type, List[Candidate]]
+    private val eligibleCache = IdentityHashMap[Type, List[Candidate]]()
 
     /** The level increases if current context has a different owner or scope than
      *  the context of the next-outer ImplicitRefs. This is however disabled under
@@ -316,7 +316,7 @@ object Implicits:
     def eligible(tp: Type): List[Candidate] =
       if (tp.hash == NotCached) computeEligible(tp)
       else {
-        val eligibles = eligibleCache.get(tp)
+        val eligibles = eligibleCache.lookup(tp)
         if (eligibles != null) {
           def elided(ci: ContextualImplicits): Int = {
             val n = ci.refs.length
@@ -329,7 +329,7 @@ object Implicits:
         else if (irefCtx eq NoContext) Nil
         else {
           val result = computeEligible(tp)
-          eligibleCache.put(tp, result)
+          eligibleCache(tp) = result
           result
         }
       }
@@ -528,7 +528,7 @@ trait ImplicitRunInfo:
 
       private var provisional: Boolean = _
       private var parts: mutable.LinkedHashSet[Type] = _
-      private val partSeen = TypeHashSet()
+      private val partSeen = util.HashSet[Type]()
 
       def traverse(t: Type) =
         if partSeen.contains(t) then ()
@@ -566,8 +566,8 @@ trait ImplicitRunInfo:
         (parts, provisional)
     end collectParts
 
-    val seen = TypeHashSet()
-    val incomplete = TypeHashSet()
+    val seen = util.HashSet[Type]()
+    val incomplete = util.HashSet[Type]()
 
     def collectCompanions(tp: Type, parts: collection.Set[Type]): TermRefSet =
       val companions = new TermRefSet
@@ -687,7 +687,7 @@ trait ImplicitRunInfo:
         record(i"implicitScope")
         val liftToAnchors = new TypeMap:
           override def stopAtStatic = true
-          private val seen = TypeHashSet()
+          private val seen = util.HashSet[Type]()
 
           def applyToUnderlying(t: TypeProxy) =
             if seen.contains(t) then