Merge remote-tracking branch 'upstream/2.12.x' into opt/heuristics

23 files changed, 119 insertions, 336 deletions

diff --git a/src/library/scala/AnyVal.scala b/src/library/scala/AnyVal.scala
index ff62948413..fb3d213e19 100644
--- a/src/library/scala/AnyVal.scala
+++ b/src/library/scala/AnyVal.scala
@@ -49,7 +49,7 @@ package scala
  * It's important to note that user-defined value classes are limited, and in some circumstances,
  * still must allocate a value class instance at runtime. These limitations and circumstances are
  * explained in greater detail in the [[http://docs.scala-lang.org/overviews/core/value-classes.html Value Classes Guide]]
- * as well as in [[http://docs.scala-lang.org/sips/pending/value-classes.html SIP-15: Value Classes]],
+ * as well as in [[http://docs.scala-lang.org/sips/completed/value-classes.html SIP-15: Value Classes]],
  * the Scala Improvement Proposal.
  */
 abstract class AnyVal extends Any {
diff --git a/src/library/scala/Equals.scala b/src/library/scala/Equals.scala
index f2f9ead44c..e06557ccdd 100644
--- a/src/library/scala/Equals.scala
+++ b/src/library/scala/Equals.scala
@@ -13,8 +13,9 @@ package scala
  */
 trait Equals extends Any {
   /** A method that should be called from every well-designed equals method
-   *  that is open to be overridden in a subclass. See Programming in Scala,
-   *  Chapter 28 for discussion and design.
+   *  that is open to be overridden in a subclass. See
+   *  [[http://www.artima.com/pins1ed/object-equality.html Programming in Scala,
+   *  Chapter 28]] for discussion and design.
    *
    *  @param    that    the value being probed for possible equality
    *  @return   true if this instance can possibly equal `that`, otherwise false
diff --git a/src/library/scala/Option.scala b/src/library/scala/Option.scala
index f134f5ce3d..7282feebb6 100644
--- a/src/library/scala/Option.scala
+++ b/src/library/scala/Option.scala
@@ -270,7 +270,7 @@ sealed abstract class Option[+A] extends Product with Serializable {
    *  // Returns None because the partial function doesn't cover the case.
    *  Some("ftp") collect {case "http" => "HTTP"}
    *
-   *  // Returns None because None is passed to the collect method.
+   *  // Returns None because the option is empty. There is no value to pass to the partial function.
    *  None collect {case value => value}
    *  }}}
    *
diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala
index fa58015a84..334377e838 100644
--- a/src/library/scala/Predef.scala
+++ b/src/library/scala/Predef.scala
@@ -56,7 +56,7 @@ import scala.io.StdIn
  *  only contain natural numbers (i.e. non-negative), and that the result returned
  *  will also be natural. `require` is distinct from `assert` in that if the
  *  condition fails, then the caller of the function is to blame rather than a
- *  logical error having been made within `addNaturals` itself. `ensures` is a
+ *  logical error having been made within `addNaturals` itself. `ensuring` is a
  *  form of `assert` that declares the guarantee the function is providing with
  *  regards to its return value.
  *
diff --git a/src/library/scala/annotation/implicitAmbiguous.scala b/src/library/scala/annotation/implicitAmbiguous.scala
new file mode 100644
index 0000000000..46eab9ae8f
--- /dev/null
+++ b/src/library/scala/annotation/implicitAmbiguous.scala
@@ -0,0 +1,34 @@
+package scala.annotation
+
+import scala.annotation.meta._
+
+/**
+  * To customize the error message that's emitted when an implicit of type
+  * C[T1,..., TN] is found more than once, annotate the class C
+  * with @implicitAmbiguous. Assuming C has type parameters X1,..., XN, the
+  * error message will be the result of replacing all occurrences of ${Xi} in
+  * the string msg with the string representation of the corresponding type
+  * argument Ti. *
+  *
+  * If more than one @implicitAmbiguous annotation is collected, the compiler is
+  * free to pick any of them to display.
+  *
+  * Nice errors can direct users to fix imports or even tell them why code
+  * intentionally doesn't compile.
+  *
+  * {{{
+  * trait =!=[C, D]
+  *
+  * implicit def neq[E, F] : E =!= F = null
+  *
+  * @annotation.implicitAmbiguous("Could not prove ${J} =!= ${J}")
+  * implicit def neqAmbig1[G, H, J] : J =!= J = null
+  * implicit def neqAmbig2[I] : I =!= I = null
+  *
+  * implicitly[Int =!= Int]
+  * }}}
+  *
+  * @author Brian McKenna
+  * @since 2.12.0
+  */
+final class implicitAmbiguous(msg: String) extends scala.annotation.StaticAnnotation {}
diff --git a/src/library/scala/collection/immutable/HashSet.scala b/src/library/scala/collection/immutable/HashSet.scala
index 49b4397cf2..603d97c3ad 100644
--- a/src/library/scala/collection/immutable/HashSet.scala
+++ b/src/library/scala/collection/immutable/HashSet.scala
@@ -162,13 +162,6 @@ class HashSet[A] extends AbstractSet[A]
   def - (e: A): HashSet[A] =
     nullToEmpty(removed0(e, computeHash(e), 0))
 
-  /** Returns this $coll as an immutable set.
-   *  
-   *  A new set will not be built; lazy collections will stay lazy.
-   */
-  @deprecatedOverriding("Immutable sets should do nothing on toSet but return themselves cast as a Set.", "2.11.0")
-  override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set[B]]
-
   override def filter(p: A => Boolean) = {
     val buffer = new Array[HashSet[A]](bufferSize(size))
     nullToEmpty(filter0(p, false, 0, buffer, 0))
@@ -201,6 +194,7 @@ class HashSet[A] extends AbstractSet[A]
 
   protected def writeReplace(): AnyRef = new HashSet.SerializationProxy(this)
 
+  override def toSet[B >: A]: Set[B] = this.asInstanceOf[HashSet[B]]
 }
 
 /** $factoryInfo
diff --git a/src/library/scala/collection/immutable/ListSet.scala b/src/library/scala/collection/immutable/ListSet.scala
index a6e6fba0a5..adc975479a 100644
--- a/src/library/scala/collection/immutable/ListSet.scala
+++ b/src/library/scala/collection/immutable/ListSet.scala
@@ -138,13 +138,6 @@ class ListSet[A] extends AbstractSet[A]
 
   override def stringPrefix = "ListSet"
 
-  /** Returns this $coll as an immutable set.
-   *  
-   *  A new set will not be built; lazy collections will stay lazy.
-   */
-  @deprecatedOverriding("Immutable sets should do nothing on toSet but return themselves cast as a Set.", "2.11.0")
-  override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set[B]]
-
   /** Represents an entry in the `ListSet`.
    */
   protected class Node(override val head: A) extends ListSet[A] with Serializable {
@@ -186,4 +179,6 @@ class ListSet[A] extends AbstractSet[A]
 
     override def tail: ListSet[A] = self
   }
+  
+  override def toSet[B >: A]: Set[B] = this.asInstanceOf[ListSet[B]]
 }
diff --git a/src/library/scala/collection/immutable/MapLike.scala b/src/library/scala/collection/immutable/MapLike.scala
index 94a5b7929a..bd5b9c9faf 100644
--- a/src/library/scala/collection/immutable/MapLike.scala
+++ b/src/library/scala/collection/immutable/MapLike.scala
@@ -113,6 +113,11 @@ self =>
     override def - (elem: A): immutable.Set[A] =
       if (this(elem)) immutable.Set[A]() ++ this - elem
       else this
+      
+    // ImmutableDefaultKeySet is only protected, so we won't warn on override.
+    // Someone could override in a way that makes widening not okay
+    // (e.g. by overriding +, though the version in this class is fine)
+    override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set[B]]
   }
 
   /** This function transforms all the values of mappings contained
diff --git a/src/library/scala/collection/immutable/Set.scala b/src/library/scala/collection/immutable/Set.scala
index 7725ad9ee3..a115469b83 100644
--- a/src/library/scala/collection/immutable/Set.scala
+++ b/src/library/scala/collection/immutable/Set.scala
@@ -35,7 +35,22 @@ trait Set[A] extends Iterable[A]
   override def companion: GenericCompanion[Set] = Set
   
   
-  override def toSet[B >: A]: Set[B] = to[({type l[a] = immutable.Set[B]})#l] // for bincompat; remove in dev
+  /** Returns this $coll as an immutable set, perhaps accepting a
+   *  wider range of elements.  Since it already is an
+   *  immutable set, it will only be rebuilt if the underlying structure
+   *  cannot be expanded to include arbitrary element types.
+   *  For instance, `BitSet` and `SortedSet` will be rebuilt, as
+   *  they require `Int` and sortable elements respectively.
+   *
+   *  When in doubt, the set will be rebuilt.  Rebuilt sets never
+   *  need to be rebuilt again.
+   */
+  override def toSet[B >: A]: Set[B] = {
+      // This way of building sets typically has the best benchmarks, surprisingly!
+    val sb = Set.newBuilder[B]
+    foreach(sb += _)
+    sb.result()
+  }
   
   override def seq: Set[A] = this
   protected override def parCombiner = ParSet.newCombiner[A] // if `immutable.SetLike` gets introduced, please move this there!
@@ -88,8 +103,10 @@ object Set extends ImmutableSetFactory[Set] {
       if (f(elem1)) Some(elem1)
       else None
     }
-    @deprecatedOverriding("Immutable sets should do nothing on toSet but return themselves cast as a Set.", "2.11.0")
-    override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set[B]]
+    // Why is Set1 non-final?  Need to fix that!
+    @deprecatedOverriding("This immutable set should do nothing on toSet but cast itself to a Set with a wider element type.", "2.11.8")
+    override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set1[B]]
+
   }
 
   /** An optimized representation for immutable sets of size 2 */
