Homogenize mutable symbol maps

Use IdentityHashMap instead of mutable.HashMap to make fast equality check

Author: nicolasstucki

bench/scripts/compiler.sh

@@ -1,2 +1,2 @@
 #!/usr/bin/env bash
-find compiler/src/ -type f \( -name "*.scala" -or -name "*.java" \) -exec echo "dotty-bench/jmh:run 5 10" {} + | sbt
+find compiler/src/ -type f \( -name "*.scala" -or -name "*.java" \) -exec echo "dotty-bench/jmh:run 6 10" {} + | sbt

compiler/sjs/backend/sjs/JSPrimitives.scala

@@ -59,7 +59,7 @@ class JSPrimitives(ctx: Context) extends DottyPrimitives(ctx) {
   /** Initialize the primitive map */
   private def initJSPrimitives(implicit ctx: Context): Map[Symbol, Int] = {
 
-    val primitives = new mutable.HashMap[Symbol, Int]()
+    val primitives = newMutableSymbolMap[Int]
 
     // !!! Code duplicate with DottyPrimitives
     /** Add a primitive operation to the map */

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

@@ -40,7 +40,7 @@ class GenBCode extends Phase {
   private val entryPoints = new mutable.HashSet[Symbol]()
   def registerEntryPoint(sym: Symbol) = entryPoints += sym
 
-  private val superCallsMap = new mutable.HashMap[Symbol, Set[ClassSymbol]]()
+  private val superCallsMap = newMutableSymbolMap[Set[ClassSymbol]]
   def registerSuperCall(sym: Symbol, calls: ClassSymbol) = {
     val old = superCallsMap.getOrElse(sym, Set.empty)
     superCallsMap.put(sym, old + calls)

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

@@ -106,7 +106,7 @@ class LabelDefs extends MiniPhaseTransform {
               val labelDef2 = transform(labelDef)
               Block(labelDef2:: Nil, t)
 
-            case _ => if (labelDefs.nonEmpty) super.transform(tree) else tree
+            case _ => if (!labelDefs.isEmpty) super.transform(tree) else tree
           }
         }
       }
@@ -120,7 +120,7 @@ class LabelDefs extends MiniPhaseTransform {
   object collectLabelDefs extends TreeMap() {
 
     // labelSymbol -> Defining tree
-    val labelDefs = new mutable.HashMap[Symbol, Tree]()
+    val labelDefs = Symbols.newMutableSymbolMap[Tree]
 
     def clear = {
       labelDefs.clear()

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

@@ -128,7 +128,7 @@ class DottyPrimitives(ctx: Context) {
     implicit val ctx = this.ctx
 
     import core.Symbols.defn
-    val primitives = new mutable.HashMap[Symbol, Int]()
+    val primitives = core.Symbols.newMutableSymbolMap[Int]
 
     /** Add a primitive operation to the map */
     def addPrimitive(s: Symbol, code: Int): Unit = {

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

@@ -23,10 +23,8 @@ object Comments {
     * docstrings via `Symbol` and expanding templates
     */
   class ContextDocstrings {
-    import scala.collection.mutable
 
-    private[this] val _docstrings: mutable.Map[Symbol, Comment] =
-      mutable.Map.empty
+    private[this] val _docstrings: MutableSymbolMap[Comment] = newMutableSymbolMap
 
     val templateExpander = new CommentExpander
 
@@ -35,7 +33,7 @@ object Comments {
     def docstring(sym: Symbol): Option[Comment] = _docstrings.get(sym)
 
     def addDocstring(sym: Symbol, doc: Option[Comment]): Unit =
-      doc.map(d => _docstrings += (sym -> d))
+      doc.map(d => _docstrings.put(sym, d))
   }
 
   /** A `Comment` contains the unformatted docstring as well as a position
@@ -182,7 +180,7 @@ object Comments {
     protected def superComment(sym: Symbol)(implicit ctx: Context): Option[String] =
       allInheritedOverriddenSymbols(sym).iterator map (x => cookedDocComment(x)) find (_ != "")
 
-    private val cookedDocComments = mutable.HashMap[Symbol, String]()
+    private val cookedDocComments = newMutableSymbolMap[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

@@ -635,4 +635,70 @@ object Symbols {
   def currentClass(implicit ctx: Context): ClassSymbol = ctx.owner.enclosingClass.asClass
 
   @sharable var stubs: List[Symbol] = Nil // diagnostic only
+
+  /* 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] = {
+      import scala.collection.JavaConversions._
+      value.toMap.filter(p)
+    }
+
+    def iterator: Iterator[(Symbol, T)] = {
+      import scala.collection.JavaConversions._
+      value.iterator
+    }
+
+    def keysIterator: Iterator[Symbol] = {
+      import scala.collection.JavaConversions._
+      value.keySet().iterator
+    }
+
+    def toMap: Map[Symbol, T] = {
+      import scala.collection.JavaConversions._
+      value.toMap
+    }
+  }
+
+  @inline def newMutableSymbolMap[T]: MutableSymbolMap[T] =
+    new MutableSymbolMap(new java.util.IdentityHashMap[Symbol, T]())
+
 }

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

@@ -23,8 +23,8 @@ class TreePickler(pickler: TastyPickler) {
   import pickler.nameBuffer.nameIndex
   import ast.tpd._
 
-  private val symRefs = new mutable.HashMap[Symbol, Addr]
-  private val forwardSymRefs = new mutable.HashMap[Symbol, List[Addr]]
+  private val symRefs = Symbols.newMutableSymbolMap[Addr]
+  private val forwardSymRefs = Symbols.newMutableSymbolMap[List[Addr]]
   private val pickledTypes = new java.util.IdentityHashMap[Type, Any] // Value type is really Addr, but that's not compatible with null
 
   private def withLength(op: => Unit) = {
@@ -595,14 +595,14 @@ class TreePickler(pickler: TastyPickler) {
 
   def pickle(trees: List[Tree])(implicit ctx: Context) = {
     trees.foreach(tree => if (!tree.isEmpty) pickleTree(tree))
-    assert(forwardSymRefs.isEmpty, i"unresolved symbols: ${forwardSymRefs.keySet.toList}%, % when pickling ${ctx.source}")
+    assert(forwardSymRefs.isEmpty, i"unresolved symbols: ${forwardSymRefs.keysIterator.toList}%, % when pickling ${ctx.source}")
   }
 
   def compactify() = {
     buf.compactify()
 
-    def updateMapWithDeltas[T](mp: collection.mutable.Map[T, Addr]) =
-      for (key <- mp.keysIterator.toBuffer[T]) mp(key) = adjusted(mp(key))
+    def updateMapWithDeltas(mp: MutableSymbolMap[Addr]) =
+      for (key <- mp.keysIterator.toBuffer[Symbol]) mp(key) = adjusted(mp(key))
 
     updateMapWithDeltas(symRefs)
   }

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

@@ -33,7 +33,7 @@ class Bridges(root: ClassSymbol)(implicit ctx: Context) {
   private var toBeRemoved = immutable.Set[Symbol]()
   private val bridges = mutable.ListBuffer[Tree]()
   private val bridgesScope = newScope
-  private val bridgeTarget = mutable.HashMap[Symbol, Symbol]()
+  private val bridgeTarget = newMutableSymbolMap[Symbol]
 
   /** Add a bridge between `member` and `other`, where `member` overrides `other`
    *  before erasure, if the following conditions are satisfied.

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

@@ -139,7 +139,7 @@ class ExtensionMethods extends MiniPhaseTransform with DenotTransformer with Ful
     extensionMeth
   }
 
-  private val extensionDefs = mutable.Map[Symbol, mutable.ListBuffer[Tree]]()
+  private val extensionDefs = newMutableSymbolMap[mutable.ListBuffer[Tree]]
   // TODO: this is state and should be per-run
   // todo: check that when transformation finished map is empty
 

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

@@ -33,7 +33,7 @@ class NonLocalReturns extends MiniPhaseTransform { thisTransformer =>
     defn.NonLocalReturnControlType.appliedTo(argtype)
 
   /** A hashmap from method symbols to non-local return keys */
-  private val nonLocalReturnKeys = mutable.Map[Symbol, TermSymbol]()
+  private val nonLocalReturnKeys = newMutableSymbolMap[TermSymbol]
 
   /** Return non-local return key for given method */
   private def nonLocalReturnKey(meth: Symbol)(implicit ctx: Context) =

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

@@ -67,7 +67,7 @@ object OverridingPairs {
     }
 
     private val subParents = {
-      val subParents = new mutable.HashMap[Symbol, BitSet]
+      val subParents = newMutableSymbolMap[BitSet]
       for (bc <- base.info.baseClasses)
         subParents(bc) = BitSet(parents.indices.filter(parents(_).derivesFrom(bc)): _*)
       subParents

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

@@ -76,8 +76,8 @@ object PatternMatcher {
     /** A map from variable symbols to their defining trees
      *  and from labels to their defining plans
      */
-    private val initializer = mutable.Map[Symbol, Tree]()
-    private val labelled = mutable.Map[Symbol, Plan]()
+    private val initializer = newMutableSymbolMap[Tree]
+    private val labelled = newMutableSymbolMap[Plan]
 
     private def newVar(rhs: Tree, flags: FlagSet): TermSymbol =
       ctx.newSymbol(ctx.owner, PatMatStdBinderName.fresh(), Synthetic | Case | flags,
@@ -529,7 +529,7 @@ object PatternMatcher {
         tests1.filter { case(test, outcome) => tests2.get(test) == Some(outcome) }
 
       /** The tests with known outcomes valid at entry to label */
-      val seenAtLabel = mutable.HashMap[Symbol, SeenTests]()
+      val seenAtLabel = newMutableSymbolMap[SeenTests]
 
       class ElimRedundant(seenTests: SeenTests) extends PlanTransform {
         override def apply(plan: TestPlan): Plan = {
@@ -609,12 +609,12 @@ object PatternMatcher {
       type SeenVars = Map[RHS, TermSymbol]
 
       /** The variables known at entry to label */
-      val seenAtLabel = mutable.HashMap[Symbol, SeenVars]()
+      val seenAtLabel = newMutableSymbolMap[SeenVars]
 
       /** Parameters of label; these are passed additional variables
        *  which are known at all callsites.
        */
-      val paramsOfLabel = mutable.HashMap[Symbol, SeenVars]()
+      val paramsOfLabel = newMutableSymbolMap[SeenVars]
 
       class Merge(seenVars: SeenVars) extends PlanTransform {
         override val treeMap = new TreeMap {

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

@@ -69,7 +69,7 @@ class ShortcutImplicits extends MiniPhase with IdentityDenotTransformer { thisTr
     /** A map to cache mapping local methods to their direct counterparts.
      *  A fresh map is created for each unit.
      */
-    private val directMeth = new mutable.HashMap[Symbol, Symbol]
+    private val directMeth = newMutableSymbolMap[Symbol]
 
     /** Should `sym` get a ..$direct companion?
      *  This is the case if (1) `sym` is a method with an implicit function type as final result type.

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

@@ -65,7 +65,7 @@ class SuperAccessors(thisTransformer: DenotTransformer) {
       ctx.owner.enclosingClass != invalidEnclClass
 
     /** List buffers for new accessor definitions, indexed by class */
-    private val accDefs = mutable.Map[Symbol, mutable.ListBuffer[Tree]]()
+    private val accDefs = newMutableSymbolMap[mutable.ListBuffer[Tree]]
 
     /** A super accessor call corresponding to `sel` */
     private def superAccessorCall(sel: Select)(implicit ctx: Context) = {

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

@@ -142,7 +142,7 @@ class TreeChecker extends Phase with SymTransformer {
   class Checker(phasesToCheck: Seq[Phase]) extends ReTyper with Checking {
 
     val nowDefinedSyms = new mutable.HashSet[Symbol]
-    val everDefinedSyms = new mutable.HashMap[Symbol, untpd.Tree]
+    val everDefinedSyms = newMutableSymbolMap[untpd.Tree]
 
     // don't check value classes after typer, as the constraint about constructors doesn't hold after transform
     override def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(implicit ctx: Context) = ()

compiler/src/dotty/tools/dotc/transform/localopt/Devalify.scala

@@ -23,13 +23,13 @@ import transform.SymUtils._
 class Devalify extends Optimisation {
   import ast.tpd._
 
-  val timesUsed = mutable.HashMap[Symbol, Int]()
-  val timesUsedAsType = mutable.HashMap[Symbol, Int]()
+  val timesUsed = newMutableSymbolMap[Int]
+  val timesUsedAsType = newMutableSymbolMap[Int]
 
   val defined = mutable.HashSet[Symbol]()
-  val usedInInnerClass = mutable.HashMap[Symbol, Int]()
+  val usedInInnerClass = newMutableSymbolMap[Int]
   // Either a duplicate or a read through series of immutable fields
-  val copies = mutable.HashMap[Symbol, Tree]()
+  val copies = newMutableSymbolMap[Tree]
 
   def clear(): Unit = {
     timesUsed.clear()
@@ -48,7 +48,7 @@ class Devalify extends Optimisation {
     })
   }
 
-  def doVisit(tree: Tree, used: mutable.HashMap[Symbol, Int])(implicit ctx: Context): Unit = tree match {
+  def doVisit(tree: Tree, used: MutableSymbolMap[Int])(implicit ctx: Context): Unit = tree match {
     case valdef: ValDef if !valdef.symbol.is(Param | Mutable | Module | Lazy) &&
                            valdef.symbol.exists && !valdef.symbol.owner.isClass =>
       defined += valdef.symbol
@@ -63,7 +63,7 @@ class Devalify extends Optimisation {
       val normalized = t.tpt.tpe.normalizedPrefix
       val symIfExists = normalized.termSymbol
       val b4 = used.getOrElseUpdate(symIfExists, 0)
-      used.put(symIfExists, b4 + 1)
+      used(symIfExists) = b4 + 1
       visitType(normalized)
 
     case valdef: ValDef if valdef.symbol.exists && !valdef.symbol.owner.isClass &&
@@ -107,21 +107,21 @@ class Devalify extends Optimisation {
   }
 
   def transformer(implicit ctx: Context): Tree => Tree = {
-    val valsToDrop = defined -- timesUsed.keySet -- timesUsedAsType.keySet
+    val valsToDrop = defined -- timesUsed.keysIterator -- timesUsedAsType.keysIterator
     val copiesToReplaceAsDuplicates = copies.filter { x =>
       val rhs = dropCasts(x._2)
       rhs.isInstanceOf[Literal] || (!rhs.symbol.owner.isClass && !rhs.symbol.is(Method | Mutable))
-    } -- timesUsedAsType.keySet
+    } -- timesUsedAsType.keysIterator
     // TODO: if a non-synthetic val is duplicate of a synthetic one, rename a synthetic one and drop synthetic flag?
 
     val copiesToReplaceAsUsedOnce =
       timesUsed.filter(x => x._2 == 1)
         .flatMap(x => copies.get(x._1) match {
           case Some(tr) => List((x._1, tr))
           case None => Nil
-        }) -- timesUsedAsType.keySet
+        }) -- timesUsedAsType.keysIterator
 
-    val replacements = copiesToReplaceAsDuplicates ++ copiesToReplaceAsUsedOnce -- usedInInnerClass.keySet
+    val replacements = copiesToReplaceAsDuplicates ++ copiesToReplaceAsUsedOnce -- usedInInnerClass.keysIterator
 
     val deepReplacer = new TreeMap() {
       override def transform(tree: Tree)(implicit ctx: Context): Tree = {

compiler/src/dotty/tools/dotc/transform/localopt/InlineLabelsCalledOnce.scala

@@ -15,8 +15,8 @@ import config.Printers.simplify
 class InlineLabelsCalledOnce extends Optimisation {
   import ast.tpd._
 
-  val timesUsed = mutable.HashMap[Symbol, Int]()
-  val defined   = mutable.HashMap[Symbol, DefDef]()
+  val timesUsed = newMutableSymbolMap[Int]
+  val defined   = newMutableSymbolMap[DefDef]
 
   def clear(): Unit = {
     timesUsed.clear()

compiler/src/dotty/tools/dotc/transform/localopt/InlineOptions.scala

@@ -17,7 +17,7 @@ import scala.collection.mutable
 class InlineOptions extends Optimisation {
   import ast.tpd._
 
-  val somes = mutable.HashMap[Symbol, Tree]()
+  val somes = newMutableSymbolMap[Tree]
   val nones = mutable.HashSet[Symbol]()
 
   def clear(): Unit = {

compiler/src/dotty/tools/dotc/transform/localopt/Jumpjump.scala

@@ -18,7 +18,7 @@ import core.Flags._
 class Jumpjump extends Optimisation {
   import ast.tpd._
 
-  val defined = mutable.HashMap[Symbol, Symbol]()
+  val defined = newMutableSymbolMap[Symbol]
 
   def clear(): Unit = defined.clear()
 

compiler/src/dotty/tools/dotc/transform/localopt/RemoveUnnecessaryNullChecks.scala

@@ -24,7 +24,7 @@ import scala.collection.mutable
 
   val initializedVals = mutable.HashSet[Symbol]()
 
-  val checkGood = mutable.HashMap[Symbol, Set[Symbol]]()
+  val checkGood = newMutableSymbolMap[Set[Symbol]]
 
   def clear(): Unit = {
     initializedVals.clear()

compiler/src/dotty/tools/dotc/transform/localopt/Valify.scala

@@ -16,13 +16,13 @@ class Valify(val simplifyPhase: Simplify) extends Optimisation {
   import ast.tpd._
 
   // Either a duplicate or a read through series of immutable fields.
-  val defined: mutable.Map[Symbol, ValDef] = mutable.Map()
+  val defined: MutableSymbolMap[ValDef] = newMutableSymbolMap
 
-  val firstRead: mutable.Map[Symbol, RefTree] = mutable.Map()
+  val firstRead: MutableSymbolMap[RefTree] = newMutableSymbolMap
 
-  val firstWrite: mutable.Map[Symbol, Assign] = mutable.Map()
+  val firstWrite: MutableSymbolMap[Assign] = newMutableSymbolMap
 
-  val secondWrite: mutable.Map[Symbol, Assign] = mutable.Map()
+  val secondWrite: MutableSymbolMap[Assign] = newMutableSymbolMap
 
   def clear(): Unit = {
     defined.clear()