Move off SimpleMap

Author: odersky

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

@@ -12,11 +12,8 @@ import StdNames.str
 import Designators._
 import util.Chars.isIdentifierStart
 import collection.IndexedSeqOptimized
-import collection.generic.CanBuildFrom
-import collection.mutable.{ Builder, StringBuilder, AnyRefMap }
-import collection.immutable.WrappedString
-import collection.generic.CanBuildFrom
-import util.{DotClass, SimpleMap}
+import collection.immutable
+import util.{DotClass}
 import config.Config
 import java.util.HashMap
 
@@ -193,24 +190,24 @@ object Names {
     def underlying: TermName = unsupported("underlying")
 
     @sharable // because of synchronized block in `and`
-    private var derivedNames: AnyRef /* SimpleMap | j.u.HashMap */ =
-      SimpleMap.Empty[NameInfo]
+    private var derivedNames: AnyRef /* immutable.Map[NameInfo, DerivedName] | j.u.HashMap */ =
+      immutable.Map.empty[NameInfo, DerivedName]
 
     private def getDerived(info: NameInfo): DerivedName /* | Null */= derivedNames match {
-      case derivedNames: SimpleMap[NameInfo, DerivedName] @unchecked =>
-        derivedNames(info)
+      case derivedNames: immutable.AbstractMap[NameInfo, DerivedName] @unchecked =>
+        if (derivedNames.contains(info)) derivedNames(info) else null
       case derivedNames: HashMap[NameInfo, DerivedName] @unchecked =>
         derivedNames.get(info)
     }
 
     private def putDerived(info: NameInfo, name: DerivedName): name.type = {
       derivedNames match {
-        case derivedNames: SimpleMap[NameInfo, DerivedName] @unchecked =>
+        case derivedNames: immutable.Map[NameInfo, DerivedName] @unchecked =>
           if (derivedNames.size < 4)
             this.derivedNames = derivedNames.updated(info, name)
           else {
             val newMap = new HashMap[NameInfo, DerivedName]
-            derivedNames.foreachBinding(newMap.put(_, _))
+            derivedNames.foreach { case (k, v) => newMap.put(k, v) }
             newMap.put(info, name)
             this.derivedNames = newMap
           }

compiler/src/dotty/tools/dotc/typer/ImportInfo.scala

@@ -6,7 +6,7 @@ import ast.{tpd, untpd}
 import ast.Trees._
 import core._
 import printing.{Printer, Showable}
-import util.SimpleMap
+import util.SimpleEqMap
 import Symbols._, Names._, Denotations._, Types._, Contexts._, StdNames._, Flags._
 import Decorators.StringInterpolators
 
@@ -52,7 +52,7 @@ class ImportInfo(symf: Context => Symbol, val selectors: List[untpd.Tree],
   def excluded: Set[TermName] = { ensureInitialized(); myExcluded }
 
   /** A mapping from renamed to original names */
-  def reverseMapping: SimpleMap[TermName, TermName] = { ensureInitialized(); myMapped }
+  def reverseMapping: SimpleEqMap[TermName, TermName] = { ensureInitialized(); myMapped }
 
   /** The original names imported by-name before renaming */
   def originals: Set[TermName] = { ensureInitialized(); myOriginals }
@@ -61,14 +61,14 @@ class ImportInfo(symf: Context => Symbol, val selectors: List[untpd.Tree],
   def isWildcardImport = { ensureInitialized(); myWildcardImport }
 
   private var myExcluded: Set[TermName] = null
-  private var myMapped: SimpleMap[TermName, TermName] = null
+  private var myMapped: SimpleEqMap[TermName, TermName] = null
   private var myOriginals: Set[TermName] = null
   private var myWildcardImport: Boolean = false
 
   /** Compute info relating to the selector list */
   private def ensureInitialized(): Unit = if (myExcluded == null) {
     myExcluded = Set()
-    myMapped = SimpleMap.Empty
+    myMapped = SimpleEqMap.Empty
     myOriginals = Set()
     def recur(sels: List[untpd.Tree]): Unit = sels match {
       case sel :: sels1 =>

compiler/src/dotty/tools/dotc/typer/Inferencing.scala

@@ -11,7 +11,7 @@ import Scopes._
 import ProtoTypes._
 import annotation.unchecked
 import util.Positions._
-import util.{Stats, SimpleMap}
+import util.{Stats, SimpleEqMap}
 import util.common._
 import Decorators._
 import Uniques._
@@ -286,7 +286,7 @@ object Inferencing {
     result
   }
 
-  type VarianceMap = SimpleMap[TypeVar, Integer]
+  type VarianceMap = SimpleEqMap[TypeVar, Integer]
 
   /** All occurrences of type vars in this type that satisfy predicate
    *  `include` mapped to their variances (-1/0/1) in this type, where
@@ -350,7 +350,7 @@ object Inferencing {
       if (vmap1 eq vmap) vmap else propagate(vmap1)
     }
 
-    propagate(accu(SimpleMap.Empty, tp))
+    propagate(accu(SimpleEqMap.Empty, tp))
   }
 }
 

compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala

@@ -11,7 +11,7 @@ import Constants._
 import Scopes._
 import annotation.unchecked
 import util.Positions._
-import util.{Stats, SimpleMap}
+import util.{Stats, SimpleEqMap}
 import util.common._
 import Decorators._
 import Uniques._
@@ -179,10 +179,10 @@ object ProtoTypes {
     override def resultType(implicit ctx: Context) = resType
 
     /** A map in which typed arguments can be stored to be later integrated in `typedArgs`. */
-    private var myTypedArg: SimpleMap[untpd.Tree, Tree] = SimpleMap.Empty
+    private var myTypedArg: SimpleEqMap[untpd.Tree, Tree] = SimpleEqMap.Empty
 
     /** A map recording the typer states in which arguments stored in myTypedArg were typed */
-    private var evalState: SimpleMap[untpd.Tree, TyperState] = SimpleMap.Empty
+    private var evalState: SimpleEqMap[untpd.Tree, TyperState] = SimpleEqMap.Empty
 
     def isMatchedBy(tp: Type)(implicit ctx: Context) =
       typer.isApplicable(tp, Nil, typedArgs, resultType)