@@ -121,8 +138,9 @@ object Set extends ImmutableSetFactory[Set] {
       else if (f(elem2)) Some(elem2)
       else None
     }
-    @deprecatedOverriding("Immutable sets should do nothing on toSet but return themselves cast as a Set.", "2.11.0")
-    override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set[B]]
+    // Why is Set2 non-final?  Need to fix that!
+    @deprecatedOverriding("This immutable set should do nothing on toSet but cast itself to a Set with a wider element type.", "2.11.8")
+    override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set2[B]]
   }
 
   /** An optimized representation for immutable sets of size 3 */
@@ -156,8 +174,9 @@ object Set extends ImmutableSetFactory[Set] {
       else if (f(elem3)) Some(elem3)
       else None
     }
-    @deprecatedOverriding("Immutable sets should do nothing on toSet but return themselves cast as a Set.", "2.11.0")
-    override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set[B]]
+    // Why is Set3 non-final?  Need to fix that!
+    @deprecatedOverriding("This immutable set should do nothing on toSet but cast itself to a Set with a wider element type.", "2.11.8")
+    override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set3[B]]
   }
 
   /** An optimized representation for immutable sets of size 4 */
@@ -193,8 +212,9 @@ object Set extends ImmutableSetFactory[Set] {
       else if (f(elem4)) Some(elem4)
       else None
     }
