Optimise HashSet bulk operations mostly focussed around ++ and union

EmptySet and SetBuilder adjusted to take advantage of ++ optimisation for simple and common cases

eliminate unneeded allocations for HashSets where the result is already built for -
   subSet ++ superSet
   subSet union superSet
   superSet union subSet
   superSet ++ subSet

make a fast path when there is structural sharing in the HashSet
for union, guarantee internal operations will only return a new HashSet if one of the existing HashSet parameters or internal values cant be used

use System.arraycopy rather than Array.copy as it avoid JVM nulling the array

add missing `eq` fast path to intersect0 and diff0

minor improvements to + to reduce allocations

reduce calls to HashSet.size which can be a bottleneck

reduce allocations in ListSet ++, + and -
no allocations in ++ or + if the data is contained in the original sets

HashSetCollision1 stores its length so as to avoid calls to ListSet.size which is O(n)
take advantage of ListSet guarantees on identity for return or + or - where we can
avoid calling ListSet.size where we can avoid it

Author: mkeskells

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