Merge pull request scala#7696 from smarter/fix/dotty-compilation

Fix compilation of the collections with Dotty

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.Iterable[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/SortedSet.scala

@@ -38,6 +38,11 @@ trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]]
   def unsorted: Set[A]
 }
 
+trait StrictOptimizedSortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]]
+  extends SortedSetOps[A, CC, C]
+    with collection.StrictOptimizedSortedSetOps[A, CC, C]
+    with StrictOptimizedSetOps[A, Set, C]
+
 /**
   * $factoryInfo
   * @define coll immutable sorted set

src/library/scala/collection/immutable/TreeSeqMap.scala

@@ -284,9 +284,9 @@ final class TreeSeqMap[K, +V] private (
 }
 object TreeSeqMap extends MapFactory[TreeSeqMap] {
   sealed trait OrderBy
-  final object OrderBy {
-    final case object Insertion extends OrderBy
-    final case object Modification extends OrderBy
+  object OrderBy {
+    case object Insertion extends OrderBy
+    case object Modification extends OrderBy
   }
 
   val Empty = new TreeSeqMap[Nothing, Nothing](Ordering.empty, HashMap.empty, 0, OrderBy.Insertion)
@@ -351,7 +351,7 @@ object TreeSeqMap extends MapFactory[TreeSeqMap] {
   private val Mapping = Map
 
   /* The ordering implementation below is an adapted version of immutable.IntMap. */
-  private[immutable] final object Ordering {
+  private[immutable] object Ordering {
     import scala.collection.generic.BitOperations.Int._
 
     @inline private[immutable] def toBinaryString(i: Int): String = s"$i/${i.toBinaryString}"
@@ -404,7 +404,7 @@ object TreeSeqMap extends MapFactory[TreeSeqMap] {
       def empty[V]: Iterator[V] = Empty.asInstanceOf[Iterator[V]]
     }
 
-    final case object Zero extends Ordering[Nothing] {
+    case object Zero extends Ordering[Nothing] {
       // Important! Without this equals method in place, an infinite
       // loop from Map.equals => size => pattern-match-on-Nil => equals
       // develops.  Case objects and custom equality don't mix without
@@ -635,4 +635,4 @@ object TreeSeqMap extends MapFactory[TreeSeqMap] {
         else bin(prefix, mask, l, r)
     }
   }
-}
+}

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)

src/library/scala/sys/process/ProcessImpl.scala

@@ -193,7 +193,7 @@ private[process] trait ProcessImpl {
     protected[this] val source = new SyncVar[Option[InputStream]]
     override final def run(): Unit = {
       @tailrec def go(): Unit =
-        source.take match {
+        source.take() match {
           case Some(in) => runloop(in, pipe) ; go()
           case None =>
         }
@@ -216,7 +216,7 @@ private[process] trait ProcessImpl {
     protected[this] val sink = new SyncVar[Option[OutputStream]]
     override def run(): Unit = {
       @tailrec def go(): Unit =
-        sink.take match {
+        sink.take() match {
           case Some(out) => runloop(pipe, out) ; go()
           case None =>
         }