-    @deprecatedOverriding("Immutable sets should do nothing on toSet but return themselves cast as a Set.", "2.11.0")
-    override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set[B]]
+    // Why is Set4 non-final?  Need to fix that!
+    @deprecatedOverriding("This immutable set should do nothing on toSet but cast itself to a Set with a wider element type.", "2.11.8")
+    override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set4[B]]
   }
 }
 
diff --git a/src/library/scala/collection/immutable/SortedMap.scala b/src/library/scala/collection/immutable/SortedMap.scala
index f1493551ab..682788e18e 100644
--- a/src/library/scala/collection/immutable/SortedMap.scala
+++ b/src/library/scala/collection/immutable/SortedMap.scala
@@ -53,6 +53,12 @@ self =>
       val map = self.rangeImpl(from, until)
       new map.DefaultKeySortedSet
     }
+    override def toSet[C >: A]: Set[C] = {
+      // This way of building sets typically has the best benchmarks, surprisingly!
+      val sb = Set.newBuilder[C]
+      foreach(sb += _)
+      sb.result()
+    }
   }
 
   /** Add a key/value pair to this map.
diff --git a/src/library/scala/collection/mutable/AVLTree.scala b/src/library/scala/collection/mutable/AVLTree.scala
deleted file mode 100644
index b63d0aae33..0000000000
--- a/src/library/scala/collection/mutable/AVLTree.scala
+++ /dev/null
@@ -1,250 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2013, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-
-package scala
-package collection
-package mutable
-
-/**
- * An immutable AVL Tree implementation formerly used by mutable.TreeSet
- *
- * @author Lucien Pereira
- */
-@deprecated("AVLTree and its related classes are being removed from the standard library since they're not different enough from RedBlackTree to justify keeping them.", "2.11.2")
-private[mutable] sealed trait AVLTree[+A] extends Serializable {
-  def balance: Int
-
-  def depth: Int
-
-  def iterator[B >: A]: Iterator[B] = Iterator.empty
-
-  def contains[B >: A](value: B, ordering: Ordering[B]): Boolean = false
-
-  /**
-   * Returns a new tree containing the given element.
-   * Throws an IllegalArgumentException if element is already present.
-   *
-   */
-  def insert[B >: A](value: B, ordering: Ordering[B]): AVLTree[B] = Node(value, Leaf, Leaf)
-
-  /**
-   * Return a new tree which not contains given element.
-   *
-   */
-  def remove[B >: A](value: B, ordering: Ordering[B]): AVLTree[A] =
-    throw new NoSuchElementException(String.valueOf(value))
-
-  /**
-   * Return a tuple containing the smallest element of the provided tree
-   * and a new tree from which this element has been extracted.
-   *
-   */
-  def removeMin[B >: A]: (B, AVLTree[B]) = sys.error("Should not happen.")
-
-  /**
-   * Return a tuple containing the biggest element of the provided tree
-   * and a new tree from which this element has been extracted.
-   *
-   */
-  def removeMax[B >: A]: (B, AVLTree[B]) = sys.error("Should not happen.")
-
-  def rebalance[B >: A]: AVLTree[B] = this
-
-  def leftRotation[B >: A]: Node[B] = sys.error("Should not happen.")
-
-  def rightRotation[B >: A]: Node[B] = sys.error("Should not happen.")
-
-  def doubleLeftRotation[B >: A]: Node[B] = sys.error("Should not happen.")
-
-  def doubleRightRotation[B >: A]: Node[B] = sys.error("Should not happen.")
-}
-
-/**
- * @deprecated("AVLTree and its related classes are being removed from the standard library since they're not different enough from RedBlackTree to justify keeping them.", "2.11.0")
- */
-private case object Leaf extends AVLTree[Nothing] {
-  override val balance: Int = 0
-
-  override val depth: Int = -1
-}
-
-/**
- * @deprecated("AVLTree and its related classes are being removed from the standard library since they're not different enough from RedBlackTree to justify keeping them.", "2.11.0")
- */
-private case class Node[A](data: A, left: AVLTree[A], right: AVLTree[A]) extends AVLTree[A] {
-  override val balance: Int = right.depth - left.depth
-
-  override val depth: Int = math.max(left.depth, right.depth) + 1
-
-  override def iterator[B >: A]: Iterator[B] = new AVLIterator(this)
-
-  override def contains[B >: A](value: B, ordering: Ordering[B]) = {
-    val ord = ordering.compare(value, data)
-    if (0 == ord)
-      true
-    else if (ord < 0)
-      left.contains(value, ordering)
-    else
-      right.contains(value, ordering)
-  }
-
-  /**
-   * Returns a new tree containing the given element.
-   * Throws an IllegalArgumentException if element is already present.
-   *
-   */
-  override def insert[B >: A](value: B, ordering: Ordering[B]) = {
-    val ord = ordering.compare(value, data)
-    if (0 == ord)
-      throw new IllegalArgumentException()
-    else if (ord < 0)
-      Node(data, left.insert(value, ordering), right).rebalance
-    else
-      Node(data, left, right.insert(value, ordering)).rebalance
-  }
-
-  /**
-   * Return a new tree which not contains given element.
-   *
-   */
-  override def remove[B >: A](value: B, ordering: Ordering[B]): AVLTree[A] = {
-    val ord = ordering.compare(value, data)
-    if(ord == 0) {
-      if (Leaf == left) {
-        if (Leaf == right) {
-          Leaf
-        } else {
-          val (min, newRight) = right.removeMin
-          Node(min, left, newRight).rebalance
-        }
-      } else {
-        val (max, newLeft) = left.removeMax
-        Node(max, newLeft, right).rebalance
-      }
-    } else if (ord < 0) {
-      Node(data, left.remove(value, ordering), right).rebalance
-    } else {
-      Node(data, left, right.remove(value, ordering)).rebalance
-    }
-  }
-
-  /**
-   * Return a tuple containing the smallest element of the provided tree
-   * and a new tree from which this element has been extracted.
-   *
-   */
-  override def removeMin[B >: A]: (B, AVLTree[B]) = {
-    if (Leaf == left)
-      (data, right)
-    else {
-      val (min, newLeft) = left.removeMin
-      (min, Node(data, newLeft, right).rebalance)
-    }
-  }
-
-  /**
-   * Return a tuple containing the biggest element of the provided tree
-   * and a new tree from which this element has been extracted.
-   *
-   */
-  override def removeMax[B >: A]: (B, AVLTree[B]) = {
-    if (Leaf == right)
-      (data, left)
-    else {
-      val (max, newRight) = right.removeMax
-      (max, Node(data, left, newRight).rebalance)
-    }
-  }
-
-  override def rebalance[B >: A] = {
-    if (-2 == balance) {
-      if (1 == left.balance)
-        doubleRightRotation
-      else
-        rightRotation
-    } else if (2 == balance) {
-      if (-1 == right.balance)
-        doubleLeftRotation
-      else
-        leftRotation
-    } else {
-      this
-    }
-  }
-
-  override def leftRotation[B >: A] = {
-    if (Leaf != right) {
-      val r: Node[A] = right.asInstanceOf[Node[A]]
-      Node(r.data, Node(data, left, r.left), r.right)
-    } else sys.error("Should not happen.")
-  }
-
-  override def rightRotation[B >: A] = {
-    if (Leaf != left) {
-      val l: Node[A] = left.asInstanceOf[Node[A]]
-      Node(l.data, l.left, Node(data, l.right, right))
-    } else sys.error("Should not happen.")
-  }
-
-  override def doubleLeftRotation[B >: A] = {
-    if (Leaf != right) {
-      val r: Node[A] = right.asInstanceOf[Node[A]]
-      // Let's save an instanceOf by 'inlining' the left rotation
-      val rightRotated = r.rightRotation
-      Node(rightRotated.data, Node(data, left, rightRotated.left), rightRotated.right)
-    } else sys.error("Should not happen.")
-  }
-
-  override def doubleRightRotation[B >: A] = {
-    if (Leaf != left) {
-      val l: Node[A] = left.asInstanceOf[Node[A]]
-      // Let's save an instanceOf by 'inlining' the right rotation
-      val leftRotated = l.leftRotation
-      Node(leftRotated.data, leftRotated.left, Node(data, leftRotated.right, right))
-    } else sys.error("Should not happen.")
-  }
-}
-
-/**
- * @deprecated("AVLTree and its related classes are being removed from the standard library since they're not different enough from RedBlackTree to justify keeping them.", "2.11.0")
- */
-private class AVLIterator[A](root: Node[A]) extends Iterator[A] {
-  val stack = mutable.ArrayStack[Node[A]](root)
-  diveLeft()
-
-  private def diveLeft(): Unit = {
-    if (Leaf != stack.head.left) {
-      val left: Node[A] = stack.head.left.asInstanceOf[Node[A]]
-      stack.push(left)
-      diveLeft()
-    }
-  }
-
-  private def engageRight(): Unit = {
-    if (Leaf != stack.head.right) {
-      val right: Node[A] = stack.head.right.asInstanceOf[Node[A]]
-      stack.pop()
-      stack.push(right)
-      diveLeft()
-    } else
-      stack.pop()
-  }
-
-  override def hasNext: Boolean = !stack.isEmpty
-
-  override def next(): A = {
-    if (stack.isEmpty)
-      throw new NoSuchElementException()
-    else {
-      val result = stack.head.data
-      // Let's maintain stack for the next invocation
-      engageRight()
-      result
-    }
-  }
-}
diff --git a/src/library/scala/collection/mutable/PriorityQueue.scala b/src/library/scala/collection/mutable/PriorityQueue.scala
index 619beeb1d6..e6889da3b5 100644
--- a/src/library/scala/collection/mutable/PriorityQueue.scala
+++ b/src/library/scala/collection/mutable/PriorityQueue.scala
@@ -18,8 +18,19 @@ import generic._
  *
  *  Only the `dequeue` and `dequeueAll` methods will return elements in priority
  *  order (while removing elements from the heap).  Standard collection methods
