Make util.WeakHashSet a subclass of util.MutableSet

Thus making it a drop-in replacement for util.HashSet which will be
useful in the next commit where we'll use it in Uniques.

Also add `@constructorOnly` annotations for clarity.

Also remove all existing references to WeakHashSet in the code base
since it turns out they were all dead code.

Author: smarter

compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala

@@ -13,7 +13,6 @@ import dotty.tools.dotc.core.Phases._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.transform.SymUtils._
-import dotty.tools.dotc.util.WeakHashSet
 
 /**
  * This class mainly contains the method classBTypeFromSymbol, which extracts the necessary
@@ -49,7 +48,6 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
     def newAnyRefMap[K <: AnyRef, V](): mutable.AnyRefMap[K, V] = new mutable.AnyRefMap[K, V]()
     def newWeakMap[K, V](): mutable.WeakHashMap[K, V] = new mutable.WeakHashMap[K, V]()
     def recordCache[T <: Clearable](cache: T): T = cache
-    def newWeakSet[K >: Null <: AnyRef](): WeakHashSet[K] = new WeakHashSet[K]()
     def newMap[K, V](): mutable.HashMap[K, V] = new mutable.HashMap[K, V]()
     def newSet[K](): mutable.Set[K] = new mutable.HashSet[K]
   }
@@ -60,7 +58,6 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
     def newWeakMap[K, V](): collection.mutable.WeakHashMap[K, V]
     def newMap[K, V](): collection.mutable.HashMap[K, V]
     def newSet[K](): collection.mutable.Set[K]
-    def newWeakSet[K >: Null <: AnyRef](): dotty.tools.dotc.util.WeakHashSet[K]
     def newAnyRefMap[K <: AnyRef, V](): collection.mutable.AnyRefMap[K, V]
   }
 

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -12,7 +12,6 @@ import scala.annotation.threadUnsafe
 import scala.collection.generic.Clearable
 import scala.collection.mutable
 import scala.reflect.ClassTag
-import dotty.tools.dotc.util.WeakHashSet
 import dotty.tools.io.AbstractFile
 import scala.tools.asm.AnnotationVisitor
 import dotty.tools.dotc.core._

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

@@ -8,7 +8,7 @@ abstract class MutableSet[T] extends ReadOnlySet[T]:
   def +=(x: T): Unit
 
   /** Like `+=` but return existing element equal to `x` of it exists,
-   *  `x` itself otherwose.
+   *  `x` itself otherwise.
    */
   def put(x: T): T
 

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

@@ -1,10 +1,10 @@
-/** Taken from the original implementation of WeakHashSet in scala-reflect
+/** Adapted from the original implementation of WeakHashSet in scala-reflect
  */
 package dotty.tools.dotc.util
 
 import java.lang.ref.{ReferenceQueue, WeakReference}
 
-import scala.annotation.tailrec
+import scala.annotation.{ constructorOnly, tailrec }
 import scala.collection.mutable
 
 /**
@@ -17,7 +17,7 @@ import scala.collection.mutable
  * This set implementation is not in general thread safe without external concurrency control. However it behaves
  * properly when GC concurrently collects elements in this set.
  */
