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`.

18 files changed, 206 insertions, 249 deletions

diff --git a/src/library/scala/collection/immutable/HashMap.scala b/src/library/scala/collection/immutable/HashMap.scala
index 3c41e1ba11..eac9c14f3f 100644
--- a/src/library/scala/collection/immutable/HashMap.scala
+++ b/src/library/scala/collection/immutable/HashMap.scala
@@ -33,8 +33,7 @@ import parallel.immutable.ParHashMap
  *  @define willNotTerminateInf
  */
 @SerialVersionUID(2L)
-@deprecatedInheritance("The implementation details of immutable hash maps make inheriting from them unwise.", "2.11.0")
-class HashMap[A, +B] extends AbstractMap[A, B]
+sealed class HashMap[A, +B] extends AbstractMap[A, B]
                         with Map[A, B]
                         with MapLike[A, B, HashMap[A, B]]
                         with Serializable
diff --git a/src/library/scala/collection/immutable/HashSet.scala b/src/library/scala/collection/immutable/HashSet.scala
index 2d8cc0b386..fc937e3a22 100644
--- a/src/library/scala/collection/immutable/HashSet.scala
+++ b/src/library/scala/collection/immutable/HashSet.scala
@@ -31,8 +31,7 @@ import scala.annotation.tailrec
  *  @define coll immutable hash set
  */
 @SerialVersionUID(2L)
-@deprecatedInheritance("The implementation details of immutable hash sets make inheriting from them unwise.", "2.11.0")
-class HashSet[A] extends AbstractSet[A]
+sealed class HashSet[A] extends AbstractSet[A]
                     with Set[A]
                     with GenericSetTemplate[A, HashSet]
                     with SetLike[A, HashSet[A]]
diff --git a/src/library/scala/collection/immutable/ListMap.scala b/src/library/scala/collection/immutable/ListMap.scala
index 5bbcf44201..e1bcc0711c 100644
--- a/src/library/scala/collection/immutable/ListMap.scala
+++ b/src/library/scala/collection/immutable/ListMap.scala
@@ -58,8 +58,7 @@ object ListMap extends ImmutableMapFactory[ListMap] {
  *  @define willNotTerminateInf
  */
 @SerialVersionUID(301002838095710379L)
-@deprecatedInheritance("The semantics of immutable collections makes inheriting from ListMap error-prone.", "2.11.0")
-class ListMap[A, +B]
+sealed class ListMap[A, +B]
 extends AbstractMap[A, B]
    with Map[A, B]
    with MapLike[A, B, ListMap[A, B]]
diff --git a/src/library/scala/collection/immutable/ListSet.scala b/src/library/scala/collection/immutable/ListSet.scala
index 98b91f7c84..d20e7bc6d2 100644
--- a/src/library/scala/collection/immutable/ListSet.scala
+++ b/src/library/scala/collection/immutable/ListSet.scala
@@ -67,8 +67,7 @@ object ListSet extends ImmutableSetFactory[ListSet] {
  *  @define mayNotTerminateInf
  *  @define willNotTerminateInf
  */
-@deprecatedInheritance("The semantics of immutable collections makes inheriting from ListSet error-prone.", "2.11.0")
-class ListSet[A] extends AbstractSet[A]
+sealed class ListSet[A] extends AbstractSet[A]
                     with Set[A]
                     with GenericSetTemplate[A, ListSet]
                     with SetLike[A, ListSet[A]]
diff --git a/src/library/scala/collection/immutable/Queue.scala b/src/library/scala/collection/immutable/Queue.scala
index 70b51f8251..3ad6656636 100644
--- a/src/library/scala/collection/immutable/Queue.scala
+++ b/src/library/scala/collection/immutable/Queue.scala
@@ -37,8 +37,7 @@ import mutable.{ Builder, ListBuffer }
  */
 
 @SerialVersionUID(-7622936493364270175L)
-@deprecatedInheritance("The implementation details of immutable queues make inheriting from them unwise.", "2.11.0")
-class Queue[+A] protected(protected val in: List[A], protected val out: List[A])
+sealed class Queue[+A] protected(protected val in: List[A], protected val out: List[A])
          extends AbstractSeq[A]
             with LinearSeq[A]
             with GenericTraversableTemplate[A, Queue]
diff --git a/src/library/scala/collection/immutable/Range.scala b/src/library/scala/collection/immutable/Range.scala
index fb7dd4cfbf..d3fe367e50 100644
--- a/src/library/scala/collection/immutable/Range.scala
+++ b/src/library/scala/collection/immutable/Range.scala
@@ -57,8 +57,7 @@ import scala.collection.parallel.immutable.ParRange
  *         and its complexity is O(1).
  */
 @SerialVersionUID(7618862778670199309L)
-@deprecatedInheritance("The implementation details of Range makes inheriting from it unwise.", "2.11.0")
-class Range(val start: Int, val end: Int, val step: Int)
+sealed class Range(val start: Int, val end: Int, val step: Int)
 extends scala.collection.AbstractSeq[Int]
    with IndexedSeq[Int]
    with scala.collection.CustomParallelizable[Int, ParRange]
diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala
index d92b159f3b..d3d5af7678 100644
--- a/src/library/scala/collection/immutable/Stream.scala
+++ b/src/library/scala/collection/immutable/Stream.scala
@@ -198,8 +198,7 @@ import scala.language.implicitConversions
  *  @define orderDependentFold
  *  @define willTerminateInf Note: lazily evaluated; will terminate for infinite-sized collections.
  */
-@deprecatedInheritance("This class will be sealed.", "2.11.0")
-abstract class Stream[+A] extends AbstractSeq[A]
+sealed abstract class Stream[+A] extends AbstractSeq[A]
                              with LinearSeq[A]
                              with GenericTraversableTemplate[A, Stream]
                              with LinearSeqOptimized[A, Stream[A]]
diff --git a/src/library/scala/collection/immutable/TreeMap.scala b/src/library/scala/collection/immutable/TreeMap.scala
index b845b76026..2d1bf0f6b1 100644
--- a/src/library/scala/collection/immutable/TreeMap.scala
+++ b/src/library/scala/collection/immutable/TreeMap.scala
@@ -44,8 +44,7 @@ object TreeMap extends ImmutableSortedMapFactory[TreeMap] {
  *  @define mayNotTerminateInf
  *  @define willNotTerminateInf
  */
-@deprecatedInheritance("The implementation details of immutable tree maps make inheriting from them unwise.", "2.11.0")
-class TreeMap[A, +B] private (tree: RB.Tree[A, B])(implicit val ordering: Ordering[A])
+final class TreeMap[A, +B] private (tree: RB.Tree[A, B])(implicit val ordering: Ordering[A])
   extends SortedMap[A, B]
      with SortedMapLike[A, B, TreeMap[A, B]]
      with MapLike[A, B, TreeMap[A, B]]
diff --git a/src/library/scala/collection/immutable/TreeSet.scala b/src/library/scala/collection/immutable/TreeSet.scala
index 2800030d67..2cdf3b3521 100644
--- a/src/library/scala/collection/immutable/TreeSet.scala
+++ b/src/library/scala/collection/immutable/TreeSet.scala
@@ -49,8 +49,7 @@ object TreeSet extends ImmutableSortedSetFactory[TreeSet] {
  *  @define willNotTerminateInf
  */
 @SerialVersionUID(-5685982407650748405L)
-@deprecatedInheritance("The implementation details of immutable tree sets make inheriting from them unwise.", "2.11.0")
-class TreeSet[A] private (tree: RB.Tree[A, Unit])(implicit val ordering: Ordering[A])
+final class TreeSet[A] private (tree: RB.Tree[A, Unit])(implicit val ordering: Ordering[A])
   extends SortedSet[A] with SortedSetLike[A, TreeSet[A]] with Serializable {
 
   if (ordering eq null)
diff --git a/src/library/scala/collection/immutable/WrappedString.scala b/src/library/scala/collection/immutable/WrappedString.scala
index 7592316650..8726bd2ed9 100644
--- a/src/library/scala/collection/immutable/WrappedString.scala
+++ b/src/library/scala/collection/immutable/WrappedString.scala
@@ -29,8 +29,7 @@ import mutable.{Builder, StringBuilder}
  *  @define Coll `WrappedString`
  *  @define coll wrapped string
  */
-@deprecatedInheritance("Inherit from StringLike instead of WrappedString.", "2.11.0")
-class WrappedString(val self: String) extends AbstractSeq[Char] with IndexedSeq[Char] with StringLike[WrappedString] {
+final class WrappedString(val self: String) extends AbstractSeq[Char] with IndexedSeq[Char] with StringLike[WrappedString] {
 
   override protected[this] def thisCollection: WrappedString = this
   override protected[this] def toCollection(repr: WrappedString): WrappedString = repr
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)
+}
diff --git a/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala b/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala
index 5e4572da60..d53b56d484 100644
--- a/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala
+++ b/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala
@@ -10,18 +10,12 @@ package scala
 package collection.parallel.mutable
 
 import scala.collection.mutable.ArraySeq
-import scala.collection.mutable.UnrolledBuffer
+import scala.collection.mutable.DoublingUnrolledBuffer
 import scala.collection.mutable.UnrolledBuffer.Unrolled
 import scala.collection.parallel.Combiner
 import scala.collection.parallel.Task
 import scala.reflect.ClassTag
 
-// Todo -- revisit whether inheritance is the best way to achieve this functionality
-private[mutable] 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 Unrolled[T](0, new Array[T](4), null, this)
-}
-
 
 /** An array combiner that uses doubling unrolled buffers to store elements. */
 trait UnrolledParArrayCombiner[T]
diff --git a/test/files/pos/virtpatmat_exist1.scala b/test/files/pos/virtpatmat_exist1.scala
index 6cad017b0b..1f24892489 100644
--- a/test/files/pos/virtpatmat_exist1.scala
+++ b/test/files/pos/virtpatmat_exist1.scala
@@ -1,5 +1,6 @@
 import annotation.unchecked.{ uncheckedVariance=> uV }
-import scala.collection.immutable.{ListMap, HashMap, ListSet, HashSet}
+import scala.collection.immutable.{ListMap, ListSet}
+import scala.collection.mutable.{HashMap, HashSet}
 
 object Test {
   class HashMapCollision1[A, +B](var hash: Int, var kvs: ListMap[A, B @uV]) extends HashMap[A, B @uV]