- *  including `drop` and `iterator` will remove or traverse the heap in whichever
- *  order seems most convenient.
+ *  including `drop`, `iterator`, and `toString` will remove or traverse the heap
+ *  in whichever order seems most convenient.
+ *
+ *  Therefore, printing a `PriorityQueue` will not reveal the priority order of
+ *  the elements, though the highest-priority element will be printed first.  To
+ *  print the elements in order, one must duplicate the `PriorityQueue` (by using
+ *  `clone`, for instance) and then dequeue them:
+ *
+ *  @example {{{
+ *  val pq = collection.mutable.PriorityQueue(1, 2, 5, 3, 7)
+ *  println(pq)                  // elements probably not in order
+ *  println(pq.clone.dequeueAll) // prints Vector(7, 5, 3, 2, 1)
+ *  }}}
  *
  *  @tparam A    type of the elements in this priority queue.
  *  @param ord   implicit ordering used to compare the elements of type `A`.
diff --git a/src/library/scala/concurrent/SyncVar.scala b/src/library/scala/concurrent/SyncVar.scala
index 9634f6d900..1ee27b0f36 100644
--- a/src/library/scala/concurrent/SyncVar.scala
+++ b/src/library/scala/concurrent/SyncVar.scala
@@ -40,7 +40,7 @@ class SyncVar[A] {
     wait(timeout)
     val elapsed = System.nanoTime() - start
     // nanoTime should be monotonic, but it's not possible to rely on that.
-    // See http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6458294.
+    // See http://bugs.java.com/bugdatabase/view_bug.do?bug_id=6458294.
     if (elapsed < 0) 0 else TimeUnit.NANOSECONDS.toMillis(elapsed)
   }
 
