Use LinkedHashMaps and LinkedHashSets everywhere.

Author: DarkDimius

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

@@ -33,7 +33,7 @@ import scala.tools.nsc.backend.jvm.opt.LocalOpt
 
 class GenBCode extends Phase {
   def phaseName: String = "genBCode"
-  private val entryPoints = new mutable.HashSet[Symbol]()
+  private val entryPoints = new mutable.LinkedHashSet[Symbol]()
   def registerEntryPoint(sym: Symbol) = entryPoints += sym
 
 

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

@@ -80,7 +80,7 @@ class LabelDefs extends MiniPhaseTransform {
   def phaseName: String = "labelDef"
 
   val queue = new ArrayBuffer[Tree]()
-  val beingAppended = new mutable.HashSet[Symbol]()
+  val beingAppended = new mutable.LinkedHashSet[Symbol]()
   var labelLevel = 0
 
   override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
@@ -95,7 +95,7 @@ class LabelDefs extends MiniPhaseTransform {
 
       // make sure that for every label there's a single location it should return and single entry point
       // if theres already a location that it returns to that's a failure
-      val disallowed = new mutable.HashMap[Symbol, Tree]()
+      val disallowed = new mutable.LinkedHashMap[Symbol, Tree]()
       queue.sizeHint(labelCalls.size + entryPoints.size)
 
       def putLabelDefsNearCallees = new TreeMap() {
@@ -118,7 +118,7 @@ class LabelDefs extends MiniPhaseTransform {
       def moveLabels(entryPoint: Apply): List[Tree] = {
         val entrySym = entryPoint.symbol
         if ((entrySym is Flags.Label) && labelDefs.contains(entrySym)) {
-          val visitedNow = new mutable.HashMap[Symbol, Tree]()
+          val visitedNow = new mutable.LinkedHashMap[Symbol, Tree]()
           val treesToAppend = new ArrayBuffer[Tree]() // order matters. parents should go first
           treesToAppend += labelDefs(entrySym)
           queue.clear()
@@ -167,15 +167,15 @@ class LabelDefs extends MiniPhaseTransform {
   object collectLabelDefs extends TreeMap() {
 
     // label calls from this DefDef
-    var parentLabelCalls: mutable.Set[Tree] = new mutable.HashSet[Tree]()
-    var callCounts: mutable.Map[Symbol, Int] = new mutable.HashMap[Symbol, Int]().withDefaultValue(0)
+    var parentLabelCalls: mutable.Set[Tree] = new mutable.LinkedHashSet[Tree]()
+    var callCounts: mutable.Map[Symbol, Int] = new mutable.LinkedHashMap[Symbol, Int]().withDefaultValue(0)
 
     def shouldMoveLabel = true
 
     // labelSymbol -> Defining tree
-    val labelDefs = new mutable.HashMap[Symbol, Tree]()
+    val labelDefs = new mutable.LinkedHashMap[Symbol, Tree]()
     // owner -> all calls by this owner
-    val labelCalls = new mutable.HashMap[Symbol, mutable.Set[Tree]]()
+    val labelCalls = new mutable.LinkedHashMap[Symbol, mutable.Set[Tree]]()
     var owner: Symbol = null
 
     def clear = {
@@ -196,7 +196,7 @@ class LabelDefs extends MiniPhaseTransform {
         assert(t.symbol is Flags.Label)
 
         val st = parentLabelCalls
-        parentLabelCalls = new mutable.HashSet[Tree]()
+        parentLabelCalls = new mutable.LinkedHashSet[Tree]()
         val symt = owner
         owner = t.symbol
 

src/dotty/tools/dotc/core/Contexts.scala

@@ -583,7 +583,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 = new mutable.HashSet[Type]
+    private[core] val pendingUnderlying = new mutable.LinkedHashSet[Type]
 
 
     private[core] var phasesPlan: List[List[Phase]] = _

src/dotty/tools/dotc/core/SymDenotations.scala

@@ -1294,7 +1294,7 @@ object SymDenotations {
     /** Invalidate baseTypeRefCache, baseClasses and superClassBits on new run */
     private def checkBasesUpToDate()(implicit ctx: Context) =
       if (baseTypeRefValid != ctx.runId) {
-        baseTypeRefCache = new java.util.HashMap[CachedType, Type]
+        baseTypeRefCache = new java.util.LinkedHashMap[CachedType, Type]
         myBaseClasses = null
         mySuperClassBits = null
         baseTypeRefValid = ctx.runId
@@ -1538,7 +1538,7 @@ object SymDenotations {
       raw.filterExcluded(excluded).asSeenFrom(pre).toDenot(pre)
     }
 
-    private[this] var baseTypeRefCache: java.util.HashMap[CachedType, Type] = null
+    private[this] var baseTypeRefCache: java.util.LinkedHashMap[CachedType, Type] = null
     private[this] var baseTypeRefValid: RunId = NoRunId
 
     /** Compute tp.baseTypeRef(this) */

src/dotty/tools/dotc/core/TypeComparer.scala

@@ -120,7 +120,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
 
   private def monitoredIsSubType(tp1: Type, tp2: Type) = {
     if (pendingSubTypes == null) {
-      pendingSubTypes = new mutable.HashSet[(Type, Type)]
+      pendingSubTypes = new mutable.LinkedHashSet[(Type, Type)]
       ctx.log(s"!!! deep subtype recursion involving ${tp1.show} <:< ${tp2.show}, constraint = ${state.constraint.show}")
       ctx.log(s"!!! constraint = ${constraint.show}")
       if (ctx.settings.YnoDeepSubtypes.value) throw new Error("deep subtype")

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

@@ -762,7 +762,7 @@ class ClassfileParser(
       originalName + " in " + outerName + "(" + externalName + ")"
   }
 
-  object innerClasses extends scala.collection.mutable.HashMap[Name, InnerClassEntry] {
+  object innerClasses extends scala.collection.mutable.LinkedHashMap[Name, InnerClassEntry] {
     /** Return the Symbol of the top level class enclosing `name`,
      *  or 'name's symbol if no entry found for `name`.
      */

src/dotty/tools/dotc/core/tasty/PositionUnpickler.scala

@@ -9,7 +9,7 @@ import collection.mutable
 import TastyBuffer.Addr
 
 object PositionUnpickler {
-  type AddrToPosition = mutable.HashMap[Addr, Position]
+  type AddrToPosition = mutable.LinkedHashMap[Addr, Position]
 }
 
 /** Unpickler for tree positions */
@@ -18,7 +18,7 @@ class PositionUnpickler(reader: TastyReader) {
   import reader._
 
   def unpickle(): (Position, AddrToPosition) = {
-    val positions = new mutable.HashMap[Addr, Position] // Dotty deviation: Can't use new AddrToPosition here. TODO: fix this!
+    val positions = new mutable.LinkedHashMap[Addr, Position] // Dotty deviation: Can't use new AddrToPosition here. TODO: fix this!
     val sourceLength = readNat()
     def readDelta() = if (isAtEnd) 0 else readInt()
     var curIndex: Addr = Addr(readDelta())

src/dotty/tools/dotc/core/tasty/TastyUnpickler.scala

@@ -22,7 +22,7 @@ class TastyUnpickler(reader: TastyReader) {
 
   def this(bytes: Array[Byte]) = this(new TastyReader(bytes))
 
-  private val sectionReader = new mutable.HashMap[String, TastyReader]
+  private val sectionReader = new mutable.LinkedHashMap[String, TastyReader]
   val tastyName = new TastyName.Table
 
   def check(cond: Boolean, msg: => String) =

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

@@ -17,8 +17,8 @@ class TreePickler(pickler: TastyPickler) {
   import pickler.nameBuffer.{nameIndex, fullNameIndex}
   import ast.tpd._
 
-  private val symRefs = new mutable.HashMap[Symbol, Addr]
-  private val forwardSymRefs = new mutable.HashMap[Symbol, List[Addr]]
+  private val symRefs = new mutable.LinkedHashMap[Symbol, Addr]
+  private val forwardSymRefs = new mutable.LinkedHashMap[Symbol, 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) = {

src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -40,9 +40,9 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
     this.positions = positions
   }
 
-  private val symAtAddr  = new mutable.HashMap[Addr, Symbol]
-  private val treeAtAddr = new mutable.HashMap[Addr, Tree]
-  private val typeAtAddr = new mutable.HashMap[Addr, Type] // currently populated only for types that are known to be SHAREd.
+  private val symAtAddr  = new mutable.LinkedHashMap[Addr, Symbol]
+  private val treeAtAddr = new mutable.LinkedHashMap[Addr, Tree]
+  private val typeAtAddr = new mutable.LinkedHashMap[Addr, Type] // currently populated only for types that are known to be SHAREd.
   private var stubs: Set[Symbol] = Set()
 
   private var roots: Set[SymDenotation] = null

src/dotty/tools/dotc/printing/Disambiguation.scala

@@ -10,8 +10,8 @@ object Disambiguation {
 
   private class State {
     var hasConflicts = false
-    val symString = new mutable.HashMap[Symbol, String]
-    val variants = new mutable.HashMap[String, mutable.ListBuffer[Symbol]]
+    val symString = new mutable.LinkedHashMap[Symbol, String]
+    val variants = new mutable.LinkedHashMap[String, mutable.ListBuffer[Symbol]]
   }
 
   def newPrinter: Context => Printer = {

src/dotty/tools/dotc/reporting/Reporter.scala

@@ -224,7 +224,7 @@ abstract class Reporter {
    */
   def errorsReported = hasErrors
 
-  val unreportedWarnings = new mutable.HashMap[String, Int] {
+  val unreportedWarnings = new mutable.LinkedHashMap[String, Int] {
     override def default(key: String) = 0
   }
 

src/dotty/tools/dotc/reporting/UniqueMessagePositions.scala

@@ -13,7 +13,7 @@ import core.Contexts.Context
  */
 trait UniqueMessagePositions extends Reporter {
 
-  private val positions = new mutable.HashMap[(SourceFile, Int), Int]
+  private val positions = new mutable.LinkedHashMap[(SourceFile, Int), Int]
 
   /** Logs a position and returns true if it was already logged.
    *  @note  Two positions are considered identical for logging if they have the same point.

src/dotty/tools/dotc/transform/CapturedVars.scala

@@ -49,7 +49,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisTransfo
     }
 
     private class CollectCaptured(implicit ctx: Context) extends EnclosingMethodTraverser {
-      private val captured = mutable.HashSet[Symbol]()
+      private val captured = mutable.LinkedHashSet[Symbol]()
       def traverse(enclMeth: Symbol, tree: Tree)(implicit ctx: Context) = tree match {
         case id: Ident =>
           val sym = id.symbol

src/dotty/tools/dotc/transform/LambdaLift.scala

@@ -61,17 +61,17 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisTransform
     private val called = new LinkedHashMap[Symbol, SymSet]
 
     /** Symbols that are called from an inner class. */
-    private val calledFromInner = new HashSet[Symbol]
+    private val calledFromInner = new LinkedHashSet[Symbol]
 
     /** A map from local methods and classes to the owners to which they will be lifted as members.
      *  For methods and classes that do not have any dependencies this will be the enclosing package.
      *  symbols with packages as lifted owners will subsequently represented as static
      *  members of their toplevel class, unless their enclosing class was already static.
      */
-    private val liftedOwner = new HashMap[Symbol, Symbol]
+    private val liftedOwner = new mutable.LinkedHashMap[Symbol, Symbol]
 
     /** Buffers for lifted out classes and methods, indexed by owner */
-    private val liftedDefs = new HashMap[Symbol, mutable.ListBuffer[Tree]]
+    private val liftedDefs = new mutable.LinkedHashMap[Symbol, mutable.ListBuffer[Tree]]
 
     /** A flag to indicate whether new free variables have been found */
     private var changedFreeVars: Boolean = _

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

@@ -64,7 +64,7 @@ object OverridingPairs {
     }
 
     private val subParents = {
-      val subParents = new mutable.HashMap[Symbol, BitSet]
+      val subParents = new mutable.LinkedHashMap[Symbol, BitSet]
       for (bc <- base.info.baseClasses)
         subParents(bc) = BitSet(parents.indices.filter(parents(_).derivesFrom(bc)): _*)
       subParents
@@ -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 = new mutable.LinkedHashSet[Symbol]
 
     /** The current entry candidate for overriding
      */

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

@@ -465,7 +465,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
         if (!emitVars) in
         else {
           // binders in `subPatBindersStored` that are referenced by tree `in`
-          val usedBinders = new collection.mutable.HashSet[Symbol]()
+          val usedBinders = new collection.mutable.LinkedHashSet[Symbol]()
           // all potentially stored subpat binders
           val potentiallyStoredBinders = stored.unzip._1.toSet
           // compute intersection of all symbols in the tree `in` and all potentially stored subpat binders

src/dotty/tools/dotc/transform/Pickler.scala

@@ -26,7 +26,7 @@ class Pickler extends Phase {
     s.close
   }
 
-  private val beforePickling = new mutable.HashMap[ClassSymbol, String]
+  private val beforePickling = new mutable.LinkedHashMap[ClassSymbol, String]
 
   /** Drop any elements of this list that are linked module classes of other elements in the list */
   private def dropCompanionModuleClasses(clss: List[ClassSymbol])(implicit ctx: Context): List[ClassSymbol] = {

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

@@ -41,8 +41,8 @@ class TreeChecker extends Phase with SymTransformer {
   import ast.tpd._
 
 
-  private val seenClasses = collection.mutable.HashMap[String, Symbol]()
-  private val seenModuleVals = collection.mutable.HashMap[String, Symbol]()
+  private val seenClasses = collection.mutable.LinkedHashMap[String, Symbol]()
+  private val seenModuleVals = collection.mutable.LinkedHashMap[String, Symbol]()
 
   def isValidJVMName(name: Name) =
       !name.exists(c => c == '.' || c == ';' || c =='[' || c == '/')
@@ -135,8 +135,8 @@ class TreeChecker extends Phase with SymTransformer {
 
   class Checker(phasesToCheck: Seq[Phase]) extends ReTyper {
 
-    val nowDefinedSyms = new mutable.HashSet[Symbol]
-    val everDefinedSyms = new mutable.HashMap[Symbol, Tree]
+    val nowDefinedSyms = new mutable.LinkedHashSet[Symbol]
+    val everDefinedSyms = new mutable.LinkedHashMap[Symbol, Tree]
 
     def withDefinedSym[T](tree: untpd.Tree)(op: => T)(implicit ctx: Context): T = tree match {
       case tree: DefTree =>

src/dotty/tools/dotc/typer/Checking.scala

@@ -349,7 +349,7 @@ trait Checking {
 
   /** Check that class does not define same symbol twice */
   def checkNoDoubleDefs(cls: Symbol)(implicit ctx: Context): Unit = {
-    val seen = new mutable.HashMap[Name, List[Symbol]] {
+    val seen = new mutable.LinkedHashMap[Name, List[Symbol]] {
       override def default(key: Name) = Nil
     }
     typr.println(i"check no double defs $cls")

src/dotty/tools/dotc/typer/Implicits.scala

@@ -367,7 +367,7 @@ trait ImplicitRunInfo { self: RunInfo =>
   }
 
   /** A map that counts the number of times an implicit ref was picked */
-  val useCount = new mutable.HashMap[TermRef, Int] {
+  val useCount = new mutable.LinkedHashMap[TermRef, Int] {
     override def default(key: TermRef) = 0
   }
 

src/dotty/tools/dotc/util/Stats.scala

@@ -14,7 +14,7 @@ import collection.mutable
 
   @volatile private var stack: List[String] = Nil
 
-  val hits = new mutable.HashMap[String, Int] {
+  val hits = new mutable.LinkedHashMap[String, Int] {
     override def default(key: String): Int = 0
   }