Merge pull request scala#5603 from szeiger/wip/modularize-parallel-collections

[ci:last-only] Remove parallel collections from scala-library

Author: SethTisue

src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala

@@ -92,7 +92,7 @@ object AsmUtils {
     node
   }
 
-  def main(args: Array[String]): Unit = args.par.foreach { classFileName =>
+  def main(args: Array[String]): Unit = args /*.par*/.foreach { classFileName =>
     val node = zapScalaClassAttrs(sortClassMembers(classFromBytes(classBytes(classFileName))))
 
     val pw = new PrintWriter(classFileName + ".asm")

src/library/scala/collection/CustomParallelizable.scala

@@ -22,7 +22,7 @@ package collection
  *  A map is a collection of bindings from keys to values, where there are
  *  no duplicate keys.
  */
-trait GenMapLike[K, +V, +Repr] extends GenIterableLike[(K, V), Repr] with Equals with Parallelizable[(K, V), parallel.ParMap[K, V]] {
+trait GenMapLike[K, +V, +Repr] extends GenIterableLike[(K, V), Repr] with Equals {
   def default(key: K): V
   def get(key: K): Option[V]
   def apply(key: K): V

src/library/scala/collection/GenMapLike.scala

@@ -30,7 +30,7 @@ import generic._
  *  Sequences are special cases of iterable collections of class `Iterable`.
  *  Unlike iterables, sequences always have a defined order of elements.
  */
-trait GenSeqLike[+A, +Repr] extends Any with GenIterableLike[A, Repr] with Equals with Parallelizable[A, parallel.ParSeq[A]] {
+trait GenSeqLike[+A, +Repr] extends Any with GenIterableLike[A, Repr] with Equals {
   def seq: Seq[A]
 
   /** Selects an element by its index in the $coll.

src/library/scala/collection/GenSeqLike.scala

@@ -25,8 +25,7 @@ package collection
 trait GenSetLike[A, +Repr]
 extends GenIterableLike[A, Repr]
    with (A => Boolean)
-   with Equals
-   with Parallelizable[A, parallel.ParSet[A]] {
+   with Equals {
 
   def iterator: Iterator[A]
   def contains(elem: A): Boolean

src/library/scala/collection/GenSetLike.scala

@@ -54,7 +54,7 @@ import scala.annotation.migration
  *  @author Aleksandar Prokopec
  *  @since 2.9
  */
-trait GenTraversableLike[+A, +Repr] extends Any with GenTraversableOnce[A] with Parallelizable[A, parallel.ParIterable[A]] {
+trait GenTraversableLike[+A, +Repr] extends Any with GenTraversableOnce[A] {
 
   def repr: Repr
 

src/library/scala/collection/GenTraversableLike.scala

@@ -12,7 +12,6 @@ package collection
 import generic._
 import mutable.{ Builder, MapBuilder }
 import scala.annotation.migration
-import parallel.ParMap
 
 /** A template trait for maps, which associate keys with values.
  *
@@ -59,7 +58,6 @@ trait MapLike[K, +V, +This <: MapLike[K, V, This] with Map[K, V]]
      with IterableLike[(K, V), This]
      with GenMapLike[K, V, This]
      with Subtractable[K, This]
-     with Parallelizable[(K, V), ParMap[K, V]]
 {
 self =>
 
@@ -344,8 +342,6 @@ self =>
     result
   }
 
-  protected[this] override def parCombiner = ParMap.newCombiner[K, V]
-
   /** Appends all bindings of this map to a string builder using start, end, and separator strings.
    *  The written text begins with the string `start` and ends with the string
    *  `end`. Inside, the string representations of all bindings of this map

src/library/scala/collection/MapLike.scala

@@ -11,7 +11,6 @@ package collection
 
 import immutable.{ List, Range }
 import generic._
-import parallel.ParSeq
 import scala.math.Ordering
 
 /** A template trait for sequences of type `Seq[A]`
@@ -58,7 +57,7 @@ import scala.math.Ordering
  *  @define orderDependent
  *  @define orderDependentFold
  */
-trait SeqLike[+A, +Repr] extends Any with IterableLike[A, Repr] with GenSeqLike[A, Repr] with Parallelizable[A, ParSeq[A]] { self =>
+trait SeqLike[+A, +Repr] extends Any with IterableLike[A, Repr] with GenSeqLike[A, Repr] { self =>
 
   override protected[this] def thisCollection: Seq[A] = this.asInstanceOf[Seq[A]]
   override protected[this] def toCollection(repr: Repr): Seq[A] = repr.asInstanceOf[Seq[A]]
@@ -67,8 +66,6 @@ trait SeqLike[+A, +Repr] extends Any with IterableLike[A, Repr] with GenSeqLike[
 
   def apply(idx: Int): A
 
-  protected[this] override def parCombiner = ParSeq.newCombiner[A]
-
   /** Compares the length of this $coll to a test value.
    *
    *   @param   len   the test value that gets compared with the length.

src/library/scala/collection/Parallelizable.scala

@@ -12,7 +12,6 @@ package collection
 import generic._
 import mutable.{ Builder, SetBuilder }
 import scala.annotation.migration
-import parallel.ParSet
 
 /** A template trait for sets.
  *
@@ -59,7 +58,6 @@ trait SetLike[A, +This <: SetLike[A, This] with Set[A]]
 extends IterableLike[A, This]
    with GenSetLike[A, This]
    with Subtractable[A, This]
-   with Parallelizable[A, ParSet[A]]
 {
 self =>
 
@@ -75,8 +73,6 @@ self =>
    */
   override protected[this] def newBuilder: Builder[A, This] = new SetBuilder[A, This](empty)
 
-  protected[this] override def parCombiner = ParSet.newCombiner[A]
-
   // Default collection type appropriate for immutable collections; mutable collections override this
   override def toSeq: Seq[A] = {
     if (isEmpty) Vector.empty[A]

src/library/scala/collection/SeqLike.scala

@@ -13,7 +13,6 @@ import generic._
 import mutable.{ Builder }
 import scala.annotation.migration
 import scala.annotation.unchecked.{ uncheckedVariance => uV }
-import parallel.ParIterable
 import scala.language.higherKinds
 
 /** A template trait for traversable collections of type `Traversable[A]`.
@@ -71,7 +70,6 @@ trait TraversableLike[+A, +Repr] extends Any
                                     with FilterMonadic[A, Repr]
                                     with TraversableOnce[A]
                                     with GenTraversableLike[A, Repr]
-                                    with Parallelizable[A, ParIterable[A]]
 {
   self =>
 
@@ -103,8 +101,6 @@ trait TraversableLike[+A, +Repr] extends Any
    */
   protected[this] def newBuilder: Builder[A, Repr]
 
-  protected[this] def parCombiner = ParIterable.newCombiner[A]
-
   /** Applies a function `f` to all elements of this $coll.
    *
    *  @param  f   the function that is applied for its side-effect to every element.

src/library/scala/collection/SetLike.scala

@@ -11,7 +11,6 @@ package collection
 package concurrent
 
 import java.util.concurrent.atomic._
-import scala.collection.parallel.mutable.ParTrieMap
 import scala.util.hashing.Hashing
 import scala.util.control.ControlThrowable
 import generic._
@@ -631,7 +630,6 @@ private[concurrent] case class RDCSS_Descriptor[K, V](old: INode[K, V], expected
 final class TrieMap[K, V] private (r: AnyRef, rtupd: AtomicReferenceFieldUpdater[TrieMap[K, V], AnyRef], hashf: Hashing[K], ef: Equiv[K])
 extends scala.collection.concurrent.Map[K, V]
    with scala.collection.mutable.MapLike[K, V, TrieMap[K, V]]
-   with CustomParallelizable[(K, V), ParTrieMap[K, V]]
    with Serializable
 {
   private var hashingobj = if (hashf.isInstanceOf[Hashing.Default[_]]) new TrieMap.MangledHashing[K] else hashf
@@ -777,8 +775,6 @@ extends scala.collection.concurrent.Map[K, V]
 
   override def seq = this
 
-  override def par = new ParTrieMap(this)
-
   override def empty: TrieMap[K, V] = new TrieMap[K, V]
 
   def isReadOnly = rootupdater eq null