Another exciting development in the world of -Y...

Another exciting development in the world of -Y options which I and
three other people will use. Today's is -Yrich-exceptions. Use it like
so:

  SOURCEPATH=/path/to/src scalac -Yrich-exceptions a.scala

In the repl, -Yrich-exceptions will cause lastException to be bound to
an Exceptional instead of old rusty Throwable. That spins up new powers:

  scala> Nil.head
  [Nil.head] (List.scala:389)
  (access lastException for the full trace)
  scala> lastException.show
  /* The repl internal portion of the stack trace is elided. */
  [Nil.head]
   386:   override def isEmpty = true
   387:   override def head: Nothing =
   388:     throw new NoSuchElementException("head of empty list")
  *389:   override def tail: List[Nothing] =
   390:     throw new UnsupportedOperationException("tail of empty list")
   391:   // Removal of equals method here might lead to an infinite recursion similar to IntMap.equals.
   392:   override def equals(that: Any) = that match {

  [line0.<init>] (<console>:6)
  [line0.<clinit>] (<console>:-1)

Also try "lastException.showTable" but this is getting a little long for
more excerpt. No review.

1 files changed, 18 insertions, 0 deletions

diff --git a/src/compiler/scala/tools/nsc/io/package.scala b/src/compiler/scala/tools/nsc/io/package.scala
new file mode 100644
index 0000000000..18d374a617
--- /dev/null
+++ b/src/compiler/scala/tools/nsc/io/package.scala
@@ -0,0 +1,18 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2010 LAMP/EPFL
+ * @author Paul Phillips
+ */
+
+package scala.tools.nsc
+
+import java.util.concurrent.{ Future, Callable, Executors }
+
+package object io {
+  def runnable(body: => Unit): Runnable       = new Runnable { override def run() = body }
+  def callable[T](body: => T): Callable[T]    = new Callable[T] { override def call() = body }
+  def spawn[T](body: => T): Future[T]         = Executors.newSingleThreadExecutor() submit callable[T](body)
+  def submit(runnable: Runnable)              = Executors.newSingleThreadExecutor() submit runnable
+  def runnableFn(f: () => Unit): Runnable     = runnable(f())
+  def callableFn[T](f: () => T): Callable[T]  = callable(f())
+  def spawnFn[T](f: () => T): Future[T]       = spawn(f())
+}
\ No newline at end of file