-final class WeakHashSet[A <: AnyRef](initialCapacity: Int, loadFactor: Double) extends mutable.Set[A] {
+final class WeakHashSet[A <: AnyRef](initialCapacity: Int, loadFactor: Double) extends MutableSet[A] {
 
   import WeakHashSet._
 
@@ -61,8 +61,6 @@ final class WeakHashSet[A <: AnyRef](initialCapacity: Int, loadFactor: Double) e
 
   private def computeThreshold: Int = (table.size * loadFactor).ceil.toInt
 
-  def get(elem: A): Option[A] = Option(findEntry(elem))
-
   /**
    * find the bucket associated with an element's hash code
    */
@@ -86,6 +84,7 @@ final class WeakHashSet[A <: AnyRef](initialCapacity: Int, loadFactor: Double) e
    * remove a single entry from a linked list in a given bucket
    */
   private def remove(bucket: Int, prevEntry: Entry[A], entry: Entry[A]): Unit = {
+    Stats.record(statsItem("remove"))
     prevEntry match {
       case null => table(bucket) = entry.tail
       case _ => prevEntry.tail = entry.tail
@@ -122,6 +121,7 @@ final class WeakHashSet[A <: AnyRef](initialCapacity: Int, loadFactor: Double) e
    * Double the size of the internal table
    */
   private def resize(): Unit = {
+    Stats.record(statsItem("resize"))
     val oldTable = table
     table = new Array[Entry[A]](oldTable.size * 2)
     threshold = computeThreshold
@@ -145,12 +145,10 @@ final class WeakHashSet[A <: AnyRef](initialCapacity: Int, loadFactor: Double) e
     tableLoop(0)
   }
 
-  def contains(elem: A): Boolean = findEntry(elem) ne null
-
-  // from scala.reflect.internal.Set, find an element or null if it isn't contained
-  def findEntry(elem: A): A = elem match {
+  def lookup(elem: A): A | Null = elem match {
     case null => throw new NullPointerException("WeakHashSet cannot hold nulls")
     case _    =>
+      Stats.record(statsItem("lookup"))
       removeStaleEntries()
       val hash = elem.hashCode
       val bucket = bucketFor(hash)
@@ -166,10 +164,11 @@ final class WeakHashSet[A <: AnyRef](initialCapacity: Int, loadFactor: Double) e
 
       linkedListLoop(table(bucket))
   }
-  // add an element to this set unless it's already in there and return the element
-  def findEntryOrUpdate(elem: A): A = elem match {
+
+  def put(elem: A): A = elem match {
     case null => throw new NullPointerException("WeakHashSet cannot hold nulls")
     case _    =>
+      Stats.record(statsItem("put"))
       removeStaleEntries()
       val hash = elem.hashCode
       val bucket = bucketFor(hash)
@@ -194,36 +193,12 @@ final class WeakHashSet[A <: AnyRef](initialCapacity: Int, loadFactor: Double) e
       linkedListLoop(oldHead)
   }
 
-  // add an element to this set unless it's already in there and return this set
-  override def addOne(elem: A): this.type = elem match {
-    case null => throw new NullPointerException("WeakHashSet cannot hold nulls")
-    case _    =>
-      removeStaleEntries()
-      val hash = elem.hashCode
-      val bucket = bucketFor(hash)
-      val oldHead = table(bucket)
-
-      def add(): Unit = {
-        table(bucket) = new Entry(elem, hash, oldHead, queue)
-        count += 1
-        if (count > threshold) resize()
-      }
-
-      @tailrec
-      def linkedListLoop(entry: Entry[A]): Unit = entry match {
-        case null                        => add()
-        case _ if elem.equals(entry.get) => ()
-        case _                           => linkedListLoop(entry.tail)
-      }
+  def +=(elem: A): Unit = put(elem)
 
-      linkedListLoop(oldHead)
-      this
-  }
-
-  // remove an element from this set and return this set
-  override def subtractOne(elem: A): this.type = elem match {
-    case null => this
+  def -=(elem: A): Unit = elem match {
+    case null =>
     case _ =>
+      Stats.record(statsItem("-="))
       removeStaleEntries()
       val bucket = bucketFor(elem.hashCode)
 
@@ -237,11 +212,9 @@ final class WeakHashSet[A <: AnyRef](initialCapacity: Int, loadFactor: Double) e
       }
 
       linkedListLoop(null, table(bucket))
-      this
   }
 
-  // empty this set
-  override def clear(): Unit = {
+  def clear(): Unit = {
     table = new Array[Entry[A]](table.size)
     threshold = computeThreshold
     count = 0
@@ -251,21 +224,11 @@ final class WeakHashSet[A <: AnyRef](initialCapacity: Int, loadFactor: Double) e
     queueLoop()
   }
 
-  // true if this set is empty
-  override def empty: This = new WeakHashSet[A](initialCapacity, loadFactor)
-
-  // the number of elements in this set
-  override def size: Int = {
+  def size: Int = {
     removeStaleEntries()
     count
   }
 
-  override def isEmpty: Boolean = size == 0
-  override def foreach[U](f: A => U): Unit = iterator foreach f
-
-  // It has the `()` because iterator runs `removeStaleEntries()`
-  override def toList(): List[A] = iterator.toList
-
   // Iterator over all the elements in this set in no particular order
   override def iterator: Iterator[A] = {
     removeStaleEntries()
@@ -318,6 +281,12 @@ final class WeakHashSet[A <: AnyRef](initialCapacity: Int, loadFactor: Double) e
     }
   }
 
+  protected def statsItem(op: String): String = {
+    val prefix = "WeakHashSet."
+    val suffix = getClass.getSimpleName
+    s"$prefix$op $suffix"
+  }
+
   /**
    * Diagnostic information about the internals of this set. Not normally
    * needed by ordinary code, but may be useful for diagnosing performance problems
@@ -386,7 +355,7 @@ object WeakHashSet {
    * A single entry in a WeakHashSet. It's a WeakReference plus a cached hash code and
    * a link to the next Entry in the same bucket
    */
-  private class Entry[A](element: A, val hash:Int, var tail: Entry[A], queue: ReferenceQueue[A]) extends WeakReference[A](element, queue)
+  private class Entry[A](@constructorOnly element: A, val hash:Int, var tail: Entry[A], @constructorOnly queue: ReferenceQueue[A]) extends WeakReference[A](element, queue)
 
   private final val defaultInitialCapacity = 16
   private final val defaultLoadFactor = .75