Drop MutableSymbolMap as a separate class

It's now an alias of util.IdentityHashMap[Symbol, _]

Author: odersky

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -22,7 +22,7 @@ import Symbols._
 import Phases._
 
 import dotty.tools.dotc.util
-import dotty.tools.dotc.util.Spans
+import dotty.tools.dotc.util.{Spans, ReadOnlyMap}
 import dotty.tools.dotc.report
 
 import Decorators._
@@ -36,7 +36,7 @@ import Names.TermName
 import Annotations.Annotation
 import Names.Name
 
-class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap: Map[Symbol, Set[ClassSymbol]])(using val ctx: Context) {
+class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap: ReadOnlyMap[Symbol, Set[ClassSymbol]])(using val ctx: Context) {
 
   private val desugared = new java.util.IdentityHashMap[Type, tpd.Select]
 

compiler/src/dotty/tools/backend/jvm/GenBCode.scala

@@ -36,7 +36,7 @@ import dotty.tools.io._
 class GenBCode extends Phase {
   def phaseName: String = GenBCode.name
 
-  private val superCallsMap = newMutableSymbolMap[Set[ClassSymbol]]
+  private val superCallsMap = new MutableSymbolMap[Set[ClassSymbol]]
   def registerSuperCall(sym: Symbol, calls: ClassSymbol): Unit = {
     val old = superCallsMap.getOrElse(sym, Set.empty)
     superCallsMap.update(sym, old + calls)
@@ -51,10 +51,8 @@ class GenBCode extends Phase {
   }
 
   def run(using Context): Unit =
-    new GenBCodePipeline(
-      new DottyBackendInterface(
-        outputDir, superCallsMap.toMap
-      )
+    GenBCodePipeline(
+      DottyBackendInterface(outputDir, superCallsMap)
     ).run(ctx.compilationUnit.tpdTree)
 
 

compiler/src/dotty/tools/backend/jvm/scalaPrimitives.scala

@@ -9,6 +9,7 @@ import Names.TermName, StdNames._
 import Types.{JavaArrayType, UnspecifiedErrorType, Type}
 import Symbols.{Symbol, NoSymbol}
 import dotc.report
+import dotc.util.ReadOnlyMap
 
 import scala.annotation.threadUnsafe
 import scala.collection.immutable
@@ -34,7 +35,7 @@ import scala.collection.immutable
 class DottyPrimitives(ictx: Context) {
   import dotty.tools.backend.ScalaPrimitivesOps._
 
-  @threadUnsafe private lazy val primitives: immutable.Map[Symbol, Int] = init
+  @threadUnsafe private lazy val primitives: ReadOnlyMap[Symbol, Int] = init
 
   /** Return the code for the given symbol. */
   def getPrimitive(sym: Symbol): Int = {
@@ -118,12 +119,12 @@ class DottyPrimitives(ictx: Context) {
   }
 
   /** Initialize the primitive map */
-  private def init: immutable.Map[Symbol, Int]  = {
+  private def init: ReadOnlyMap[Symbol, Int]  = {
 
     given Context = ictx
 
     import Symbols.defn
-    val primitives = Symbols.newMutableSymbolMap[Int]
+    val primitives = Symbols.MutableSymbolMap[Int](512)
 
     /** Add a primitive operation to the map */
     def addPrimitive(s: Symbol, code: Int): Unit = {
@@ -394,7 +395,7 @@ class DottyPrimitives(ictx: Context) {
     addPrimitives(DoubleClass, nme.UNARY_-, NEG)
 
 
-    primitives.toMap
+    primitives
   }
 
   def isPrimitive(sym: Symbol): Boolean =

compiler/src/dotty/tools/backend/sjs/JSPrimitives.scala

@@ -10,6 +10,7 @@ import Symbols._
 import dotty.tools.dotc.ast.tpd._
 import dotty.tools.backend.jvm.DottyPrimitives
 import dotty.tools.dotc.report
+import dotty.tools.dotc.util.ReadOnlyMap
 
 import scala.collection.mutable
 
@@ -55,7 +56,7 @@ class JSPrimitives(ictx: Context) extends DottyPrimitives(ictx) {
   import JSPrimitives._
   import dotty.tools.backend.ScalaPrimitivesOps._
 
-  private lazy val jsPrimitives: Map[Symbol, Int] = initJSPrimitives(using ictx)
+  private lazy val jsPrimitives: ReadOnlyMap[Symbol, Int] = initJSPrimitives(using ictx)
 
   override def getPrimitive(sym: Symbol): Int =
     jsPrimitives.getOrElse(sym, super.getPrimitive(sym))
@@ -70,9 +71,9 @@ class JSPrimitives(ictx: Context) extends DottyPrimitives(ictx) {
     jsPrimitives.contains(fun.symbol(using ictx)) || super.isPrimitive(fun)
 
   /** Initialize the primitive map */
-  private def initJSPrimitives(using Context): Map[Symbol, Int] = {
+  private def initJSPrimitives(using Context): ReadOnlyMap[Symbol, Int] = {
 
-    val primitives = newMutableSymbolMap[Int]
+    val primitives = MutableSymbolMap[Int]()
 
     // !!! Code duplicate with DottyPrimitives
     /** Add a primitive operation to the map */
@@ -120,7 +121,7 @@ class JSPrimitives(ictx: Context) extends DottyPrimitives(ictx) {
     addPrimitive(jsdefn.ReflectSelectable_selectDynamic, REFLECT_SELECTABLE_SELECTDYN)
     addPrimitive(jsdefn.ReflectSelectable_applyDynamic, REFLECT_SELECTABLE_APPLYDYN)
 
-    primitives.toMap
+    primitives
   }
 
 }

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

@@ -4,7 +4,7 @@ package core
 
 import ast.{ untpd, tpd }
 import Decorators._, Symbols._, Contexts._
-import util.SourceFile
+import util.{SourceFile, ReadOnlyMap}
 import util.Spans._
 import util.CommentParsing._
 import util.Property.Key
@@ -23,11 +23,11 @@ object Comments {
     */
   class ContextDocstrings {
 
-    private val _docstrings: MutableSymbolMap[Comment] = newMutableSymbolMap
+    private val _docstrings: MutableSymbolMap[Comment] = MutableSymbolMap[Comment](512) // FIXME: 2nd [Comment] needed or "not a class type"
 
     val templateExpander: CommentExpander = new CommentExpander
 
-    def docstrings: Map[Symbol, Comment] = _docstrings.toMap
+    def docstrings: ReadOnlyMap[Symbol, Comment] = _docstrings
 
     def docstring(sym: Symbol): Option[Comment] = _docstrings.get(sym)
 
@@ -180,7 +180,7 @@ object Comments {
     protected def superComment(sym: Symbol)(using Context): Option[String] =
       allInheritedOverriddenSymbols(sym).iterator map (x => cookedDocComment(x)) find (_ != "")
 
-    private val cookedDocComments = newMutableSymbolMap[String]
+    private val cookedDocComments = MutableSymbolMap[String]()
 
     /** The raw doc comment of symbol `sym`, minus usecase and define sections, augmented by
      *  missing sections of an inherited doc comment.

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

@@ -30,7 +30,7 @@ import reporting.Message
 import collection.mutable
 import io.AbstractFile
 import language.implicitConversions
-import util.{SourceFile, NoSource, Property, SourcePosition, SrcPos}
+import util.{SourceFile, NoSource, Property, SourcePosition, SrcPos, IdentityHashMap}
 import scala.collection.JavaConverters._
 import scala.annotation.internal.sharable
 import config.Printers.typr
@@ -495,61 +495,7 @@ object Symbols {
   /** The current class */
   def currentClass(using Context): ClassSymbol = ctx.owner.enclosingClass.asClass
 
-  /* Mutable map from symbols any T */
-  class MutableSymbolMap[T](private[Symbols] val value: java.util.IdentityHashMap[Symbol, T]) extends AnyVal {
-
-    def apply(sym: Symbol): T = value.get(sym)
-
-    def get(sym: Symbol): Option[T] = Option(value.get(sym))
-
-    def getOrElse[U >: T](sym: Symbol, default: => U): U = {
-      val v = value.get(sym)
-      if (v != null) v else default
-    }
-
-    def getOrElseUpdate(sym: Symbol, op: => T): T = {
-      val v = value.get(sym)
-      if (v != null) v
-      else {
-        val v = op
-        assert(v != null)
-        value.put(sym, v)
-        v
-      }
-    }
-
-    def update(sym: Symbol, x: T): Unit = {
-      assert(x != null)
-      value.put(sym, x)
-    }
-    def put(sym: Symbol, x: T): T = {
-      assert(x != null)
-      value.put(sym, x)
-    }
-
-    def -=(sym: Symbol): Unit = value.remove(sym)
-    def remove(sym: Symbol): Option[T] = Option(value.remove(sym))
-
-    def contains(sym: Symbol): Boolean = value.containsKey(sym)
-
-    def isEmpty: Boolean = value.isEmpty
-
-    def clear(): Unit = value.clear()
-
-    def filter(p: ((Symbol, T)) => Boolean): Map[Symbol, T] =
-      value.asScala.toMap.filter(p)
-
-    def iterator: Iterator[(Symbol, T)] = value.asScala.iterator
-
-    def keysIterator: Iterator[Symbol] = value.keySet().asScala.iterator
-
-    def toMap: Map[Symbol, T] = value.asScala.toMap
-
-    override def toString: String = value.asScala.toString()
-  }
-
-  inline def newMutableSymbolMap[T]: MutableSymbolMap[T] =
-    new MutableSymbolMap(new java.util.IdentityHashMap[Symbol, T]())
+  type MutableSymbolMap[T] = IdentityHashMap[Symbol, T]
 
 // ---- Factory methods for symbol creation ----------------------
 //

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -42,8 +42,8 @@ class TreePickler(pickler: TastyPickler) {
   import pickler.nameBuffer.nameIndex
   import tpd._
 
-  private val symRefs = Symbols.newMutableSymbolMap[Addr]
-  private val forwardSymRefs = Symbols.newMutableSymbolMap[List[Addr]]
+  private val symRefs = Symbols.MutableSymbolMap[Addr](256)
+  private val forwardSymRefs = Symbols.MutableSymbolMap[List[Addr]]()
   private val pickledTypes = util.IdentityHashMap[Type, Addr]()
 
   /** A list of annotation trees for every member definition, so that later

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

@@ -1,4 +1,5 @@
-package dotty.tools.dotc
+package dotty.tools
+package dotc
 package transform
 
 import core._
@@ -23,7 +24,7 @@ abstract class AccessProxies {
   import AccessProxies._
 
   /** accessor -> accessed */
-  private val accessedBy = newMutableSymbolMap[Symbol]
+  private val accessedBy = MutableSymbolMap[Symbol]()
 
   /** Given the name of an accessor, is the receiver of the call to accessed obtained
    *  as a parameterer?
@@ -35,7 +36,7 @@ abstract class AccessProxies {
    *  So a second call of the same method will yield the empty list.
    */
   private def accessorDefs(cls: Symbol)(using Context): Iterator[DefDef] =
-    for (accessor <- cls.info.decls.iterator; accessed <- accessedBy.remove(accessor)) yield
+    for (accessor <- cls.info.decls.iterator; accessed <- accessedBy.remove(accessor).toOption) yield
       polyDefDef(accessor.asTerm, tps => argss => {
         def numTypeParams = accessed.info match {
           case info: PolyType => info.paramNames.length

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

@@ -36,7 +36,7 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
   private var toBeRemoved = immutable.Set[Symbol]()
   private val bridges = mutable.ListBuffer[Tree]()
   private val bridgesScope = newScope
-  private val bridgeTarget = newMutableSymbolMap[Symbol]
+  private val bridgeTarget = MutableSymbolMap[Symbol]()
 
   def bridgePosFor(member: Symbol): SrcPos =
     (if (member.owner == root && member.span.exists) member else root).srcPos

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

@@ -1,4 +1,5 @@
-package dotty.tools.dotc
+package dotty.tools
+package dotc
 package transform
 
 import core._
@@ -115,13 +116,13 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
     && (((cls.owner.name eq nme.DOLLAR_NEW) && cls.owner.isAllOf(Private|Synthetic)) || cls.owner.isAllOf(EnumCase))
     && cls.owner.owner.linkedClass.derivesFromJavaEnum
 
-  private val enumCaseOrdinals: MutableSymbolMap[Int] = newMutableSymbolMap
+  private val enumCaseOrdinals = MutableSymbolMap[Int]()
 
   private def registerEnumClass(cls: Symbol)(using Context): Unit =
-    cls.children.zipWithIndex.foreach(enumCaseOrdinals.put)
+    cls.children.zipWithIndex.foreach(enumCaseOrdinals.update)
 
   private def ordinalFor(enumCase: Symbol): Int =
-    enumCaseOrdinals.remove(enumCase).get
+    enumCaseOrdinals.remove(enumCase).nn
 
   /** 1. If this is an enum class, add $name and $ordinal parameters to its
    *     parameter accessors and pass them on to the java.lang.Enum constructor.

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

@@ -140,24 +140,21 @@ class ExtensionMethods extends MiniPhase with DenotTransformer with FullParamete
     extensionMeth
   }
 
-  private val extensionDefs = newMutableSymbolMap[mutable.ListBuffer[Tree]]
-  // TODO: this is state and should be per-run
+  private val extensionDefs = MutableSymbolMap[mutable.ListBuffer[Tree]]()
   // todo: check that when transformation finished map is empty
 
   override def transformTemplate(tree: tpd.Template)(using Context): tpd.Tree =
-    if (isDerivedValueClass(ctx.owner))
+    if isDerivedValueClass(ctx.owner) then
       /* This is currently redundant since value classes may not
          wrap over other value classes anyway.
         checkNonCyclic(ctx.owner.pos, Set(), ctx.owner) */
       tree
-    else if (ctx.owner.isStaticOwner)
-      extensionDefs remove tree.symbol.owner match {
-        case Some(defns) if defns.nonEmpty =>
-          cpy.Template(tree)(body = tree.body ++
-            defns.map(transformFollowing(_)))
+    else if ctx.owner.isStaticOwner then
+      extensionDefs.remove(tree.symbol.owner) match
+        case defns: mutable.ListBuffer[Tree] if defns.nonEmpty =>
+          cpy.Template(tree)(body = tree.body ++ defns.map(transformFollowing(_)))
         case _ =>
           tree
-      }
     else tree
 
   override def transformDefDef(tree: tpd.DefDef)(using Context): tpd.Tree =

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

@@ -35,7 +35,7 @@ class NonLocalReturns extends MiniPhase {
     nonLocalReturnControl.appliedTo(argtype)
 
   /** A hashmap from method symbols to non-local return keys */
-  private val nonLocalReturnKeys = newMutableSymbolMap[TermSymbol]
+  private val nonLocalReturnKeys = MutableSymbolMap[TermSymbol]()
 
   /** Return non-local return key for given method */
   private def nonLocalReturnKey(meth: Symbol)(using Context) =
@@ -83,10 +83,9 @@ class NonLocalReturns extends MiniPhase {
   }
 
   override def transformDefDef(tree: DefDef)(using Context): Tree =
-    nonLocalReturnKeys.remove(tree.symbol) match {
-      case Some(key) => cpy.DefDef(tree)(rhs = nonLocalReturnTry(tree.rhs, key, tree.symbol))
-      case _ => tree
-    }
+    nonLocalReturnKeys.remove(tree.symbol) match
+      case key: TermSymbol => cpy.DefDef(tree)(rhs = nonLocalReturnTry(tree.rhs, key, tree.symbol))
+      case null => tree
 
   override def transformReturn(tree: Return)(using Context): Tree =
     if isNonLocalReturn(tree) then

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

@@ -64,12 +64,11 @@ object OverridingPairs {
       decls
     }
 
-    private val subParents = {
-      val subParents = newMutableSymbolMap[BitSet]
+    private val subParents =
+      val subParents = MutableSymbolMap[BitSet]()
       for (bc <- base.info.baseClasses)
         subParents(bc) = BitSet(parents.indices.filter(parents(_).derivesFrom(bc)): _*)
       subParents
-    }
 
     private def hasCommonParentAsSubclass(cls1: Symbol, cls2: Symbol): Boolean =
       (subParents(cls1) intersect subParents(cls2)).nonEmpty

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

@@ -92,7 +92,7 @@ object PatternMatcher {
     /** A map from variable symbols to their defining trees
      *  and from labels to their defining plans
      */
-    private val initializer = newMutableSymbolMap[Tree]
+    private val initializer = MutableSymbolMap[Tree]()
 
     private def newVar(rhs: Tree, flags: FlagSet): TermSymbol =
       newSymbol(ctx.owner, PatMatStdBinderName.fresh(), Synthetic | Case | flags,

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

@@ -1,4 +1,5 @@
-package dotty.tools.dotc
+package dotty.tools
+package dotc
 package transform
 
 import dotty.tools.dotc.ast.{Trees, tpd}
@@ -59,7 +60,7 @@ class SuperAccessors(thisPhase: DenotTransformer) {
     ctx.owner.enclosingClass != invalidEnclClass
 
   /** List buffers for new accessor definitions, indexed by class */
-  private val accDefs = newMutableSymbolMap[mutable.ListBuffer[Tree]]
+  private val accDefs = MutableSymbolMap[mutable.ListBuffer[Tree]]()
 
   /** A super accessor call corresponding to `sel` */
   private def superAccessorCall(sel: Select, mixName: Name = nme.EMPTY)(using Context) = {
@@ -205,7 +206,7 @@ class SuperAccessors(thisPhase: DenotTransformer) {
   def wrapTemplate(tree: Template)(op: Template => Template)(using Context): Template = {
     accDefs(currentClass) = new mutable.ListBuffer[Tree]
     val impl = op(tree)
-    val accessors = accDefs.remove(currentClass).get
+    val accessors = accDefs.remove(currentClass).nn
     if (accessors.isEmpty) impl
     else {
       val (params, rest) = impl.body span {