Convert more sets to util.HashSet

Author: odersky

compiler/src/dotty/tools/dotc/classpath/AggregateClassPath.scala

@@ -7,6 +7,7 @@ package dotc.classpath
 import java.net.URL
 import scala.collection.mutable.ArrayBuffer
 import scala.collection.immutable.ArraySeq
+import dotc.util
 
 import dotty.tools.io.{ AbstractFile, ClassPath, ClassRepresentation, EfficientClassPath }
 
@@ -132,7 +133,7 @@ case class AggregateClassPath(aggregates: Seq[ClassPath]) extends ClassPath {
   }
 
   private def getDistinctEntries[EntryType <: ClassRepresentation](getEntries: ClassPath => Seq[EntryType]): Seq[EntryType] = {
-    val seenNames = collection.mutable.HashSet[String]()
+    val seenNames = util.HashSet[String]()
     val entriesBuffer = new ArrayBuffer[EntryType](1024)
     for {
       cp <- aggregates

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

@@ -14,7 +14,7 @@ import Uniques._
 import ast.Trees._
 import ast.untpd
 import Flags.GivenOrImplicit
-import util.{NoSource, SimpleIdentityMap, SourceFile}
+import util.{NoSource, SimpleIdentityMap, SourceFile, HashSet}
 import typer.{Implicits, ImportInfo, Inliner, SearchHistory, SearchRoot, TypeAssigner, Typer, Nullables}
 import Nullables.{NotNullInfo, given _}
 import Implicits.ContextualImplicits
@@ -534,7 +534,7 @@ object Contexts {
     def settings: ScalaSettings            = base.settings
     def definitions: Definitions           = base.definitions
     def platform: Platform                 = base.platform
-    def pendingUnderlying: mutable.HashSet[Type]   = base.pendingUnderlying
+    def pendingUnderlying: util.HashSet[Type]      = base.pendingUnderlying
     def uniqueNamedTypes: Uniques.NamedTypeUniques = base.uniqueNamedTypes
     def uniques: util.HashSet[Type]                = base.uniques
 
@@ -869,7 +869,7 @@ object Contexts {
 
     /** The set of named types on which a currently active invocation
      *  of underlying during a controlled operation exists. */
-    private[core] val pendingUnderlying: mutable.HashSet[Type] = new mutable.HashSet[Type]
+    private[core] val pendingUnderlying: util.HashSet[Type] = util.HashSet[Type]()
 
     /** A map from ErrorType to associated message. We use this map
      *  instead of storing messages directly in ErrorTypes in order

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

@@ -49,7 +49,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
     needsGc = false
     if Config.checkTypeComparerReset then checkReset()
 
-  private var pendingSubTypes: mutable.Set[(Type, Type)] = null
+  private var pendingSubTypes: util.MutableSet[(Type, Type)] = null
   private var recCount = 0
   private var monitored = false
 
@@ -202,7 +202,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
 
     def monitoredIsSubType = {
       if (pendingSubTypes == null) {
-        pendingSubTypes = new mutable.HashSet[(Type, Type)]
+        pendingSubTypes = util.HashSet[(Type, Type)]()
         report.log(s"!!! deep subtype recursion involving ${tp1.show} <:< ${tp2.show}, constraint = ${state.constraint.show}")
         report.log(s"!!! constraint = ${constraint.show}")
         //if (ctx.settings.YnoDeepSubtypes.value) {
@@ -231,7 +231,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         }
       }
       val p = (normalize(tp1), normalize(tp2))
-      !pendingSubTypes(p) && {
+      !pendingSubTypes.contains(p) && {
         try {
           pendingSubTypes += p
           firstTry

compiler/src/dotty/tools/dotc/plugins/Plugin.scala

@@ -162,12 +162,12 @@ object Plugin {
       case Failure(e)  => Failure(e)
     })
 
-    val seen = mutable.HashSet[String]()
+    val seen = util.HashSet[String]()
     val enabled = (fromPaths ::: fromDirs) map(_.flatMap {
       case (classname, loader) =>
         Plugin.load(classname, loader).flatMap {  clazz =>
           val plugin = instantiate(clazz)
-          if (seen(classname))   // a nod to scala/bug#7494, take the plugin classes distinctly
+          if (seen.contains(classname))   // a nod to scala/bug#7494, take the plugin classes distinctly
             Failure(new PluginLoadException(plugin.name, s"Ignoring duplicate plugin ${plugin.name} (${classname})"))
           else if (ignoring contains plugin.name)
             Failure(new PluginLoadException(plugin.name, s"Disabling plugin ${plugin.name}"))

compiler/src/dotty/tools/dotc/transform/CapturedVars.scala

@@ -26,11 +26,11 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
   override def runsAfterGroupsOf: Set[String] = Set(LiftTry.name)
     // lifting tries changes what variables are considered to be captured
 
-  private[this] var Captured: Store.Location[collection.Set[Symbol]] = _
+  private[this] var Captured: Store.Location[util.ReadOnlySet[Symbol]] = _
   private def captured(using Context) = ctx.store(Captured)
 
   override def initContext(ctx: FreshContext): Unit =
-    Captured = ctx.addLocation(Set.empty)
+    Captured = ctx.addLocation(util.ReadOnlySet.empty[Symbol])
 
   private class RefInfo(using Context) {
     /** The classes for which a Ref type exists. */
@@ -54,7 +54,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
   }
 
   private class CollectCaptured extends TreeTraverser {
-    private val captured = mutable.HashSet[Symbol]()
+    private val captured = util.HashSet[Symbol]()
     def traverse(tree: Tree)(using Context) = tree match {
       case id: Ident =>
         val sym = id.symbol
@@ -68,7 +68,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
       case _ =>
         traverseChildren(tree)
     }
-    def runOver(tree: Tree)(using Context): collection.Set[Symbol] = {
+    def runOver(tree: Tree)(using Context): util.ReadOnlySet[Symbol] = {
       traverse(tree)
       captured
     }

compiler/src/dotty/tools/dotc/util/MutableSet.scala

@@ -2,10 +2,7 @@ package dotty.tools.dotc.util
 
 /** A common class for lightweight mutable sets.
  */
-abstract class MutableSet[T] {
-
-  /** The entry in the set such that `isEqual(x, entry)`, or else `null`. */
-  def lookup(x: T): T | Null
+abstract class MutableSet[T] extends ReadOnlySet[T]:
 
   /** Add element `x` to the set */
   def +=(x: T): Unit
@@ -15,16 +12,8 @@ abstract class MutableSet[T] {
    */
   def put(x: T): T
 
-  def clear(): Unit
-
-  def size: Int
-
-  def iterator: Iterator[T]
+  /** Remove element `x` from the set */
+  def -=(x: T): Unit
 
-  def contains(x: T): Boolean = lookup(x) != null
-
-  def foreach[U](f: T => U): Unit = iterator foreach f
-
-  def toList: List[T] = iterator.toList
+  def clear(): Unit
 
-}

compiler/src/dotty/tools/dotc/util/ReadOnlySet.scala

@@ -0,0 +1,24 @@
+package dotty.tools.dotc.util
+
+/** A class for the readonly part of mutable sets.
+ */
+abstract class ReadOnlySet[T]:
+
+  /** The entry in the set such that `isEqual(x, entry)`, or else `null`. */
+  def lookup(x: T): T | Null
+
+  def size: Int
+
+  def iterator: Iterator[T]
+
+  def contains(x: T): Boolean = lookup(x) != null
+
+  def foreach[U](f: T => U): Unit = iterator.foreach(f)
+
+  def toList: List[T] = iterator.toList
+
+  def isEmpty = size == 0
+
+object ReadOnlySet:
+  def empty[T]: ReadOnlySet[T] = HashSet[T](4)
+