Make util.Set and util.HashSet more usable

Add size and -= methods. Rename addEntry to +=. Rename findEntry to lookup.

# Conflicts:
#	compiler/src/dotty/tools/dotc/util/HashSet.scala

Author: odersky

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

@@ -187,7 +187,7 @@ object TypeOps:
     /** a faster version of cs1 intersect cs2 */
     def intersect(cs1: List[ClassSymbol], cs2: List[ClassSymbol]): List[ClassSymbol] = {
       val cs2AsSet = new util.HashSet[ClassSymbol](128)
-      cs2.foreach(cs2AsSet.addEntry)
+      cs2.foreach(cs2AsSet +=)
       cs1.filter(cs2AsSet.contains)
     }
 

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

@@ -5540,7 +5540,7 @@ object Types {
     def apply(x: mutable.Set[NamedType], tp: Type): mutable.Set[NamedType] =
       if (seen contains tp) x
       else {
-        seen.addEntry(tp)
+        seen += tp
         tp match {
           case tp: TypeRef =>
             foldOver(maybeAdd(x, tp), tp)

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

@@ -534,7 +534,7 @@ trait ImplicitRunInfo:
         if partSeen.contains(t) then ()
         else if implicitScopeCache.contains(t) then parts += t
         else
-          partSeen.addEntry(t)
+          partSeen += t
           t.dealias match
             case t: TypeRef =>
               if isAnchor(t.symbol) then
@@ -578,12 +578,12 @@ trait ImplicitRunInfo:
             is.companionRefs
           case None =>
             if seen.contains(t) then
-              incomplete.addEntry(tp) // all references for `t` will be accounted for in `seen` so we return `EmptySet`.
+              incomplete += tp // all references for `t` will be accounted for in `seen` so we return `EmptySet`.
               TermRefSet.empty        // on the other hand, the refs of `tp` are now inaccurate, so `tp` is marked incomplete.
             else
-              seen.addEntry(t)
+              seen += t
               val is = recur(t)
-              if !implicitScopeCache.contains(t) then incomplete.addEntry(tp)
+              if !implicitScopeCache.contains(t) then incomplete += tp
               is.companionRefs
       end iscopeRefs
 
@@ -693,7 +693,7 @@ trait ImplicitRunInfo:
             if seen.contains(t) then
               WildcardType
             else
-              seen.addEntry(t)
+              seen += t
               t.underlying match
                 case TypeBounds(lo, hi) =>
                   if defn.isBottomTypeAfterErasure(lo) then apply(hi)

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

@@ -651,11 +651,11 @@ object RefChecks {
         val seenClasses = new util.HashSet[Symbol](256)
         def addDecls(cls: Symbol): Unit =
           if (!seenClasses.contains(cls)) {
-            seenClasses.addEntry(cls)
+            seenClasses += cls
             for (mbr <- cls.info.decls)
               if (mbr.isTerm && !mbr.isOneOf(Synthetic | Bridge) && mbr.memberCanMatchInheritedSymbols &&
                   !membersToCheck.contains(mbr.name))
-                membersToCheck.addEntry(mbr.name)
+                membersToCheck += mbr.name
             cls.info.parents.map(_.classSymbol)
               .filter(_.isOneOf(AbstractOrTrait))
               .dropWhile(_.isOneOf(JavaDefined | Scala2x))

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

@@ -1,13 +1,29 @@
 package dotty.tools.dotc.util
 
 /** A hash set that allows some privileged protected access to its internals
+ *  @param  initialCapacity  Indicates the initial number of slots in the hash table.
+ *                           The actual number of slots is always a power of 2, so the
+ *                           initial size of the table will be the smallest power of two
+ *                           that is equal or greater than the given `initialCapacity`.
+ *  @param  loadFactor       The maximum fraction of used elements relative to capacity.
+ *                           The hash table will be re-sized once the number of elements exceeds
+ *                           the current size of the hash table multiplied by loadFactor.
+ *  With the defaults given, the first resize of the table happens once the number of elements
+ *  grows beyond 16.
  */
-class HashSet[T >: Null <: AnyRef](powerOfTwoInitialCapacity: Int = 16, loadFactor: Float = 0.25f) extends MutableSet[T] {
+class HashSet[T >: Null <: AnyRef](initialCapacity: Int = 16, loadFactor: Float = 0.25f) extends MutableSet[T] {
   private var used: Int = _
   private var limit: Int = _
   private var table: Array[AnyRef] = _
 
-  assert(Integer.bitCount(powerOfTwoInitialCapacity) == 1)
+  private def roundToPower(n: Int) =
+    if Integer.bitCount(n) == 1 then n
+    else
+      def recur(n: Int): Int =
+        if n == 1 then 2
+        else recur(n >>> 1) << 1
+      recur(n)
+
   protected def isEqual(x: T, y: T): Boolean = x.equals(y)
 
   // Counters for Stats
@@ -27,7 +43,7 @@ class HashSet[T >: Null <: AnyRef](powerOfTwoInitialCapacity: Int = 16, loadFact
   /** Remove all elements from this set and set back to initial configuration */
   def clear(): Unit = {
     used = 0
-    allocate(powerOfTwoInitialCapacity)
+    allocate(roundToPower(initialCapacity))
   }
 
   /** Turn hashcode `x` into a table index */
@@ -36,7 +52,7 @@ class HashSet[T >: Null <: AnyRef](powerOfTwoInitialCapacity: Int = 16, loadFact
   /** Hashcode, can be overridden */
   def hash(x: T): Int = x.hashCode
 
-  private def entryAt(idx: Int) = table.apply(idx).asInstanceOf[T]
+  private def entryAt(idx: Int) = table(idx).asInstanceOf[T]
 
   /** Find entry such that `isEqual(x, entry)`. If it exists, return it.
    *  If not, enter `x` in set and return `x`.
@@ -63,7 +79,7 @@ class HashSet[T >: Null <: AnyRef](powerOfTwoInitialCapacity: Int = 16, loadFact
   }
 
   /** The entry in the set such that `isEqual(x, entry)`, or else `null`. */
-  def findEntry(x: T): T = {
+  def lookup(x: T): T = {
     if (Stats.enabled) accesses += 1
     var h = index(hash(x))
     var entry = entryAt(h)
@@ -77,38 +93,6 @@ class HashSet[T >: Null <: AnyRef](powerOfTwoInitialCapacity: Int = 16, loadFact
 
   private var rover: Int = -1
 
-  /** Add entry `x` to set */
-  def addEntry(x: T): Unit = {
-    if (Stats.enabled) accesses += 1
-    var h = index(hash(x))
-    var entry = entryAt(h)
-    while (entry ne null) {
-      if (isEqual(x, entry)) return
-      if (Stats.enabled) misses += 1
-      h = index(h + 1)
-      entry = entryAt(h)
-    }
-    table(h) = x
-    used += 1
-    if (used > (table.length >> 2)) growTable()
-  }
-
-  /** Add all entries in `xs` to set */
-  def addEntries(xs: TraversableOnce[T]): Unit =
-    xs.iterator foreach addEntry
-
-  /** The iterator of all elements in the set */
-  def iterator: Iterator[T] = new Iterator[T] {
-    private var i = 0
-    def hasNext: Boolean = {
-      while (i < table.length && (table(i) eq null)) i += 1
-      i < table.length
-    }
-    def next(): T =
-      if (hasNext) { i += 1; table(i - 1).asInstanceOf[T] }
-      else null
-  }
-
   /** Privileged access: Find first entry with given hashcode */
   protected def findEntryByHash(hashCode: Int): T = {
     rover = index(hashCode)
@@ -158,5 +142,58 @@ class HashSet[T >: Null <: AnyRef](powerOfTwoInitialCapacity: Int = 16, loadFact
     }
   }
 
+  /** Add entry `x` to set */
+  def += (x: T): Unit = {
+    if (Stats.enabled) accesses += 1
+    var h = index(hash(x))
+    var entry = entryAt(h)
+    while (entry ne null) {
+      if (isEqual(x, entry)) return
+      if (Stats.enabled) misses += 1
+      h = index(h + 1)
+      entry = entryAt(h)
+    }
+    table(h) = x
+    used += 1
+    if (used > (table.length >> 2)) growTable()
+  }
+
+  def -= (x: T): Unit =
+    if (Stats.enabled) accesses += 1
+    var h = index(hash(x))
+    var entry = entryAt(h)
+    while entry != null do
+      if isEqual(x, entry) then
+        var hole = h
+        while
+          h = index(h + 1)
+          entry = entryAt(h)
+          entry != null && index(hash(entry)) != h
+        do
+          table(hole) = entry
+          hole = h
+        table(hole) = null
+        used -= 1
+        return
+      h = index(h + 1)
+      entry = entryAt(h)
+  end -=
+
+  /** Add all entries in `xs` to set */
+  def ++= (xs: IterableOnce[T]): Unit =
+    xs.iterator.foreach(this += _)
+
+  /** The iterator of all elements in the set */
+  def iterator: Iterator[T] = new Iterator[T] {
+    private var i = 0
+    def hasNext: Boolean = {
+      while (i < table.length && (table(i) eq null)) i += 1
+      i < table.length
+    }
+    def next(): T =
+      if (hasNext) { i += 1; table(i - 1).asInstanceOf[T] }
+      else null
+  }
+
   override def toString(): String = "HashSet(%d / %d)".format(used, table.length)
 }

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

@@ -4,20 +4,21 @@ package dotty.tools.dotc.util
  */
 abstract class MutableSet[T >: Null] {
 
-  def findEntry(x: T): T
+  /** The entry in the set such that `isEqual(x, entry)`, or else `null`. */
+  def lookup(x: T): T /* | Null */
 
-  def addEntry(x: T): Unit
+  def +=(x: T): Unit
 
-  def iterator: Iterator[T]
+  def clear(): Unit
 
-  def foreach[U](f: T => U): Unit = iterator foreach f
+  def size: Int
 
-  def apply(x: T): Boolean = contains(x)
+  def iterator: Iterator[T]
 
-  def contains(x: T): Boolean =
-    findEntry(x) != null
+  def contains(x: T): Boolean = lookup(x) != null
+
+  def foreach[U](f: T => U): Unit = iterator foreach f
 
   def toList: List[T] = iterator.toList
 
-  def clear(): Unit
 }