Merge pull request scala/scala#8589 from rorygraves/mike/2.12.x_quickHashSetUnion

[nomerge] faster ++ and union for HashSet

Author: retronym

library/src/scala/collection/IterableLike.scala

@@ -291,7 +291,7 @@ self =>
     b.result()
   }
 
-  def sameElements[B >: A](that: GenIterable[B]): Boolean = {
+  def sameElements[B >: A](that: GenIterable[B]): Boolean = (this.asInstanceOf[AnyRef] eq that.asInstanceOf[AnyRef]) || {
     that match {
       case thatVector: Vector[_] if this.isInstanceOf[Vector[_]] =>
         val thisVector = this.asInstanceOf[Vector[_]]
@@ -307,6 +307,9 @@ self =>
           }
           equal
         }
+      case thatSet: GenSet[A] if this.isInstanceOf[GenSetLike[A,_]]=>
+        val thisSet = this.asInstanceOf[GenSetLike[A,_]]
+          thisSet.size == thatSet.size && thisSet.subsetOf(thatSet)
 
       case _ =>
         val these = this.iterator

library/src/scala/collection/SetLike.scala

@@ -150,7 +150,35 @@ self =>
    *  @param elems     the collection containing the elements to add.
    *  @return a new $coll with the given elements added, omitting duplicates.
    */
-  def ++ (elems: GenTraversableOnce[A]): This = (repr /: elems.seq)(_ + _)
+  def ++ (elems: GenTraversableOnce[A]): This = {
+    import immutable.HashSet
+    //in 2.14 this should be moved to the appropriate place - HashSet and EmptySet.
+    //we can't break binary comparability before then
+    this match {
+      case _ if this eq immutable.Set.empty.asInstanceOf[AnyRef] =>
+        import immutable.Set.{Set1, Set2, Set3, Set4}
+        elems match {
+          case hs: HashSet[A] if hs.size > 4 => hs.asInstanceOf[This]
+          case hs: Set1[A] => hs.asInstanceOf[This]
+          case hs: Set2[A] => hs.asInstanceOf[This]
+          case hs: Set3[A] => hs.asInstanceOf[This]
+          case hs: Set4[A] => hs.asInstanceOf[This]
+          case _  =>
+            if (elems.isEmpty) this.asInstanceOf[This]
+            else (repr /: elems.seq) (_ + _)
+        }
+      case hs: immutable.HashSet[A] =>
+        elems match {
+          case that: GenSet[A] =>
+            hs.union(that).asInstanceOf[This]
+          case _ =>
+            (repr /: elems.seq) (_ + _)
+        }
+      case _ =>
+        (repr /: elems.seq) (_ + _)
+
+    }
+  }
 
   /** Creates a new set with a given element removed from this set.
    *

library/src/scala/collection/TraversableLike.scala

@@ -145,11 +145,29 @@ trait TraversableLike[+A, +Repr] extends Any
   def hasDefiniteSize = true
 
   def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
-    val b = bf(repr)
-    if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.seq.size)
-    b ++= thisCollection
-    b ++= that.seq
-    b.result
+    def defaultPlusPlus: That = {
+      val b = bf(repr)
+      if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.seq.size)
+      b ++= thisCollection
+      b ++= that.seq
+      b.result
+    }
+
+    if (bf eq immutable.Set.canBuildFrom) {
+      this match {
+        case s: immutable.Set[A] if that.isInstanceOf[GenSet[A]] =>
+          (s union that.asInstanceOf[GenSet[A]]).asInstanceOf[That]
+        case _ => defaultPlusPlus
+      }
+    } else if (bf eq immutable.HashSet.canBuildFrom) {
+      this match {
+        case s: immutable.HashSet[A] if that.isInstanceOf[GenSet[A]] =>
+          (s union that.asInstanceOf[GenSet[A]]).asInstanceOf[That]
+        case _ => defaultPlusPlus
+      }
+
+    } else defaultPlusPlus
+
   }
 
   /** As with `++`, returns a new collection containing the elements from the left operand followed by the
@@ -185,11 +203,28 @@ trait TraversableLike[+A, +Repr] extends Any
    *                  followed by all elements of `that`.
    */
   def ++:[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
-    val b = bf(repr)
-    if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.size)
-    b ++= that
-    b ++= thisCollection
-    b.result
+    def defaultPlusPlus: That = {
+      val b = bf(repr)
+      if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.size)
+      b ++= that
+      b ++= thisCollection
+      b.result
+    }
+    if (bf eq immutable.Set.canBuildFrom) {
+      this match {
+        case s: immutable.Set[A] if that.isInstanceOf[GenSet[A]] =>
+          (s union that.asInstanceOf[GenSet[A]]).asInstanceOf[That]
+        case _ => defaultPlusPlus
+      }
+    } else if (bf eq immutable.HashSet.canBuildFrom) {
+      this match {
+        case s: immutable.HashSet[A] if that.isInstanceOf[GenSet[A]] =>
+          (s union that.asInstanceOf[GenSet[A]]).asInstanceOf[That]
+        case _ => defaultPlusPlus
+      }
+
+    } else defaultPlusPlus
+
   }
 
   /** As with `++`, returns a new collection containing the elements from the