Make some collection classes final or sealed

They were all annotated with `@deprecatedInheritance` in 2.11.0. Some
deprecated classes are moved to new source files in order to seal the
parent class. The package-private class `DoublingUnrolledBuffer` is
moved from `scala.collection.parallel.mutable` to
`scala.collection.mutable` in order to seal `UnrolledBuffer`.

6 files changed, 193 insertions, 221 deletions

diff --git a/src/library/scala/collection/mutable/ArrayBuilder.scala b/src/library/scala/collection/mutable/ArrayBuilder.scala
index 549ffef565..d023110c1b 100644
--- a/src/library/scala/collection/mutable/ArrayBuilder.scala
+++ b/src/library/scala/collection/mutable/ArrayBuilder.scala
@@ -53,8 +53,7 @@ object ArrayBuilder {
    *
    *  @tparam T     type of elements for the array builder, subtype of `AnyRef` with a `ClassTag` context bound.
    */
-  @deprecatedInheritance("ArrayBuilder.ofRef is an internal implementation not intended for subclassing.", "2.11.0")
-  class ofRef[T <: AnyRef : ClassTag] extends ArrayBuilder[T] {
+  final class ofRef[T <: AnyRef : ClassTag] extends ArrayBuilder[T] {
 
     private var elems: Array[T] = _
     private var capacity: Int = 0
@@ -119,8 +118,7 @@ object ArrayBuilder {
   }
 
   /** A class for array builders for arrays of `byte`s. It can be reused. */
-  @deprecatedInheritance("ArrayBuilder.ofByte is an internal implementation not intended for subclassing.", "2.11.0")
-  class ofByte extends ArrayBuilder[Byte] {
+  final class ofByte extends ArrayBuilder[Byte] {
 
     private var elems: Array[Byte] = _
     private var capacity: Int = 0
@@ -185,8 +183,7 @@ object ArrayBuilder {
   }
 
   /** A class for array builders for arrays of `short`s. It can be reused. */
-  @deprecatedInheritance("ArrayBuilder.ofShort is an internal implementation not intended for subclassing.", "2.11.0")
-  class ofShort extends ArrayBuilder[Short] {
+  final class ofShort extends ArrayBuilder[Short] {
 
     private var elems: Array[Short] = _
     private var capacity: Int = 0
@@ -251,8 +248,7 @@ object ArrayBuilder {
   }
 
   /** A class for array builders for arrays of `char`s. It can be reused. */
-  @deprecatedInheritance("ArrayBuilder.ofChar is an internal implementation not intended for subclassing.", "2.11.0")
-  class ofChar extends ArrayBuilder[Char] {
+  final class ofChar extends ArrayBuilder[Char] {
 
     private var elems: Array[Char] = _
     private var capacity: Int = 0
@@ -317,8 +313,7 @@ object ArrayBuilder {
   }
 
   /** A class for array builders for arrays of `int`s. It can be reused. */
-  @deprecatedInheritance("ArrayBuilder.ofInt is an internal implementation not intended for subclassing.", "2.11.0")
-  class ofInt extends ArrayBuilder[Int] {
+  final class ofInt extends ArrayBuilder[Int] {
 
     private var elems: Array[Int] = _
     private var capacity: Int = 0
@@ -383,8 +378,7 @@ object ArrayBuilder {
   }
 
   /** A class for array builders for arrays of `long`s. It can be reused. */
-  @deprecatedInheritance("ArrayBuilder.ofLong is an internal implementation not intended for subclassing.", "2.11.0")
-  class ofLong extends ArrayBuilder[Long] {
+  final class ofLong extends ArrayBuilder[Long] {
 
     private var elems: Array[Long] = _
     private var capacity: Int = 0
@@ -449,8 +443,7 @@ object ArrayBuilder {
   }
 
   /** A class for array builders for arrays of `float`s. It can be reused. */
-  @deprecatedInheritance("ArrayBuilder.ofFloat is an internal implementation not intended for subclassing.", "2.11.0")
-  class ofFloat extends ArrayBuilder[Float] {
+  final class ofFloat extends ArrayBuilder[Float] {
 
     private var elems: Array[Float] = _
     private var capacity: Int = 0
@@ -515,8 +508,7 @@ object ArrayBuilder {
   }
 
   /** A class for array builders for arrays of `double`s. It can be reused. */
-  @deprecatedInheritance("ArrayBuilder.ofDouble is an internal implementation not intended for subclassing.", "2.11.0")
-  class ofDouble extends ArrayBuilder[Double] {
+  final class ofDouble extends ArrayBuilder[Double] {
 
     private var elems: Array[Double] = _
     private var capacity: Int = 0
@@ -646,8 +638,7 @@ object ArrayBuilder {
   }
 
   /** A class for array builders for arrays of `Unit` type. It can be reused. */
-  @deprecatedInheritance("ArrayBuilder.ofUnit is an internal implementation not intended for subclassing.", "2.11.0")
-  class ofUnit extends ArrayBuilder[Unit] {
+  final class ofUnit extends ArrayBuilder[Unit] {
 
     private var size: Int = 0
 
diff --git a/src/library/scala/collection/mutable/ArrayOps.scala b/src/library/scala/collection/mutable/ArrayOps.scala
index 5144db7de3..b7682c5ab9 100644
--- a/src/library/scala/collection/mutable/ArrayOps.scala
+++ b/src/library/scala/collection/mutable/ArrayOps.scala
@@ -32,8 +32,7 @@ import parallel.mutable.ParArray
  *  @define mayNotTerminateInf
  *  @define willNotTerminateInf
  */
-@deprecatedInheritance("ArrayOps will be sealed to facilitate greater flexibility with array/collections integration in future releases.", "2.11.0")
-trait ArrayOps[T] extends Any with ArrayLike[T, Array[T]] with CustomParallelizable[T, ParArray[T]] {
+sealed trait ArrayOps[T] extends Any with ArrayLike[T, Array[T]] with CustomParallelizable[T, ParArray[T]] {
 
   private def elementClass: Class[_] =
     arrayElementClass(repr.getClass)
diff --git a/src/library/scala/collection/mutable/PriorityQueue.scala b/src/library/scala/collection/mutable/PriorityQueue.scala
index e6889da3b5..b4112c03dd 100644
--- a/src/library/scala/collection/mutable/PriorityQueue.scala
+++ b/src/library/scala/collection/mutable/PriorityQueue.scala
@@ -46,8 +46,7 @@ import generic._
  *  @define mayNotTerminateInf
  *  @define willNotTerminateInf
  */
-@deprecatedInheritance("PriorityQueue is not intended to be subclassed due to extensive private implementation details.", "2.11.0")
-class PriorityQueue[A](implicit val ord: Ordering[A])
+sealed class PriorityQueue[A](implicit val ord: Ordering[A])
    extends AbstractIterable[A]
       with Iterable[A]
       with GenericOrderedTraversableTemplate[A, PriorityQueue]
@@ -266,3 +265,176 @@ object PriorityQueue extends OrderedTraversableFactory[PriorityQueue] {
   implicit def canBuildFrom[A](implicit ord: Ordering[A]): CanBuildFrom[Coll, A, PriorityQueue[A]] = new GenericCanBuildFrom[A]
 }
 
+
+/** This class servers as a proxy for priority queues. The
+  *  elements of the queue have to be ordered in terms of the
+  *  `Ordered[T]` class.
+  *
+  *  @author  Matthias Zenger
+  *  @version 1.0, 03/05/2004
+  *  @since   1
+  */
+@deprecated("Proxying is deprecated due to lack of use and compiler-level support.", "2.11.0")
+sealed abstract class PriorityQueueProxy[A](implicit ord: Ordering[A]) extends PriorityQueue[A]
+  with Proxy
+{
+  def self: PriorityQueue[A]
+
+  /** Creates a new iterator over all elements contained in this
+    *  object.
+    *
+    *  @return the new iterator
+    */
+  override def iterator: Iterator[A] = self.iterator
+
+  /** Returns the length of this priority queue.
+    */
+  override def length: Int = self.length
+
+  /** Checks if the queue is empty.
+    *
+    *  @return true, iff there is no element in the queue.
+    */
+  override def isEmpty: Boolean = self.isEmpty
+
+  /** Inserts a single element into the priority queue.
+    *
+    *  @param  elem        the element to insert
+    */
+  override def +=(elem: A): this.type = { self += elem; this }
+
+  /** Adds all elements provided by an iterator into the priority queue.
+    *
+    *  @param  it        an iterator
+    */
+  override def ++=(it: TraversableOnce[A]): this.type = {
+    self ++= it
+    this
+  }
+
+  /** Adds all elements to the queue.
+    *
+    *  @param  elems       the elements to add.
+    */
+  override def enqueue(elems: A*): Unit = self ++= elems
+
+  /** Returns the element with the highest priority in the queue,
+    *  and removes this element from the queue.
+    *
+    *  @return   the element with the highest priority.
+    */
+  override def dequeue(): A = self.dequeue()
+
+  /** Returns the element with the highest priority in the queue,
+    *  or throws an error if there is no element contained in the queue.
+    *
+    *  @return   the element with the highest priority.
+    */
+  override def head: A = self.head
+
+  /** Removes all elements from the queue. After this operation is completed,
+    *  the queue will be empty.
+    */
+  override def clear(): Unit = self.clear()
+
+  /** Returns a regular queue containing the same elements.
+    */
+  override def toQueue: Queue[A] = self.toQueue
+
+  /** This method clones the priority queue.
+    *
+    *  @return  a priority queue with the same elements.
+    */
+  override def clone(): PriorityQueue[A] = new PriorityQueueProxy[A] {
+    def self = PriorityQueueProxy.this.self.clone()
+  }
+}
+
+
+/** This class implements synchronized priority queues using a binary heap.
+  *  The elements of the queue have to be ordered in terms of the `Ordered[T]` class.
+  *
+  *  @tparam A    type of the elements contained in this synchronized priority queue
+  *  @param ord   implicit ordering used to compared elements of type `A`
+  *
+  *  @author  Matthias Zenger
+  *  @version 1.0, 03/05/2004
+  *  @since   1
+  *  @define Coll `SynchronizedPriorityQueue`
+  *  @define coll synchronized priority queue
+  */
+@deprecated("Comprehensive synchronization via selective overriding of methods is inherently unreliable.  Consider java.util.concurrent.ConcurrentSkipListSet as an alternative.", "2.11.0")
+sealed class SynchronizedPriorityQueue[A](implicit ord: Ordering[A]) extends PriorityQueue[A] {
+
+  /** Checks if the queue is empty.
+    *
+    *  @return true, iff there is no element in the queue.
+    */
+  override def isEmpty: Boolean = synchronized { super.isEmpty }
+
+  /** Inserts a single element into the priority queue.
+    *
+    *  @param  elem        the element to insert
+    */
+  override def +=(elem: A): this.type = {
+    synchronized {
+      super.+=(elem)
+    }
+    this
+  }
+
+  /** Adds all elements of a traversable object into the priority queue.
+    *
+    *  @param  xs        a traversable object
+    */
+  override def ++=(xs: TraversableOnce[A]): this.type = {
+    synchronized {
+      super.++=(xs)
+    }
+    this
+  }
+
+  /** Adds all elements to the queue.
+    *
+    *  @param  elems       the elements to add.
+    */
+  override def enqueue(elems: A*): Unit = synchronized { super.++=(elems) }
+
+  /** Returns the element with the highest priority in the queue,
+    *  and removes this element from the queue.
+    *
+    *  @return   the element with the highest priority.
+    */
+  override def dequeue(): A = synchronized { super.dequeue() }
+
+  /** Returns the element with the highest priority in the queue,
+    *  or throws an error if there is no element contained in the queue.
+    *
+    *  @return   the element with the highest priority.
+    */
+  override def head: A = synchronized { super.head }
+
+  /** Removes all elements from the queue. After this operation is completed,
+    *  the queue will be empty.
+    */
+  override def clear(): Unit = synchronized { super.clear() }
+
+  /** Returns an iterator which yield all the elements of the priority
+    *  queue in descending priority order.
+    *
+    *  @return  an iterator over all elements sorted in descending order.
+    */
+  override def iterator: Iterator[A] = synchronized { super.iterator }
+
+  /** Checks if two queues are structurally identical.
+    *
+    *  @return true, iff both queues contain the same sequence of elements.
+    */
+  override def equals(that: Any): Boolean = synchronized { super.equals(that) }
+
+  /** Returns a textual representation of a queue as a string.
+    *
+    *  @return the string representation of this queue.
+    */
+  override def toString(): String = synchronized { super.toString() }
+}
diff --git a/src/library/scala/collection/mutable/PriorityQueueProxy.scala b/src/library/scala/collection/mutable/PriorityQueueProxy.scala
deleted file mode 100644
index b24551a6b7..0000000000
--- a/src/library/scala/collection/mutable/PriorityQueueProxy.scala
+++ /dev/null
@@ -1,96 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2013, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-
-
-package scala
-package collection
-package mutable
-
-/** This class servers as a proxy for priority queues. The
- *  elements of the queue have to be ordered in terms of the
- *  `Ordered[T]` class.
- *
- *  @author  Matthias Zenger
- *  @version 1.0, 03/05/2004
- *  @since   1
- */
-@deprecated("Proxying is deprecated due to lack of use and compiler-level support.", "2.11.0")
-abstract class PriorityQueueProxy[A](implicit ord: Ordering[A]) extends PriorityQueue[A]
-         with Proxy
-{
-  def self: PriorityQueue[A]
-
-  /** Creates a new iterator over all elements contained in this
-   *  object.
-   *
-   *  @return the new iterator
-   */
-  override def iterator: Iterator[A] = self.iterator
-
-  /** Returns the length of this priority queue.
-   */
-  override def length: Int = self.length
-
-  /** Checks if the queue is empty.
-   *
-   *  @return true, iff there is no element in the queue.
-   */
-  override def isEmpty: Boolean = self.isEmpty
-
-  /** Inserts a single element into the priority queue.
-   *
-   *  @param  elem        the element to insert
-   */
-  override def +=(elem: A): this.type = { self += elem; this }
-
-  /** Adds all elements provided by an iterator into the priority queue.
-   *
-   *  @param  it        an iterator
-   */
-  override def ++=(it: TraversableOnce[A]): this.type = {
-    self ++= it
-    this
-  }
-
-  /** Adds all elements to the queue.
-   *
-   *  @param  elems       the elements to add.
-   */
-  override def enqueue(elems: A*): Unit = self ++= elems
-
-  /** Returns the element with the highest priority in the queue,
-   *  and removes this element from the queue.
-   *
-   *  @return   the element with the highest priority.
-   */
-  override def dequeue(): A = self.dequeue()
-
-  /** Returns the element with the highest priority in the queue,
-   *  or throws an error if there is no element contained in the queue.
-   *
-   *  @return   the element with the highest priority.
-   */
-  override def head: A = self.head
-
-  /** Removes all elements from the queue. After this operation is completed,
-   *  the queue will be empty.
-   */
-  override def clear(): Unit = self.clear()
-
-  /** Returns a regular queue containing the same elements.
-   */
-  override def toQueue: Queue[A] = self.toQueue
-
-  /** This method clones the priority queue.
-   *
-   *  @return  a priority queue with the same elements.
-   */
-  override def clone(): PriorityQueue[A] = new PriorityQueueProxy[A] {
-    def self = PriorityQueueProxy.this.self.clone()
-  }
-}
diff --git a/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala b/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala
deleted file mode 100644
index d3c0b85f69..0000000000
--- a/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala
+++ /dev/null
@@ -1,101 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2013, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-
-
-
-package scala
-package collection
-package mutable
-
-/** This class implements synchronized priority queues using a binary heap.
- *  The elements of the queue have to be ordered in terms of the `Ordered[T]` class.
- *
- *  @tparam A    type of the elements contained in this synchronized priority queue
- *  @param ord   implicit ordering used to compared elements of type `A`
- *
- *  @author  Matthias Zenger
- *  @version 1.0, 03/05/2004
- *  @since   1
- *  @define Coll `SynchronizedPriorityQueue`
- *  @define coll synchronized priority queue
- */
-@deprecated("Comprehensive synchronization via selective overriding of methods is inherently unreliable.  Consider java.util.concurrent.ConcurrentSkipListSet as an alternative.", "2.11.0")
-class SynchronizedPriorityQueue[A](implicit ord: Ordering[A]) extends PriorityQueue[A] {
-
-  /** Checks if the queue is empty.
-   *
-   *  @return true, iff there is no element in the queue.
-   */
-  override def isEmpty: Boolean = synchronized { super.isEmpty }
-
-  /** Inserts a single element into the priority queue.
-   *
-   *  @param  elem        the element to insert
-   */
-  override def +=(elem: A): this.type = {
-    synchronized {
-      super.+=(elem)
-    }
-    this
-  }
-
-  /** Adds all elements of a traversable object into the priority queue.
-   *
-   *  @param  xs        a traversable object
-   */
-  override def ++=(xs: TraversableOnce[A]): this.type = {
-    synchronized {
-      super.++=(xs)
-    }
-    this
-  }
-
-  /** Adds all elements to the queue.
-   *
-   *  @param  elems       the elements to add.
-   */
-  override def enqueue(elems: A*): Unit = synchronized { super.++=(elems) }
-
-  /** Returns the element with the highest priority in the queue,
-   *  and removes this element from the queue.
-   *
-   *  @return   the element with the highest priority.
-   */
-  override def dequeue(): A = synchronized { super.dequeue() }
-
-  /** Returns the element with the highest priority in the queue,
-   *  or throws an error if there is no element contained in the queue.
-   *
-   *  @return   the element with the highest priority.
-   */
-  override def head: A = synchronized { super.head }
-
-  /** Removes all elements from the queue. After this operation is completed,
-   *  the queue will be empty.
-   */
-  override def clear(): Unit = synchronized { super.clear() }
-
-  /** Returns an iterator which yield all the elements of the priority
-   *  queue in descending priority order.
-   *
-   *  @return  an iterator over all elements sorted in descending order.
-   */
-  override def iterator: Iterator[A] = synchronized { super.iterator }
-
-  /** Checks if two queues are structurally identical.
-   *
-   *  @return true, iff both queues contain the same sequence of elements.
-   */
-  override def equals(that: Any): Boolean = synchronized { super.equals(that) }
-
-  /** Returns a textual representation of a queue as a string.
-   *
-   *  @return the string representation of this queue.
-   */
-  override def toString(): String = synchronized { super.toString() }
-}
diff --git a/src/library/scala/collection/mutable/UnrolledBuffer.scala b/src/library/scala/collection/mutable/UnrolledBuffer.scala
index 2212486bcf..b49d009a17 100644
--- a/src/library/scala/collection/mutable/UnrolledBuffer.scala
+++ b/src/library/scala/collection/mutable/UnrolledBuffer.scala
@@ -43,8 +43,7 @@ import scala.reflect.ClassTag
  *
  */
 @SerialVersionUID(1L)
-@deprecatedInheritance("UnrolledBuffer is not designed to enable meaningful subclassing.", "2.11.0")
-class UnrolledBuffer[T](implicit val tag: ClassTag[T])
+sealed class UnrolledBuffer[T](implicit val tag: ClassTag[T])
 extends scala.collection.mutable.AbstractBuffer[T]
    with scala.collection.mutable.Buffer[T]
    with scala.collection.mutable.BufferLike[T, UnrolledBuffer[T]]
@@ -350,3 +349,11 @@ object UnrolledBuffer extends ClassTagTraversableFactory[UnrolledBuffer] {
   }
 
 }
+
+
+// This is used by scala.collection.parallel.mutable.UnrolledParArrayCombiner:
+// Todo -- revisit whether inheritance is the best way to achieve this functionality
+private[collection] class DoublingUnrolledBuffer[T](implicit t: ClassTag[T]) extends UnrolledBuffer[T]()(t) {
+  override def calcNextLength(sz: Int) = if (sz < 10000) sz * 2 else sz
+  protected override def newUnrolled = new UnrolledBuffer.Unrolled[T](0, new Array[T](4), null, this)
+}