I'm wandering around trunk looking for slowness.

are constant distractions which I've meant forever to fix anyway, such
as the importing of collection.mutable._ (or any other package with lots
of reused names.) Why is this relevant to performance? Well,

  var x = new HashSet[Int]

What's that? What does 'x += 1' mean? These are questions we can all
live without.

There's almost nothing left which references HashSet or HashMap or Stack
or other ambiguous classes without a qualifier: I can finish trunk but
I can't keep it clean on my own. (Where should I be writing this stuff
down, I wonder.) No review.

1 files changed, 4 insertions, 5 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/ReachingDefinitions.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/ReachingDefinitions.scala
index d7e5e84a80..c18408ddbd 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/analysis/ReachingDefinitions.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/analysis/ReachingDefinitions.scala
@@ -10,7 +10,6 @@ package analysis
 
 import scala.collection.{ mutable, immutable }
 import immutable.ListSet
-import mutable.HashMap
 
 /** Compute reaching definitions. We are only interested in reaching
  *  definitions for local variables, since values on the stack
@@ -69,10 +68,10 @@ abstract class ReachingDefinitions {
 
     var method: IMethod = _
 
-    val gen: mutable.Map[BasicBlock, Set[Definition]] = new HashMap()
-    val kill: mutable.Map[BasicBlock, Set[Local]]     = new HashMap()
-    val drops: mutable.Map[BasicBlock, Int]           = new HashMap()
-    val outStack: mutable.Map[BasicBlock, Stack]      = new HashMap()
+    val gen: mutable.Map[BasicBlock, Set[Definition]] = new mutable.HashMap()
+    val kill: mutable.Map[BasicBlock, Set[Local]]     = new mutable.HashMap()
+    val drops: mutable.Map[BasicBlock, Int]           = new mutable.HashMap()
+    val outStack: mutable.Map[BasicBlock, Stack]      = new mutable.HashMap()
 
     def init(m: IMethod) {
       this.method = m