5 files changed, 19 insertions, 24 deletions
diff --git a/src/library/scala/concurrent/JavaConversions.scala b/src/library/scala/concurrent/JavaConversions.scala
index 9fde489ced..7ee9096127 100644
--- a/src/library/scala/concurrent/JavaConversions.scala
+++ b/src/library/scala/concurrent/JavaConversions.scala
@@ -22,15 +22,12 @@ object JavaConversions {
       type Future[+R] = () => R
 
       def submit(task: () => Unit): this.Future[Unit] = {
-        val result = new SyncVar[Either[Unit, Throwable]]
+        val result = new SyncVar[Either[Throwable, Unit]]
         val runnable = new Runnable {
           def run() { result set tryCatch(task()) }
         }
         exec.execute(runnable)
-        () => result.get match {
-          case Left(a) => a
-          case Right(t) => throw t
-        }
+        () => ops getOrThrow result.get
       }
 
       def managedBlock(blocker: ManagedBlocker) {
diff --git a/src/library/scala/concurrent/TaskRunner.scala b/src/library/scala/concurrent/TaskRunner.scala
index d29e8ff12f..a393b065fa 100644
--- a/src/library/scala/concurrent/TaskRunner.scala
+++ b/src/library/scala/concurrent/TaskRunner.scala
@@ -15,15 +15,9 @@ trait TaskRunner[T] extends AsyncInvokable[() => T, T] {
 
   def managedBlock(blocker: ManagedBlocker): Unit
 
-  /** If expression computed successfully return it in <code>Left</code>,
-   *  otherwise return exception in <code>Right</code>.
+  /** If expression computed successfully return it in <code>Right</code>,
+   *  otherwise return exception in <code>Left</code>.
    */
-  protected def tryCatch[A](left: => A): Either[A, Exception] = {
-    try {
-      Left(left)
-    } catch {
-      case e: Exception => Right(e)
-    }
-  }
-
+  protected def tryCatch[A](body: => A): Either[Exception, A] =
+    ops tryCatchEx body
 }
diff --git a/src/library/scala/concurrent/ThreadRunner.scala b/src/library/scala/concurrent/ThreadRunner.scala
index 7fb653a326..f48e0384b7 100644
--- a/src/library/scala/concurrent/ThreadRunner.scala
+++ b/src/library/scala/concurrent/ThreadRunner.scala
@@ -11,15 +11,12 @@ class ThreadRunner[T] extends TaskRunner[T] {
   type Future[+S] = () => S
 
   def submit(task: () => T): this.Future[T] = {
-    val result = new SyncVar[Either[T, Exception]]
+    val result = new SyncVar[Either[Exception, T]]
     val runnable = new Runnable {
       def run() { result set tryCatch(task()) }
     }
     (new Thread(runnable)).start()
-    () => result.get match {
-      case Left(a) => a
-      case Right(t) => throw t
-    }
+    () => ops getOrThrow result.get
   }
 
   def managedBlock(blocker: ManagedBlocker) {
diff --git a/src/library/scala/concurrent/ops.scala b/src/library/scala/concurrent/ops.scala
index 182756dcb1..e2fb8f0ceb 100644
--- a/src/library/scala/concurrent/ops.scala
+++ b/src/library/scala/concurrent/ops.scala
@@ -18,8 +18,8 @@ import scala.util.control.Exception.allCatch
  *
  *  @author  Martin Odersky, Stepan Koltsov, Philipp Haller
  */
-object ops {
-
+object ops
+{
   implicit val defaultRunner: TaskRunner[Unit] =
     TaskRunners.threadRunner
 
@@ -27,10 +27,15 @@ object ops {
    *  If expression computed successfully return it in <code>Right</code>,
    *  otherwise return exception in <code>Left</code>.
    */
-  private def tryCatch[A](body: => A): Either[Throwable, A] =
+  def tryCatch[A](body: => A): Either[Throwable, A] =
     allCatch[A] either body
 
-  private def getOrThrow[A](x: Either[Throwable, A]): A =
+  def tryCatchEx[A](body: => A): Either[Exception, A] =
+    try Right(body) catch {
+      case ex: Exception  => Left(ex)
+    }
+
+  def getOrThrow[T <: Throwable, A](x: Either[T, A]): A =
     x.fold[A](throw _, identity _)
 
   /** Evaluates an expression asynchronously.
diff --git a/src/library/scala/reflect/RichClass.scala b/src/library/scala/reflect/RichClass.scala
index f016fb37dc..5d58d12377 100644
--- a/src/library/scala/reflect/RichClass.scala
+++ b/src/library/scala/reflect/RichClass.scala
@@ -10,6 +10,7 @@
 
 package scala.reflect
 
+import annotation.experimental
 import util.control.Exception._
 import util.ScalaClassLoader._
 import java.lang.{ Class => JClass }
@@ -22,6 +23,7 @@ object RichClass
   implicit def classWrapper[T](x: JClass[T]): RichClass[T] = new RichClass(x)
 }
 
+@experimental
 final class RichClass[T](val self: JClass[T]) extends Proxy
 {
   // The getConstructors and getDeclaredConstructors methods on java.lang.Class[T]