Convert some mutable.HashMaps to util.HashMaps

Author: odersky

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

@@ -108,7 +108,7 @@ case class AggregateClassPath(aggregates: Seq[ClassPath]) extends ClassPath {
   private def mergeClassesAndSources(entries: scala.collection.Seq[ClassRepresentation]): Seq[ClassRepresentation] = {
     // based on the implementation from MergedClassPath
     var count = 0
-    val indices = new collection.mutable.HashMap[String, Int]()
+    val indices = util.HashMap[String, Int]()
     val mergedEntries = new ArrayBuffer[ClassRepresentation](entries.size)
     for {
       entry <- entries

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

@@ -1,7 +1,8 @@
 /*
  * Copyright (c) 2014 Contributor. All rights reserved.
  */
-package dotty.tools.dotc.classpath
+package dotty.tools.dotc
+package classpath
 
 import java.io.File
 import java.net.URL
@@ -12,6 +13,7 @@ import scala.annotation.tailrec
 import dotty.tools.io.{AbstractFile, ClassPath, ClassRepresentation, FileZipArchive, ManifestResources}
 import dotty.tools.dotc.core.Contexts._
 import FileUtils._
+import util._
 
 /**
  * A trait providing an optional cache for classpath entries obtained from zip and jar files.
@@ -89,8 +91,8 @@ object ZipAndJarClassPathFactory extends ZipAndJarFileLookupFactory {
      * when we need subpackages of a given package or its classes, we traverse once and cache only packages.
      * Classes for given package can be then easily loaded when they are needed.
      */
-    private lazy val cachedPackages: collection.mutable.HashMap[String, PackageFileInfo] = {
-      val packages = collection.mutable.HashMap[String, PackageFileInfo]()
+    private lazy val cachedPackages: util.HashMap[String, PackageFileInfo] = {
+      val packages = util.HashMap[String, PackageFileInfo]()
 
       def getSubpackages(dir: AbstractFile): List[AbstractFile] =
         (for (file <- dir if file.isPackage) yield file).toList
@@ -102,7 +104,7 @@ object ZipAndJarClassPathFactory extends ZipAndJarFileLookupFactory {
         case pkgFile :: remainingFiles =>
           val subpackages = getSubpackages(pkgFile)
           val fullPkgName = packagePrefix + pkgFile.name
-          packages.put(fullPkgName, PackageFileInfo(pkgFile, subpackages))
+          packages(fullPkgName) = PackageFileInfo(pkgFile, subpackages)
           val newPackagePrefix = fullPkgName + "."
           subpackagesQueue.enqueue(PackageInfo(newPackagePrefix, subpackages))
           traverse(packagePrefix, remainingFiles, subpackagesQueue)
@@ -113,7 +115,7 @@ object ZipAndJarClassPathFactory extends ZipAndJarFileLookupFactory {
       }
 
       val subpackages = getSubpackages(file)
-      packages.put(ClassPath.RootPackage, PackageFileInfo(file, subpackages))
+      packages(ClassPath.RootPackage) = PackageFileInfo(file, subpackages)
       traverse(ClassPath.RootPackage, subpackages, collection.mutable.Queue())
       packages
     }

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

@@ -4321,7 +4321,7 @@ object Types {
     def underlying(using Context): Type = bound
 
     private var myReduced: Type = null
-    private var reductionContext: mutable.Map[Type, Type] = null
+    private var reductionContext: util.MutableMap[Type, Type] = null
 
     override def tryNormalize(using Context): Type = reduced.normalized
 
@@ -4340,7 +4340,7 @@ object Types {
       }
 
       def updateReductionContext(footprint: collection.Set[Type]): Unit =
-        reductionContext = new mutable.HashMap
+        reductionContext = util.HashMap()
         for (tp <- footprint)
           reductionContext(tp) = contextInfo(tp)
         typr.println(i"footprint for $this $hashCode: ${footprint.toList.map(x => (x, contextInfo(x)))}%, %")

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -732,15 +732,13 @@ class ClassfileParser(
           classTranslation.flags(jflags),
           getScope(jflags))
 
-    for (entry <- innerClasses.values) {
+    for entry <- innerClasses.valuesIterator do
       // create a new class member for immediate inner classes
-      if (entry.outerName == currentClassName) {
+      if entry.outerName == currentClassName then
         val file = ctx.platform.classPath.findClassFile(entry.externalName.toString) getOrElse {
           throw new AssertionError(entry.externalName)
         }
         enterClassAndModule(entry, file, entry.jflags)
-      }
-    }
   }
 
   // Nothing$ and Null$ were incorrectly emitted with a Scala attribute
@@ -937,14 +935,14 @@ class ClassfileParser(
       s"$originalName in $outerName($externalName)"
   }
 
-  object innerClasses extends scala.collection.mutable.HashMap[Name, InnerClassEntry] {
+  object innerClasses extends util.HashMap[Name, InnerClassEntry] {
     /** Return the Symbol of the top level class enclosing `name`,
      *  or 'name's symbol if no entry found for `name`.
      */
     def topLevelClass(name: Name)(using Context): Symbol = {
-      val tlName = if (isDefinedAt(name)) {
+      val tlName = if (contains(name)) {
         var entry = this(name)
-        while (isDefinedAt(entry.outerName))
+        while (contains(entry.outerName))
           entry = this(entry.outerName)
         entry.outerName
       }

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

@@ -177,6 +177,9 @@ abstract class GenericHashMap[Key, Value]
   def keysIterator: Iterator[Key] = new EntryIterator:
     def entry(idx: Int) = keyAt(idx)
 
+  def valuesIterator: Iterator[Value] = new EntryIterator:
+    def entry(idx: Int) = valueAt(idx)
+
   override def toString: String =
     iterator.map((k, v) => s"$k -> $v").mkString("HashMap(", ", ", ")")