Make util.WeakHashSet a subclass of util.MutableSet

Thus making it a drop-in replacement for util.HashSet.

Also add `@constructorOnly` annotations for clarity.

Author: smarter

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
    */
@@ -145,10 +143,7 @@ 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 _    =>
       removeStaleEntries()
@@ -160,14 +155,14 @@ final class WeakHashSet[A <: AnyRef](initialCapacity: Int, loadFactor: Double) e
         case null                    => null.asInstanceOf[A]
         case _                       =>
           val entryElem = entry.get
-          if (elem.equals(entryElem)) entryElem
+          if (isEqual(elem, entryElem)) entryElem
           else linkedListLoop(entry.tail)
       }
 
       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 _    =>
       removeStaleEntries()
@@ -187,42 +182,17 @@ final class WeakHashSet[A <: AnyRef](initialCapacity: Int, loadFactor: Double) e
         case null                    => add()
         case _                       =>
           val entryElem = entry.get
-          if (elem.equals(entryElem)) entryElem
+          if (isEqual(elem, entryElem)) entryElem
           else linkedListLoop(entry.tail)
       }
 
       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)
-      }
-
-      linkedListLoop(oldHead)
-      this
-  }
+  def +=(elem: A): Unit = put(elem)
 
-  // 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 _ =>
       removeStaleEntries()
       val bucket = bucketFor(elem.hashCode)
@@ -232,16 +202,14 @@ final class WeakHashSet[A <: AnyRef](initialCapacity: Int, loadFactor: Double) e
       @tailrec
       def linkedListLoop(prevEntry: Entry[A], entry: Entry[A]): Unit = entry match {
         case null => ()
-        case _ if elem.equals(entry.get) => remove(bucket, prevEntry, entry)
+        case _ if isEqual(elem, entry.get) => remove(bucket, prevEntry, entry)
         case _ => linkedListLoop(entry, entry.tail)
       }
 
       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 +219,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()
@@ -386,7 +344,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