Optimize util.HashSet

Using "%" to find the index of an entry in the backing array is
expensive, by restricting our backing array size to be a power of two we
can use "&" instead. This is similar to what we do in the implementation
of MutableScope (note: should we try to avoid code duplication between
util.HashSet and MutableScope?).

Author: smarter

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -147,8 +147,10 @@ object Config {
   /** Initial size of superId table */
   final val InitialSuperIdsSize = 4096
 
-  /** Initial capacity of uniques HashMap */
-  final val initialUniquesCapacity = 40000
+  /** Initial capacity of uniques HashMap.
+   *  Note: This MUST BE a power of two to work with util.HashSet
+   */
+  final val initialUniquesCapacity = 65536
 
   /** How many recursive calls to NamedType#underlying are performed before logging starts. */
   final val LogPendingUnderlyingThreshold = 50

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

@@ -131,7 +131,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
 
     /** a faster version of cs1 intersect cs2 */
     def intersect(cs1: List[ClassSymbol], cs2: List[ClassSymbol]): List[ClassSymbol] = {
-      val cs2AsSet = new util.HashSet[ClassSymbol](100)
+      val cs2AsSet = new util.HashSet[ClassSymbol](128)
       cs2.foreach(cs2AsSet.addEntry)
       cs1.filter(cs2AsSet.contains)
     }

compiler/src/dotty/tools/dotc/util/HashSet.scala

@@ -2,7 +2,7 @@ package dotty.tools.dotc.util
 
 /** A hash set that allows some privileged protected access to its internals
  */
-class HashSet[T >: Null <: AnyRef](initialCapacity: Int, loadFactor: Float = 0.25f) extends Set[T] {
+class HashSet[T >: Null <: AnyRef](powerOfTwoInitialCapacity: Int, loadFactor: Float = 0.25f) extends Set[T] {
   private var used: Int = _
   private var limit: Int = _
   private var table: Array[AnyRef] = _
@@ -20,11 +20,11 @@ class HashSet[T >: Null <: AnyRef](initialCapacity: Int, loadFactor: Float = 0.2
   /** Remove all elements from this set and set back to initial configuration */
   def clear(): Unit = {
     used = 0
-    allocate(initialCapacity)
+    allocate(powerOfTwoInitialCapacity)
   }
 
-  /** Turn hashode `x` into a table index */
-  private def index(x: Int): Int = math.abs(x % table.length)
+  /** Turn hashcode `x` into a table index */
+  private def index(x: Int): Int = x & (table.length - 1)
 
   /** Hashcode, can be overridden */
   def hash(x: T): Int = x.hashCode