diff --git a/src/library/scala/concurrent/impl/Promise.scala b/src/library/scala/concurrent/impl/Promise.scala
index 078ad45be9..3538ac6b94 100644
--- a/src/library/scala/concurrent/impl/Promise.scala
+++ b/src/library/scala/concurrent/impl/Promise.scala
@@ -178,7 +178,9 @@ private[concurrent] object Promise {
    * DefaultPromises, and `linkedRootOf` is currently only designed to be called
    * by Future.flatMap.
    */
-  final class DefaultPromise[T] extends AtomicReference[AnyRef](Nil) with Promise[T] {
+  // Left non-final to enable addition of extra fields by Java/Scala converters
+  // in scala-java8-compat.
+  class DefaultPromise[T] extends AtomicReference[AnyRef](Nil) with Promise[T] {
 
     /** Get the root promise for this promise, compressing the link chain to that
      *  promise if necessary.
@@ -248,12 +250,12 @@ private[concurrent] object Promise {
 
     @throws(classOf[TimeoutException])
     @throws(classOf[InterruptedException])
-    def ready(atMost: Duration)(implicit permit: CanAwait): this.type =
+    final def ready(atMost: Duration)(implicit permit: CanAwait): this.type =
       if (tryAwait(atMost)) this
       else throw new TimeoutException("Futures timed out after [" + atMost + "]")
 
     @throws(classOf[Exception])
-    def result(atMost: Duration)(implicit permit: CanAwait): T =
+    final def result(atMost: Duration)(implicit permit: CanAwait): T =
       ready(atMost).value.get.get // ready throws TimeoutException if timeout so value.get is safe here
 
     def value: Option[Try[T]] = value0
@@ -265,7 +267,7 @@ private[concurrent] object Promise {
       case _ => None
     }
 
-    override def isCompleted: Boolean = isCompleted0
+    override final def isCompleted: Boolean = isCompleted0
 
     @tailrec
     private def isCompleted0: Boolean = get() match {
@@ -274,7 +276,7 @@ private[concurrent] object Promise {
       case _ => false
     }
 
-    def tryComplete(value: Try[T]): Boolean = {
+    final def tryComplete(value: Try[T]): Boolean = {
       val resolved = resolveTry(value)
       tryCompleteAndGetListeners(resolved) match {
         case null             => false
@@ -297,7 +299,7 @@ private[concurrent] object Promise {
       }
     }
 
-    def onComplete[U](func: Try[T] => U)(implicit executor: ExecutionContext): Unit =
+    final def onComplete[U](func: Try[T] => U)(implicit executor: ExecutionContext): Unit =
       dispatchOrAddCallback(new CallbackRunnable[T](executor.prepare(), func))
 
     /** Tries to add the callback, if already completed, it dispatches the callback to be executed.
diff --git a/src/library/scala/concurrent/util/Unsafe.java b/src/library/scala/concurrent/util/Unsafe.java
deleted file mode 100644
index 73739e377d..0000000000
--- a/src/library/scala/concurrent/util/Unsafe.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2013, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-
-package scala.concurrent.util;
-import java.lang.reflect.Field;
-
-// TODO: remove once akka no longer needs it, hopefully by 2.12.0-M3!
-@Deprecated
-public final class Unsafe {
-  @Deprecated
-  public final static sun.misc.Unsafe instance;
-  static {
-    try {
-      sun.misc.Unsafe found = null;
-      for(Field field : sun.misc.Unsafe.class.getDeclaredFields()) {
-        if (field.getType() == sun.misc.Unsafe.class) {
-          field.setAccessible(true);
-          found = (sun.misc.Unsafe) field.get(null);
-          break;
-        }
-      }
-      if (found == null) throw new IllegalStateException("Can't find instance of sun.misc.Unsafe");
-      else instance = found;
-    } catch(Throwable t) {
-      throw new ExceptionInInitializerError(t);
-    }
-  }
-}
-
-// Scala version:
-// classOf[sun.misc.Unsafe].getDeclaredFields.filter(_.getType == classOf[sun.misc.Unsafe]).headOption.map { field =>
-//   field.setAccessible(true); field.get(null).asInstanceOf[sun.misc.Unsafe]
-// } getOrElse (throw new IllegalStateException("Can't find instance of sun.misc.Unsafe"))
diff --git a/src/library/scala/io/Codec.scala b/src/library/scala/io/Codec.scala
index 60f99199cb..2a41e25b01 100644
--- a/src/library/scala/io/Codec.scala
+++ b/src/library/scala/io/Codec.scala
@@ -22,7 +22,7 @@ import scala.language.implicitConversions
 //   <?xml version="1.0" encoding="ISO8859-1" ?>
 //
 // MacRoman vs. UTF-8: see http://jira.codehaus.org/browse/JRUBY-3576
-// -Dfile.encoding: see http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4375816
+// -Dfile.encoding: see http://bugs.java.com/bugdatabase/view_bug.do?bug_id=4375816
 
 /** A class for character encoding/decoding preferences.
  *
diff --git a/src/library/scala/reflect/ClassManifestDeprecatedApis.scala b/src/library/scala/reflect/ClassManifestDeprecatedApis.scala
index ca7a3cddb8..82ec872806 100644
--- a/src/library/scala/reflect/ClassManifestDeprecatedApis.scala
+++ b/src/library/scala/reflect/ClassManifestDeprecatedApis.scala
@@ -218,7 +218,7 @@ object ClassManifestFactory {
   /** ClassManifest for the abstract type `prefix # name`. `upperBound` is not
     * strictly necessary as it could be obtained by reflection. It was
     * added so that erasure can be calculated without reflection.
-    * todo: remove after next boostrap
+    * todo: remove after next bootstrap
     */
   def abstractType[T](prefix: OptManifest[_], name: String, upperbound: ClassManifest[_], args: OptManifest[_]*): ClassManifest[T] =
     new ClassManifest[T] {
@@ -239,4 +239,4 @@ private class ClassTypeManifest[T](
     (if (prefix.isEmpty) "" else prefix.get.toString+"#") +
     (if (runtimeClass.isArray) "Array" else runtimeClass.getName) +
     argString
-}
\ No newline at end of file
+}
diff --git a/src/library/scala/runtime/ScalaRunTime.scala b/src/library/scala/runtime/ScalaRunTime.scala
index a0d89fc0e1..026d5edd29 100644
--- a/src/library/scala/runtime/ScalaRunTime.scala
+++ b/src/library/scala/runtime/ScalaRunTime.scala
@@ -9,11 +9,10 @@
 package scala
 package runtime
 
-import scala.collection.{ Seq, IndexedSeq, TraversableView, AbstractIterator }
+import scala.collection.{ Seq, IndexedSeq, TraversableView, AbstractIterator, GenIterable }
 import scala.collection.mutable.WrappedArray
 import scala.collection.immutable.{ StringLike, NumericRange, List, Stream, Nil, :: }
 import scala.collection.generic.{ Sorted, IsTraversableLike }
-import scala.collection.parallel.ParIterable
 import scala.reflect.{ ClassTag, classTag }
 import scala.util.control.ControlThrowable
 import java.lang.{ Class => jClass }
@@ -156,7 +155,7 @@ object ScalaRunTime {
     arr
   }
 
-  // Java bug: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4071957
+  // Java bug: http://bugs.java.com/bugdatabase/view_bug.do?bug_id=4071957
   // More background at ticket #2318.
   def ensureAccessible(m: JMethod): JMethod = scala.reflect.ensureAccessible(m)
 
@@ -326,8 +325,7 @@ object ScalaRunTime {
       case x if useOwnToString(x)       => x.toString
       case x: AnyRef if isArray(x)      => arrayToString(x)
       case x: scala.collection.Map[_, _]      => x.iterator take maxElements map mapInner mkString (x.stringPrefix + "(", ", ", ")")
-      case x: Iterable[_]               => x.iterator take maxElements map inner mkString (x.stringPrefix + "(", ", ", ")")
-      case x: ParIterable[_]            => x.iterator take maxElements map inner mkString (x.stringPrefix + "(", ", ", ")")
+      case x: GenIterable[_]            => x.iterator take maxElements map inner mkString (x.stringPrefix + "(", ", ", ")")
       case x: Traversable[_]            => x take maxElements map inner mkString (x.stringPrefix + "(", ", ", ")")
       case x: Product1[_] if isTuple(x) => "(" + inner(x._1) + ",)" // that special trailing comma
       case x: Product if isTuple(x)     => x.productIterator map inner mkString ("(", ",", ")")
diff --git a/src/library/scala/runtime/Tuple2Zipped.scala b/src/library/scala/runtime/Tuple2Zipped.scala
index 512c4fbc27..1c432b0403 100644
--- a/src/library/scala/runtime/Tuple2Zipped.scala
+++ b/src/library/scala/runtime/Tuple2Zipped.scala
@@ -110,6 +110,8 @@ final class Tuple2Zipped[El1, Repr1, El2, Repr2](val colls: (TraversableLike[El1
         return
     }
   }
+
+  override def toString = "(%s, %s).zipped".format(colls._1.toString, colls._2.toString)
 }
 
 object Tuple2Zipped {
diff --git a/src/library/scala/runtime/Tuple3Zipped.scala b/src/library/scala/runtime/Tuple3Zipped.scala
index ffd44acf81..3bab86921b 100644
--- a/src/library/scala/runtime/Tuple3Zipped.scala
+++ b/src/library/scala/runtime/Tuple3Zipped.scala
@@ -118,6 +118,8 @@ final class Tuple3Zipped[El1, Repr1, El2, Repr2, El3, Repr3](val colls: (Travers
         return
     }
   }
+
+  override def toString: String = "(%s, %s, %s).zipped".format(colls._1.toString, colls._2.toString, colls._3.toString)
 }
 
 object Tuple3Zipped {
diff --git a/src/library/scala/sys/process/package.scala b/src/library/scala/sys/process/package.scala
index 5ec2e73cb9..0e9a1bfc56 100644
--- a/src/library/scala/sys/process/package.scala
+++ b/src/library/scala/sys/process/package.scala
@@ -157,7 +157,8 @@ package scala.sys {
     *     while(input.read() != -1) count += 1
     *     input.close()
     *   }
-    *   cat ! new ProcessIO(_.close(), byteCounter, _.close())
+    *   val p = cat run new ProcessIO(_.close(), byteCounter, _.close())
+    *   p.exitValue()
     *   count
     * }
     *
diff --git a/src/library/scala/util/Sorting.scala b/src/library/scala/util/Sorting.scala
index ee2bdbc4a7..b4f965f69b 100644
--- a/src/library/scala/util/Sorting.scala
+++ b/src/library/scala/util/Sorting.scala
@@ -88,7 +88,7 @@ object Sorting {
               a(pL - 1) = current
               pL -= 1
             case x if x < 0 =>
-              // Already in place.  Just update indicies.
+              // Already in place.  Just update indices.
               iA += 1
             case _ if iB > pR =>
               // Wrong side.  There's room on the other side, so swap
diff --git a/src/library/scala/util/control/Exception.scala b/src/library/scala/util/control/Exception.scala
index aa30887ba0..24c297a2fc 100644
--- a/src/library/scala/util/control/Exception.scala
+++ b/src/library/scala/util/control/Exception.scala
@@ -105,7 +105,7 @@ object Exception {
         case x if rethrow(x)        => throw x
         case x if pf isDefinedAt x  => pf(x)
       }
-      finally fin map (_.invoke())
+      finally fin foreach (_.invoke())
 
     /* Create an empty Try container with this Catch and the supplied `Finally`. */
     def andFinally(body: => Unit): Catch[T] = fin match {