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
 
@@ -838,8 +838,8 @@ object Contexts {
     def nextSymId: Int = { _nextSymId += 1; _nextSymId }
 
     /** Sources that were loaded */
-    val sources: mutable.HashMap[AbstractFile, SourceFile] = new mutable.HashMap[AbstractFile, SourceFile]
-    val sourceNamed: mutable.HashMap[TermName, SourceFile] = new mutable.HashMap[TermName, SourceFile]
+    val sources: util.HashMap[AbstractFile, SourceFile] = util.HashMap[AbstractFile, SourceFile]()
+    val sourceNamed: util.HashMap[TermName, SourceFile] = util.HashMap[TermName, SourceFile]()
 
     // Types state
     /** A table for hash consing unique types */
@@ -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/NameKinds.scala

@@ -7,7 +7,6 @@ import NameOps._
 import StdNames._
 import NameTags._
 import Contexts._
-import collection.mutable
 
 import scala.annotation.internal.sharable
 
@@ -17,10 +16,10 @@ object NameKinds {
   // These are sharable since all NameKinds are created eagerly at the start of the program
   // before any concurrent threads are forked. for this to work, NameKinds should never
   // be created lazily or in modules that start running after compilers are forked.
-  @sharable private val simpleNameKinds = new mutable.HashMap[Int, ClassifiedNameKind]
-  @sharable private val qualifiedNameKinds = new mutable.HashMap[Int, QualifiedNameKind]
-  @sharable private val numberedNameKinds = new mutable.HashMap[Int, NumberedNameKind]
-  @sharable private val uniqueNameKinds = new mutable.HashMap[String, UniqueNameKind]
+  @sharable private val simpleNameKinds = util.HashMap[Int, ClassifiedNameKind]()
+  @sharable private val qualifiedNameKinds = util.HashMap[Int, QualifiedNameKind]()
+  @sharable private val numberedNameKinds = util.HashMap[Int, NumberedNameKind]()
+  @sharable private val uniqueNameKinds = util.HashMap[String, UniqueNameKind]()
 
   /** A class for the info stored in a derived name */
   abstract class NameInfo {
@@ -390,8 +389,8 @@ object NameKinds {
   val Scala2MethodNameKinds: List[NameKind] =
     List(DefaultGetterName, ExtMethName, UniqueExtMethName)
 
-  def simpleNameKindOfTag      : collection.Map[Int, ClassifiedNameKind] = simpleNameKinds
-  def qualifiedNameKindOfTag   : collection.Map[Int, QualifiedNameKind]  = qualifiedNameKinds
-  def numberedNameKindOfTag    : collection.Map[Int, NumberedNameKind]   = numberedNameKinds
-  def uniqueNameKindOfSeparator: collection.Map[String, UniqueNameKind]  = uniqueNameKinds
+  def simpleNameKindOfTag      : util.ReadOnlyMap[Int, ClassifiedNameKind] = simpleNameKinds
+  def qualifiedNameKindOfTag   : util.ReadOnlyMap[Int, QualifiedNameKind]  = qualifiedNameKinds
+  def numberedNameKindOfTag    : util.ReadOnlyMap[Int, NumberedNameKind]   = numberedNameKinds
+  def uniqueNameKindOfSeparator: util.ReadOnlyMap[String, UniqueNameKind]  = uniqueNameKinds
 }

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/core/Types.scala

@@ -3405,7 +3405,7 @@ object Types {
   abstract class LambdaTypeCompanion[N <: Name, PInfo <: Type, LT <: LambdaType] {
     def syntheticParamName(n: Int): N
 
-    @sharable private val memoizedNames = new mutable.HashMap[Int, List[N]]
+    @sharable private val memoizedNames = util.HashMap[Int, List[N]]()
     def syntheticParamNames(n: Int): List[N] = synchronized {
       memoizedNames.getOrElseUpdate(n, (0 until n).map(syntheticParamName).toList)
     }

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)
 
   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/transform/Getters.scala

@@ -91,7 +91,7 @@ class Getters extends MiniPhase with SymTransformer { thisPhase =>
   }
   private val NoGetterNeededFlags = Method | Param | JavaDefined | JavaStatic
 
-  val newSetters = mutable.HashSet[Symbol]()
+  val newSetters = util.HashSet[Symbol]()
 
   def ensureSetter(sym: TermSymbol)(using Context) =
     if !sym.setter.exists then

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

@@ -77,7 +77,7 @@ object OverridingPairs {
      *  (maybe excluded because of hasCommonParentAsSubclass).
      *  These will not appear as overriding
      */
-    private val visited = new mutable.HashSet[Symbol]
+    private val visited = util.HashSet[Symbol]()
 
     /** The current entry candidate for overriding
      */

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

@@ -160,8 +160,8 @@ class TreeChecker extends Phase with SymTransformer {
 
   class Checker(phasesToCheck: Seq[Phase]) extends ReTyper with Checking {
 
-    private val nowDefinedSyms = new mutable.HashSet[Symbol]
-    private val patBoundSyms = new mutable.HashSet[Symbol]
+    private val nowDefinedSyms = util.HashSet[Symbol]()
+    private val patBoundSyms = util.HashSet[Symbol]()
     private val everDefinedSyms = MutableSymbolMap[untpd.Tree]()
 
     // don't check value classes after typer, as the constraint about constructors doesn't hold after transform

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,14 @@ abstract class MutableSet[T] {
    */
   def put(x: T): T
 
-  def clear(): Unit
-
-  def size: Int
+  /** Remove element `x` from the set */
+  def -=(x: T): Unit
 
-  def iterator: Iterator[T]
-
-  def contains(x: T): Boolean = lookup(x) != null
+  def clear(): Unit
 
-  def foreach[U](f: T => U): Unit = iterator foreach f
+  def ++= (xs: IterableOnce[T]): Unit =
+    xs.iterator.foreach(this += _)
 
-  def toList: List[T] = iterator.toList
+  def --= (xs: IterableOnce[T]): Unit =
+    xs.iterator.foreach(this -= _)
 
-}

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)
+

tests/neg-custom-args/i1650.scala

@@ -1,5 +1,5 @@
 object Test {
-  test4(test4$default$1) // error: recursion limit exceeded
+  test4(test4$default$1)
   def test4[T[P]](x: T[T[List[T[X forSome { type X }]]]]) = ??? // error // error
   def test4$default$1[T[P]]: T[Int] = ???
 }