Merge remote-tracking branch 'origin/2.10.x' into fix-duration-issues-RK

16 files changed, 215 insertions, 111 deletions

diff --git a/src/library/scala/collection/GenIterableViewLike.scala b/src/library/scala/collection/GenIterableViewLike.scala
index 9e3927eaf4..142561df20 100644
--- a/src/library/scala/collection/GenIterableViewLike.scala
+++ b/src/library/scala/collection/GenIterableViewLike.scala
@@ -25,6 +25,7 @@ self =>
     def iterator: Iterator[B]
     override def foreach[U](f: B => U): Unit = iterator foreach f
     override def toString = viewToString
+    override def isEmpty = !iterator.hasNext
   }
 
   trait EmptyView extends Transformed[Nothing] with super.EmptyView {
diff --git a/src/library/scala/concurrent/Awaitable.scala b/src/library/scala/concurrent/Awaitable.scala
index 99bdfbc5a9..655115349a 100644
--- a/src/library/scala/concurrent/Awaitable.scala
+++ b/src/library/scala/concurrent/Awaitable.scala
@@ -16,15 +16,34 @@ import scala.concurrent.util.Duration
 
 trait Awaitable[+T] {
   /**
-   * Should throw [[scala.concurrent.TimeoutException]] if it times out
+   * Await the "resolved" state of this Awaitable.
    * This method should not be called directly.
+   *
+   * @param atMost
+   *        maximum wait time, which may be negative (no waiting is done),
+   *        [[Duration.Inf]] for unbounded waiting, or a finite positive
+   *        duration
+   * @return the Awaitable itself
+   * @throws InterruptedException     if the wait call was interrupted
+   * @throws TimeoutException         if after waiting for the specified time this Awaitable is still not ready
+   * @throws IllegalArgumentException if `atMost` is [[Duration.Undefined]]
    */
   @throws(classOf[TimeoutException])
+  @throws(classOf[InterruptedException])
   def ready(atMost: Duration)(implicit permit: CanAwait): this.type
   
   /**
-   * Throws exceptions if it cannot produce a T within the specified time.
+   * Await and return the result of this Awaitable, which is either of type T or a thrown exception (any Throwable).
    * This method should not be called directly.
+   *
+   * @param atMost
+   *        maximum wait time, which may be negative (no waiting is done),
+   *        [[Duration.Inf]] for unbounded waiting, or a finite positive
+   *        duration
+   * @return the value if the Awaitable was successful within the specific maximum wait time
+   * @throws InterruptedException     if the wait call was interrupted
+   * @throws TimeoutException         if after waiting for the specified time this Awaitable is still not ready
+   * @throws IllegalArgumentException if `atMost` is [[Duration.Undefined]]
    */
   @throws(classOf[Exception])
   def result(atMost: Duration)(implicit permit: CanAwait): T
diff --git a/src/library/scala/concurrent/BlockContext.scala b/src/library/scala/concurrent/BlockContext.scala
index 640560a174..83333a9e94 100644
--- a/src/library/scala/concurrent/BlockContext.scala
+++ b/src/library/scala/concurrent/BlockContext.scala
@@ -8,9 +8,6 @@
 
 package scala.concurrent
 
-import java.lang.Thread
-import scala.concurrent.util.Duration
-
 /**
  * A context to be notified by `scala.concurrent.blocking` when
  * a thread is about to block. In effect this trait provides
diff --git a/src/library/scala/concurrent/ExecutionContext.scala b/src/library/scala/concurrent/ExecutionContext.scala
index 1be6050303..844ec14241 100644
--- a/src/library/scala/concurrent/ExecutionContext.scala
+++ b/src/library/scala/concurrent/ExecutionContext.scala
@@ -10,7 +10,6 @@ package scala.concurrent
 
 
 import java.util.concurrent.{ ExecutorService, Executor }
-import scala.concurrent.util.Duration
 import scala.annotation.implicitNotFound
 import scala.util.Try
 
diff --git a/src/library/scala/concurrent/Future.scala b/src/library/scala/concurrent/Future.scala
index bc0b437a33..a5d9cdd5d1 100644
--- a/src/library/scala/concurrent/Future.scala
+++ b/src/library/scala/concurrent/Future.scala
@@ -16,7 +16,6 @@ import java.lang.{ Iterable => JIterable }
 import java.util.{ LinkedList => JLinkedList }
 import java.util.concurrent.atomic.{ AtomicReferenceFieldUpdater, AtomicInteger, AtomicBoolean }
 
-import scala.concurrent.util.Duration
 import scala.util.control.NonFatal
 import scala.Option
 import scala.util.{Try, Success, Failure}
diff --git a/src/library/scala/concurrent/impl/ExecutionContextImpl.scala b/src/library/scala/concurrent/impl/ExecutionContextImpl.scala
index 875a558887..c517a05a81 100644
--- a/src/library/scala/concurrent/impl/ExecutionContextImpl.scala
+++ b/src/library/scala/concurrent/impl/ExecutionContextImpl.scala
@@ -14,7 +14,6 @@ import java.util.concurrent.{ LinkedBlockingQueue, Callable, Executor, ExecutorS
 import java.util.Collection
 import scala.concurrent.forkjoin._
 import scala.concurrent.{ BlockContext, ExecutionContext, Awaitable, CanAwait, ExecutionContextExecutor, ExecutionContextExecutorService }
-import scala.concurrent.util.Duration
 import scala.util.control.NonFatal
 
 
diff --git a/src/library/scala/concurrent/impl/Promise.scala b/src/library/scala/concurrent/impl/Promise.scala
index b19bed004b..f7ab85dc0c 100644
--- a/src/library/scala/concurrent/impl/Promise.scala
+++ b/src/library/scala/concurrent/impl/Promise.scala
@@ -12,7 +12,7 @@ package scala.concurrent.impl
 
 import java.util.concurrent.TimeUnit.NANOSECONDS
 import scala.concurrent.{ ExecutionContext, CanAwait, OnCompleteRunnable, TimeoutException, ExecutionException }
-import scala.concurrent.util.Duration
+import scala.concurrent.util.{ Duration, Deadline }
 import scala.annotation.tailrec
 import scala.util.control.NonFatal
 import scala.util.{ Try, Success, Failure }
@@ -64,30 +64,41 @@ private[concurrent] object Promise {
     
     protected final def tryAwait(atMost: Duration): Boolean = {
       @tailrec
-      def awaitUnsafe(waitTimeNanos: Long): Boolean = {
-        if (value.isEmpty && waitTimeNanos > 0) {
-          val ms = NANOSECONDS.toMillis(waitTimeNanos)
-          val ns = (waitTimeNanos % 1000000l).toInt // as per object.wait spec
-          val start = System.nanoTime()
-          try {
-            synchronized {
-              if (!isCompleted) wait(ms, ns) // previously - this was a `while`, ending up in an infinite loop
-            }
-          } catch {
-            case e: InterruptedException =>
-          }
+      def awaitUnsafe(deadline: Deadline, nextWait: Duration): Boolean = {
+        if (!isCompleted && nextWait > Duration.Zero) {
+          val ms = nextWait.toMillis
+          val ns = (nextWait.toNanos % 1000000l).toInt // as per object.wait spec
+
+          synchronized { if (!isCompleted) wait(ms, ns) }
 
-          awaitUnsafe(waitTimeNanos - (System.nanoTime() - start))
+          awaitUnsafe(deadline, deadline.timeLeft)
         } else
           isCompleted
       }
-      awaitUnsafe(if (atMost.isFinite) atMost.toNanos else Long.MaxValue)
+      @tailrec
+      def awaitUnbounded(): Boolean = {
+        if (isCompleted) true
+        else {
+          synchronized { if (!isCompleted) wait() }
+          awaitUnbounded()
+        }
+      }
+
+      if (atMost eq Duration.Undefined)
+        throw new IllegalArgumentException("cannot wait for Undefined period")
+      else if (atMost <= Duration.Zero)
+        isCompleted
+      else if (atMost == Duration.Inf)
+        awaitUnbounded()
+      else
+        awaitUnsafe(atMost.fromNow, atMost)
     }
 
     @throws(classOf[TimeoutException])
+    @throws(classOf[InterruptedException])
     def ready(atMost: Duration)(implicit permit: CanAwait): this.type =
       if (isCompleted || tryAwait(atMost)) this
-      else throw new TimeoutException("Futures timed out after [" + atMost.toMillis + "] milliseconds")
+      else throw new TimeoutException("Futures timed out after [" + atMost + "]")
 
     @throws(classOf[Exception])
     def result(atMost: Duration)(implicit permit: CanAwait): T =
diff --git a/src/library/scala/concurrent/package.scala b/src/library/scala/concurrent/package.scala
index a2ef42fac8..1d06341d4d 100644
--- a/src/library/scala/concurrent/package.scala
+++ b/src/library/scala/concurrent/package.scala
@@ -67,26 +67,39 @@ package concurrent {
    */
   object Await {
     /**
+     * Await the "resolved" state of this Awaitable.
      * Invokes ready() on the awaitable, properly wrapped by a call to `scala.concurrent.blocking`.
-     * ready() blocks until the awaitable has completed or the timeout expires.
      *
-     * Throws a TimeoutException if the timeout expires, as that is in the contract of `Awaitable.ready`.
-     * @param awaitable   the `Awaitable` on which `ready` is to be called
-     * @param atMost      the maximum timeout for which to wait
-     * @return            the result of `awaitable.ready` which is defined to be the awaitable itself.
+     * @param awaitable
+     *        the `Awaitable` on which `ready` is to be called
+     * @param atMost
+     *        maximum wait time, which may be negative (no waiting is done),
+     *        [[Duration.Inf]] for unbounded waiting, or a finite positive
+     *        duration
+     * @return the awaitable itself
+     * @throws InterruptedException     if the wait call was interrupted
+     * @throws TimeoutException         if after waiting for the specified time this Awaitable is still not ready
+     * @throws IllegalArgumentException if `atMost` is [[Duration.Undefined]]
      */
     @throws(classOf[TimeoutException])
+    @throws(classOf[InterruptedException])
     def ready[T](awaitable: Awaitable[T], atMost: Duration): awaitable.type =
       blocking(awaitable.ready(atMost)(AwaitPermission))
     
     /**
+     * Await and return the result of this Awaitable, which is either of type T or a thrown exception (any Throwable).
      * Invokes result() on the awaitable, properly wrapped by a call to `scala.concurrent.blocking`.
-     * result() blocks until the awaitable has completed or the timeout expires.
      *
-     * Throws a TimeoutException if the timeout expires, or any exception thrown by `Awaitable.result`.
-     * @param awaitable   the `Awaitable` on which `result` is to be called
-     * @param atMost      the maximum timeout for which to wait
-     * @return            the result of `awaitable.result`
+     * @param awaitable
+     *        the `Awaitable` on which `result` is to be called
+     * @param atMost
+     *        maximum wait time, which may be negative (no waiting is done),
+     *        [[Duration.Inf]] for unbounded waiting, or a finite positive
+     *        duration
+     * @return the value if the Awaitable was successful within the specific maximum wait time
+     * @throws InterruptedException     if the wait call was interrupted
+     * @throws TimeoutException         if after waiting for the specified time this Awaitable is still not ready
+     * @throws IllegalArgumentException if `atMost` is [[Duration.Undefined]]
      */
     @throws(classOf[Exception])
     def result[T](awaitable: Awaitable[T], atMost: Duration): T =
diff --git a/src/library/scala/deprecatedInheritance.scala b/src/library/scala/deprecatedInheritance.scala
new file mode 100644
index 0000000000..ca1b586223
--- /dev/null
+++ b/src/library/scala/deprecatedInheritance.scala
@@ -0,0 +1,22 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2012, LAMP/EPFL                  **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala
+
+/** An annotation that designates that inheriting from a class is deprecated.
+ *
+ *  This is usually done to warn about a non-final class being made final in a future version.
+ *  Sub-classing such a class then generates a warning.
+ *
+ *  @param  message the message to print during compilation if the class was sub-classed
+ *  @param  since   a string identifying the first version in which inheritance was deprecated
+ *  @since  2.10
+ *  @see    [[scala.deprecatedOverriding]]
+ */
+private[scala] // for now, this needs to be generalized to communicate other modifier deltas
+class deprecatedInheritance(message: String = "", since: String = "") extends annotation.StaticAnnotation
diff --git a/src/library/scala/deprecatedOverriding.scala b/src/library/scala/deprecatedOverriding.scala
new file mode 100644
index 0000000000..566cb59431
--- /dev/null
+++ b/src/library/scala/deprecatedOverriding.scala
@@ -0,0 +1,21 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2012, LAMP/EPFL                  **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala
+
+/** An annotation that designates that overriding a member is deprecated.
+ *
+ *  Overriding such a member in  a sub-class then generates a warning.
+ *
+ *  @param  message the message to print during compilation if the member was overridden
+ *  @param  since   a string identifying the first version in which overriding was deprecated
+ *  @since  2.10
+ *  @see    [[scala.deprecatedInheritance]]
+ */
+private[scala] // for the same reasons as deprecatedInheritance
+class deprecatedOverriding(message: String = "", since: String = "") extends annotation.StaticAnnotation
diff --git a/src/library/scala/math/BigDecimal.scala b/src/library/scala/math/BigDecimal.scala
index 8669b2e2e8..a475d663f4 100644
--- a/src/library/scala/math/BigDecimal.scala
+++ b/src/library/scala/math/BigDecimal.scala
@@ -159,6 +159,7 @@ object BigDecimal {
  *  @author  Stephane Micheloud
  *  @version 1.0
  */
+@deprecatedInheritance("This class will me made final.", "2.10.0")
 class BigDecimal(
   val bigDecimal: BigDec,
   val mc: MathContext)
diff --git a/src/library/scala/math/BigInt.scala b/src/library/scala/math/BigInt.scala
index 09e8ae2026..e354117e14 100644
--- a/src/library/scala/math/BigInt.scala
+++ b/src/library/scala/math/BigInt.scala
@@ -114,6 +114,7 @@ object BigInt {
  *  @author  Martin Odersky
  *  @version 1.0, 15/07/2003
  */
+@deprecatedInheritance("This class will me made final.", "2.10.0")
 class BigInt(val bigInteger: BigInteger) extends ScalaNumber with ScalaNumericConversions with Serializable {
   /** Returns the hash code for this BigInt. */
   override def hashCode(): Int =
diff --git a/src/library/scala/reflect/ClassTag.scala b/src/library/scala/reflect/ClassTag.scala
index 5255c44f10..e42c89d21f 100644
--- a/src/library/scala/reflect/ClassTag.scala
+++ b/src/library/scala/reflect/ClassTag.scala
@@ -2,7 +2,7 @@ package scala.reflect
 
 import java.lang.{ Class => jClass }
 import language.{implicitConversions, existentials}
-import scala.runtime.ScalaRunTime.arrayClass
+import scala.runtime.ScalaRunTime.{ arrayClass, arrayElementClass }
 
 /** A `ClassTag[T]` wraps a runtime class, which can be accessed via the `runtimeClass` method.
  *
@@ -54,35 +54,59 @@ trait ClassTag[T] extends ClassManifestDeprecatedApis[T] with Equals with Serial
    * `SomeExtractor(...)` is turned into `ct(SomeExtractor(...))` if `T` in `SomeExtractor.unapply(x: T)`
    * is uncheckable, but we have an instance of `ClassTag[T]`.
    */
-  def unapply(x: Any): Option[T] = if (x != null && runtimeClass.isAssignableFrom(x.getClass)) Some(x.asInstanceOf[T]) else None
+  def unapply(x: Any): Option[T] = unapply_impl(x)
+  def unapply(x: Byte): Option[T] = unapply_impl(x)
+  def unapply(x: Short): Option[T] = unapply_impl(x)
+  def unapply(x: Char): Option[T] = unapply_impl(x)
+  def unapply(x: Int): Option[T] = unapply_impl(x)
+  def unapply(x: Long): Option[T] = unapply_impl(x)
+  def unapply(x: Float): Option[T] = unapply_impl(x)
+  def unapply(x: Double): Option[T] = unapply_impl(x)
+  def unapply(x: Boolean): Option[T] = unapply_impl(x)
+  def unapply(x: Unit): Option[T] = unapply_impl(x)
+
+  private def unapply_impl[U: ClassTag](x: U): Option[T] =
+    if (x == null) None
+    else {
+      val staticClass = classTag[U].runtimeClass
+      val dynamicClass = x.getClass
+      val effectiveClass = if (staticClass.isPrimitive) staticClass else dynamicClass
+      val conforms = runtimeClass.isAssignableFrom(effectiveClass)
+      if (conforms) Some(x.asInstanceOf[T]) else None
+    }
 
   /** case class accessories */
   override def canEqual(x: Any) = x.isInstanceOf[ClassTag[_]]
   override def equals(x: Any) = x.isInstanceOf[ClassTag[_]] && this.runtimeClass == x.asInstanceOf[ClassTag[_]].runtimeClass
   override def hashCode = scala.runtime.ScalaRunTime.hash(runtimeClass)
-  override def toString = "ClassTag[" + runtimeClass + "]"
+  override def toString = {
+    def prettyprint(clazz: jClass[_]): String =
+      if (clazz.isArray) s"Array[${prettyprint(arrayElementClass(clazz))}]" else
+      clazz.getName
+    prettyprint(runtimeClass)
+  }
 }
 
 object ClassTag {
+  private val ObjectTYPE = classOf[java.lang.Object]
   private val NothingTYPE = classOf[scala.runtime.Nothing$]
   private val NullTYPE = classOf[scala.runtime.Null$]
-  private val ObjectTYPE = classOf[java.lang.Object]
 
-  val Byte    : ClassTag[scala.Byte]       = new ClassTag[scala.Byte]{ def runtimeClass = java.lang.Byte.TYPE; private def readResolve() = ClassTag.Byte }
-  val Short   : ClassTag[scala.Short]      = new ClassTag[scala.Short]{ def runtimeClass = java.lang.Short.TYPE; private def readResolve() = ClassTag.Short }
-  val Char    : ClassTag[scala.Char]       = new ClassTag[scala.Char]{ def runtimeClass = java.lang.Character.TYPE; private def readResolve() = ClassTag.Char }
-  val Int     : ClassTag[scala.Int]        = new ClassTag[scala.Int]{ def runtimeClass = java.lang.Integer.TYPE; private def readResolve() = ClassTag.Int }
-  val Long    : ClassTag[scala.Long]       = new ClassTag[scala.Long]{ def runtimeClass = java.lang.Long.TYPE; private def readResolve() = ClassTag.Long }
-  val Float   : ClassTag[scala.Float]      = new ClassTag[scala.Float]{ def runtimeClass = java.lang.Float.TYPE; private def readResolve() = ClassTag.Float }
-  val Double  : ClassTag[scala.Double]     = new ClassTag[scala.Double]{ def runtimeClass = java.lang.Double.TYPE; private def readResolve() = ClassTag.Double }
-  val Boolean : ClassTag[scala.Boolean]    = new ClassTag[scala.Boolean]{ def runtimeClass = java.lang.Boolean.TYPE; private def readResolve() = ClassTag.Boolean }
-  val Unit    : ClassTag[scala.Unit]       = new ClassTag[scala.Unit]{ def runtimeClass = java.lang.Void.TYPE; private def readResolve() = ClassTag.Unit }
-  val Any     : ClassTag[scala.Any]        = new ClassTag[scala.Any]{ def runtimeClass = ObjectTYPE; private def readResolve() = ClassTag.Any }
-  val Object  : ClassTag[java.lang.Object] = new ClassTag[java.lang.Object]{ def runtimeClass = ObjectTYPE; private def readResolve() = ClassTag.Object }
-  val AnyVal  : ClassTag[scala.AnyVal]     = ClassTag.Object.asInstanceOf[ClassTag[scala.AnyVal]]
-  val AnyRef  : ClassTag[scala.AnyRef]     = ClassTag.Object.asInstanceOf[ClassTag[scala.AnyRef]]
-  val Nothing : ClassTag[scala.Nothing]    = new ClassTag[scala.Nothing]{ def runtimeClass = NothingTYPE; private def readResolve() = ClassTag.Nothing }
-  val Null    : ClassTag[scala.Null]       = new ClassTag[scala.Null]{ def runtimeClass = NullTYPE; private def readResolve() = ClassTag.Null }
+  val Byte    : ClassTag[scala.Byte]       = Manifest.Byte
+  val Short   : ClassTag[scala.Short]      = Manifest.Short
+  val Char    : ClassTag[scala.Char]       = Manifest.Char
+  val Int     : ClassTag[scala.Int]        = Manifest.Int
+  val Long    : ClassTag[scala.Long]       = Manifest.Long
+  val Float   : ClassTag[scala.Float]      = Manifest.Float
+  val Double  : ClassTag[scala.Double]     = Manifest.Double
+  val Boolean : ClassTag[scala.Boolean]    = Manifest.Boolean
+  val Unit    : ClassTag[scala.Unit]       = Manifest.Unit
+  val Any     : ClassTag[scala.Any]        = Manifest.Any
+  val Object  : ClassTag[java.lang.Object] = Manifest.Object
+  val AnyVal  : ClassTag[scala.AnyVal]     = Manifest.AnyVal
+  val AnyRef  : ClassTag[scala.AnyRef]     = Manifest.AnyRef
+  val Nothing : ClassTag[scala.Nothing]    = Manifest.Nothing
+  val Null    : ClassTag[scala.Null]       = Manifest.Null
 
   def apply[T](runtimeClass1: jClass[_]): ClassTag[T] =
     runtimeClass1 match {
@@ -96,6 +120,8 @@ object ClassTag {
       case java.lang.Boolean.TYPE   => ClassTag.Boolean.asInstanceOf[ClassTag[T]]
       case java.lang.Void.TYPE      => ClassTag.Unit.asInstanceOf[ClassTag[T]]
       case ObjectTYPE               => ClassTag.Object.asInstanceOf[ClassTag[T]]
+      case NothingTYPE              => ClassTag.Nothing.asInstanceOf[ClassTag[T]]
+      case NullTYPE                 => ClassTag.Null.asInstanceOf[ClassTag[T]]
       case _                        => new ClassTag[T]{ def runtimeClass = runtimeClass1 }
     }
 
diff --git a/src/library/scala/reflect/Manifest.scala b/src/library/scala/reflect/Manifest.scala
index 9347f5b6bb..f2a23f4372 100644
--- a/src/library/scala/reflect/Manifest.scala
+++ b/src/library/scala/reflect/Manifest.scala
@@ -155,28 +155,34 @@ object ManifestFactory {
     private def readResolve(): Any = Manifest.Unit
   }
 
-  val Any: Manifest[scala.Any] = new PhantomManifest[scala.Any]("Any") {
+  private val ObjectTYPE = classOf[java.lang.Object]
+  private val NothingTYPE = classOf[scala.runtime.Nothing$]
+  private val NullTYPE = classOf[scala.runtime.Null$]
+
+  val Any: Manifest[scala.Any] = new PhantomManifest[scala.Any](ObjectTYPE, "Any") {
     override def <:<(that: ClassManifest[_]): Boolean = (that eq this)
     private def readResolve(): Any = Manifest.Any
   }
 
-  val Object: Manifest[java.lang.Object] = new PhantomManifest[java.lang.Object]("Object") {
+  val Object: Manifest[java.lang.Object] = new PhantomManifest[java.lang.Object](ObjectTYPE, "Object") {
     override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any)
     private def readResolve(): Any = Manifest.Object
   }
 
-  val AnyVal: Manifest[scala.AnyVal] = new PhantomManifest[scala.AnyVal]("AnyVal") {
+  val AnyRef: Manifest[scala.AnyRef] = Object.asInstanceOf[Manifest[scala.AnyRef]]
+
+  val AnyVal: Manifest[scala.AnyVal] = new PhantomManifest[scala.AnyVal](ObjectTYPE, "AnyVal") {
     override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any)
     private def readResolve(): Any = Manifest.AnyVal
   }
 
-  val Null: Manifest[scala.Null] = new PhantomManifest[scala.Null]("Null") {
+  val Null: Manifest[scala.Null] = new PhantomManifest[scala.Null](NullTYPE, "Null") {
     override def <:<(that: ClassManifest[_]): Boolean =
       (that ne null) && (that ne Nothing) && !(that <:< AnyVal)
     private def readResolve(): Any = Manifest.Null
   }
 
-  val Nothing: Manifest[scala.Nothing] = new PhantomManifest[scala.Nothing]("Nothing") {
+  val Nothing: Manifest[scala.Nothing] = new PhantomManifest[scala.Nothing](NothingTYPE, "Nothing") {
     override def <:<(that: ClassManifest[_]): Boolean = (that ne null)
     private def readResolve(): Any = Manifest.Nothing
   }
@@ -211,7 +217,8 @@ object ManifestFactory {
   def classType[T](prefix: Manifest[_], clazz: Predef.Class[_], args: Manifest[_]*): Manifest[T] =
     new ClassTypeManifest[T](Some(prefix), clazz, args.toList)
 
-  private abstract class PhantomManifest[T](override val toString: String) extends ClassTypeManifest[T](None, classOf[java.lang.Object], Nil) {
+  private abstract class PhantomManifest[T](_runtimeClass: Predef.Class[_],
+                                            override val toString: String) extends ClassTypeManifest[T](None, _runtimeClass, Nil) {
     override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef]
     override val hashCode = System.identityHashCode(this)
   }
diff --git a/src/library/scala/runtime/ScalaRunTime.scala b/src/library/scala/runtime/ScalaRunTime.scala
index e5f5e9dc5d..a8635151ff 100644
--- a/src/library/scala/runtime/ScalaRunTime.scala
+++ b/src/library/scala/runtime/ScalaRunTime.scala
@@ -167,35 +167,6 @@ object ScalaRunTime {
   def checkInitialized[T <: AnyRef](x: T): T =
     if (x == null) throw new UninitializedError else x
 
-  abstract class Try[+A] {
-    def Catch[B >: A](handler: PartialFunction[Throwable, B]): B
-    def Finally(fin: => Unit): A
-  }
-
-  def Try[A](block: => A): Try[A] = new Try[A] with Runnable {
-    private var result: A = _
-    private var exception: Throwable =
-      try   { run() ; null }
-      catch {
-        case e: ControlThrowable  => throw e  // don't catch non-local returns etc
-        case e: Throwable         => e
-      }
-
-    def run() { result = block }
-
-    def Catch[B >: A](handler: PartialFunction[Throwable, B]): B =
-      if (exception == null) result
-      else if (handler isDefinedAt exception) handler(exception)
-      else throw exception
-
-    def Finally(fin: => Unit): A = {
-      fin
-
-      if (exception == null) result
-      else throw exception
-    }
-  }
-
   def _toString(x: Product): String =
     x.productIterator.mkString(x.productPrefix + "(", ",", ")")
 
diff --git a/src/library/scala/util/Try.scala b/src/library/scala/util/Try.scala
index f381a18b0c..7afbfcdd66 100644
--- a/src/library/scala/util/Try.scala
+++ b/src/library/scala/util/Try.scala
@@ -52,6 +52,8 @@ import language.implicitConversions
  * ''Note'': only non-fatal exceptions are caught by the combinators on `Try` (see [[scala.util.control.NonFatal]]).
  * Serious system errors, on the other hand, will be thrown.
  *
+ * ''Note:'': all Try combinators will catch exceptions and return failure unless otherwise specified in the documentation.
+ *
  * `Try` comes to the Scala standard library after years of use as an integral part of Twitter's stack.
  *
  * @author based on Twitter's original implementation in com.twitter.util.
@@ -68,12 +70,19 @@ sealed abstract class Try[+T] {
   def isSuccess: Boolean
 
   /** Returns the value from this `Success` or the given `default` argument if this is a `Failure`.
+   *
+   * ''Note:'': This will throw an exception if it is not a success and default throws an exception.
    */
-  def getOrElse[U >: T](default: => U) = if (isSuccess) get else default
+  def getOrElse[U >: T](default: => U): U =
+    if (isSuccess) get else default
 
   /** Returns this `Try` if it's a `Success` or the given `default` argument if this is a `Failure`.
    */
-  def orElse[U >: T](default: => Try[U]) = if (isSuccess) this else default
+  def orElse[U >: T](default: => Try[U]): Try[U] =
+    try if (isSuccess) this else default
+    catch {
+      case NonFatal(e) => Failure(e)
+    }
 
   /** Returns the value from this `Success` or throws the exception if this is a `Failure`.
    */
@@ -81,6 +90,8 @@ sealed abstract class Try[+T] {
 
   /**
    * Applies the given function `f` if this is a `Success`, otherwise returns `Unit` if this is a `Failure`.
+   *
+   * ''Note:'' If `f` throws, then this method may throw an exception.
    */
   def foreach[U](f: T => U): Unit
 
@@ -114,7 +125,7 @@ sealed abstract class Try[+T] {
   /**
    * Returns `None` if this is a `Failure` or a `Some` containing the value if this is a `Success`.
    */
-  def toOption = if (isSuccess) Some(get) else None
+  def toOption: Option[T] = if (isSuccess) Some(get) else None
 
   /**
    * Transforms a nested `Try`, ie, a `Try` of type `Try[Try[T]]`,
@@ -131,20 +142,25 @@ sealed abstract class Try[+T] {
   /** Completes this `Try` by applying the function `f` to this if this is of type `Failure`, or conversely, by applying
    *  `s` if this is a `Success`.
    */
-  def transform[U](s: T => Try[U], f: Throwable => Try[U]): Try[U] = this match {
-    case Success(v) => s(v)
-    case Failure(e) => f(e)
-  }
+  def transform[U](s: T => Try[U], f: Throwable => Try[U]): Try[U] =
+    try this match {
+      case Success(v) => s(v)
+      case Failure(e) => f(e)
+    } catch {
+      case NonFatal(e) => Failure(e)
+    }
 
 }
 
 object Try {
-
-  def apply[T](r: => T): Try[T] = {
-    try { Success(r) } catch {
+  /** Constructs a `Try` using the by-name parameter.  This
+   * method will ensure any non-fatal exception is caught and a
+   * `Failure` object is returned.
+   */
+  def apply[T](r: => T): Try[T] =
+    try Success(r) catch {
       case NonFatal(e) => Failure(e)
     }
-  }
 
 }
 
@@ -152,24 +168,25 @@ final case class Failure[+T](val exception: Throwable) extends Try[T] {
   def isFailure: Boolean = true
   def isSuccess: Boolean = false
   def recoverWith[U >: T](f: PartialFunction[Throwable, Try[U]]): Try[U] =
-    if (f.isDefinedAt(exception)) f(exception) else this
+    try {
+      if (f isDefinedAt exception) f(exception) else this
+    } catch {
+      case NonFatal(e) => Failure(e)
+    }
   def get: T = throw exception
-  def flatMap[U](f: T => Try[U]): Try[U] = Failure[U](exception)
-  def flatten[U](implicit ev: T <:< Try[U]): Try[U] = Failure[U](exception)
-  def foreach[U](f: T => U): Unit = {}
-  def map[U](f: T => U): Try[U] = Failure[U](exception)
+  def flatMap[U](f: T => Try[U]): Try[U] = this.asInstanceOf[Try[U]]
+  def flatten[U](implicit ev: T <:< Try[U]): Try[U] = this.asInstanceOf[Try[U]]
+  def foreach[U](f: T => U): Unit = ()
+  def map[U](f: T => U): Try[U] = this.asInstanceOf[Try[U]]
   def filter(p: T => Boolean): Try[T] = this
-  def recover[U >: T](rescueException: PartialFunction[Throwable, U]): Try[U] = {
+  def recover[U >: T](rescueException: PartialFunction[Throwable, U]): Try[U] =
     try {
-      if (rescueException.isDefinedAt(exception)) {
+      if (rescueException isDefinedAt exception) {
         Try(rescueException(exception))
-      } else {
-        this
-      }
+      } else this
     } catch {
       case NonFatal(e) => Failure(e)
     }
-  }
   def failed: Try[Throwable] = Success(exception)
 }
 
@@ -177,7 +194,7 @@ final case class Failure[+T](val exception: Throwable) extends Try[T] {
 final case class Success[+T](value: T) extends Try[T] {
   def isFailure: Boolean = false
   def isSuccess: Boolean = true
-  def recoverWith[U >: T](f: PartialFunction[Throwable, Try[U]]): Try[U] = Success(value)
+  def recoverWith[U >: T](f: PartialFunction[Throwable, Try[U]]): Try[U] = this
   def get = value
   def flatMap[U](f: T => Try[U]): Try[U] =
     try f(value)