Merge pull request scala/scala#8583 from rorygraves/mike/2.12.x/quickHashSetEquals

faster equals for HashSet

Author: szeiger

library/src/scala/collection/immutable/HashSet.scala

@@ -14,6 +14,8 @@ package scala
 package collection
 package immutable
 
+import java.util
+
 import generic._
 import scala.collection.parallel.immutable.ParHashSet
 import scala.collection.GenSet
@@ -260,12 +262,21 @@ object HashSet extends ImmutableSetFactory[HashSet] {
     override protected def get0(key: A, hash: Int, level: Int): Boolean =
       (hash == this.hash && key == this.key)
 
+    override def equals(other: Any): Boolean = {
+      other match {
+        case that: HashSet1[A] =>
+          (this eq that) || (this.hash == that.hash && this.key == that.key)
+        case _ : HashSet[_] => false
+        case _ => super.equals(other)
+      }
+    }
+
     override protected def subsetOf0(that: HashSet[A], level: Int) = {
       // check if that contains this.key
       // we use get0 with our key and hash at the correct level instead of calling contains,
       // which would not work since that might not be a top-level HashSet
       // and in any case would be inefficient because it would require recalculating the hash code
-      that.get0(key, hash, level)
+      (this eq that) || that.get0(key, hash, level)
     }
 
     override private[collection] def updated0(key: A, hash: Int, level: Int): HashSet[A] =
@@ -330,12 +341,21 @@ object HashSet extends ImmutableSetFactory[HashSet] {
     override protected def get0(key: A, hash: Int, level: Int): Boolean =
       if (hash == this.hash) ks.contains(key) else false
 
+    override def equals(other: Any): Boolean = {
+      other match {
+        case that: HashSetCollision1[A] =>
+          (this eq that) || (this.hash == that.hash && this.ks == that.ks)
+        case miss : HashSet[_] => false
+        case _ => super.equals(other)
+      }
+    }
+
     override protected def subsetOf0(that: HashSet[A], level: Int) = {
       // we have to check each element
       // we use get0 with our hash at the correct level instead of calling contains,
       // which would not work since that might not be a top-level HashSet
       // and in any case would be inefficient because it would require recalculating the hash code
-      ks.forall(key => that.get0(key, hash, level))
+      (this eq that) || ks.forall(key => that.get0(key, hash, level))
     }
 
     override private[collection] def updated0(key: A, hash: Int, level: Int): HashSet[A] =
@@ -880,7 +900,17 @@ object HashSet extends ImmutableSetFactory[HashSet] {
       }
     }
 
-    override protected def subsetOf0(that: HashSet[A], level: Int): Boolean = if (that eq this) true else that match {
+    override def equals(other: Any): Boolean = {
+      other match {
+        case that: HashTrieSet[A] =>
+          (this eq that) || (this.bitmap == that.bitmap && this.size0 == that.size0 &&
+            util.Arrays.equals(this.elems.asInstanceOf[Array[AnyRef]], that.elems.asInstanceOf[Array[AnyRef]]))
+        case _ : HashSet[_] => false
+        case _ => super.equals(other)
+      }
+    }
+
+    override protected def subsetOf0(that: HashSet[A], level: Int): Boolean = (that eq this) || (that match {
       case that: HashTrieSet[A] if this.size0 <= that.size0 =>
         // create local mutable copies of members
         var abm = this.bitmap
@@ -921,7 +951,7 @@ object HashSet extends ImmutableSetFactory[HashSet] {
         // if the other set is a HashSetCollision1, we can not be a subset of it because we are a HashTrieSet with at least two different hash codes
         // if the other set is the empty set, we are not a subset of it because we are not empty
         false
-    }
+    })
 
     override protected def filter0(p: A => Boolean, negate: Boolean, level: Int, buffer: Array[HashSet[A]], offset0: Int): HashSet[A] = {
       // current offset