Set#concat: avoid clashing overloads by adding a DummyImplicit

Because Dotty adds mixing forwarders before erasure, classes can end up with
forwarders for both the non-polymorphic and polymorphic concats that
will clash after erasure.

Author: smarter

src/library/scala/collection/BitSet.scala

@@ -233,7 +233,7 @@ trait BitSetOps[+C <: BitSet with BitSetOps[C]]
     coll.fromBitMaskNoCopy(a)
   }
 
-  override def concat(other: collection.IterableOnce[Int]): C = other match {
+  override def concat(other: collection.IterableOnce[Int])(implicit dummy: DummyImplicit): C = other match {
     case otherBitset: BitSet =>
       val len = coll.nwords max otherBitset.nwords
       val words = new Array[Long](len)

src/library/scala/collection/Set.scala

@@ -176,6 +176,10 @@ trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]]
   @deprecated("Use &- with an explicit collection argument instead of - with varargs", "2.13.0")
   def - (elem1: A, elem2: A, elems: A*): C = diff(elems.toSet + elem1 + elem2)
 
+  // The implicit dummy parameter is necessary to avoid erased signature clashes
+  // between this `concat` and the polymorphic one defined in `IterableOps`.
+  // Note that these clashes only happen in Dotty because it adds mixin
+  // forwarders before erasure unlike Scala 2.
   /** Creates a new $coll by adding all elements contained in another collection to this $coll, omitting duplicates.
     *
     * This method takes a collection of elements and adds all elements, omitting duplicates, into $coll.
@@ -189,7 +193,7 @@ trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]]
     *  @param that     the collection containing the elements to add.
     *  @return a new $coll with the given elements added, omitting duplicates.
     */
-  def concat(that: collection.IterableOnce[A]): C = fromSpecific(that match {
+  def concat(that: collection.IterableOnce[A])(implicit dummy: DummyImplicit): C = fromSpecific(that match {
     case that: collection.Iterable[A] => new View.Concat(toIterable, that)
     case _ => iterator.concat(that.iterator)
   })
@@ -201,7 +205,7 @@ trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]]
   def + (elem1: A, elem2: A, elems: A*): C = fromSpecific(new View.Concat(new View.Appended(new View.Appended(toIterable, elem1), elem2), elems))
 
   /** Alias for `concat` */
-  @`inline` final def ++ (that: collection.IterableOnce[A]): C = concat(that)
+  @`inline` final def ++ (that: collection.IterableOnce[A])(implicit dummy: DummyImplicit): C = concat(that)
 
   /** Computes the union between of set and another set.
     *

src/library/scala/collection/StrictOptimizedSetOps.scala

@@ -23,7 +23,7 @@ trait StrictOptimizedSetOps[A, +CC[_], +C <: SetOps[A, CC, C]]
   extends SetOps[A, CC, C]
     with StrictOptimizedIterableOps[A, CC, C] {
 
-  override def concat(that: IterableOnce[A]): C =
+  override def concat(that: IterableOnce[A])(implicit dummy: DummyImplicit): C =
     strictOptimizedConcat(that, newSpecificBuilder)
 
 }

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

@@ -73,7 +73,7 @@ final class HashSet[A] private[immutable] (val rootNode: SetNode[A])
     if (rootNode ne newRootNode) new HashSet(newRootNode) else this
   }
 
-  override def concat(that: IterableOnce[A]): HashSet[A] = {
+  override def concat(that: IterableOnce[A])(implicit dummy: DummyImplicit): HashSet[A] = {
     val builder = iterableFactory.newBuilder[A]
     builder ++= this
     builder ++= that

src/library/scala/collection/immutable/Set.scala

@@ -79,7 +79,7 @@ trait StrictOptimizedSetOps[A, +CC[X], +C <: SetOps[A, CC, C]]
     with collection.StrictOptimizedSetOps[A, CC, C]
     with StrictOptimizedIterableOps[A, CC, C] {
 
-  override def concat(that: collection.IterableOnce[A]): C = {
+  override def concat(that: collection.IterableOnce[A])(implicit dummy: DummyImplicit): C = {
     var result: C = coll
     val it = that.iterator
     while (it.hasNext) result = result + it.next()

src/library/scala/collection/immutable/TreeSet.scala

@@ -139,7 +139,7 @@ final class TreeSet[A] private[immutable] (private[immutable] val tree: RB.Tree[
   def excl(elem: A): TreeSet[A] =
     newSetOrSelf(RB.delete(tree, elem))
 
-  override def concat(that: collection.IterableOnce[A]): TreeSet[A] = {
+  override def concat(that: collection.IterableOnce[A])(implicit dummy: DummyImplicit): TreeSet[A] = {
     val t = that match {
       case ts: TreeSet[A] if ordering == ts.ordering =>
         RB.union(tree, ts.tree)