Modularized the repl.

Following in the footsteps of scaladoc and interactive.
The interpreter sources move into src/repl, and are given
a separate build target. As with the others, at present
they are still packaged into scala-compiler.jar.

A summary of changes:

 - repl requires use of ReplGlobal (this was already implied)
 - macro code's repl-specific classloader hack pulled into overridable
   method and overridden in ReplGlobal
 - removed -Ygen-javap option to eliminate backend's dependency on javap
 - removed -Yrepl-debug option (can still be enabled with -Dscala.repl.debug)
 - pushed javap code into src/repl so javax.tools dependency can bee
   weakened to the repl only
 - removed some "show pickled" related code which hasn't worked right
   in a while and isn't the right way to do it anymore anyway. Will
   return to fix showPickled and provide it with some tests.

1 files changed, 46 insertions, 0 deletions

diff --git a/src/repl/scala/tools/nsc/interpreter/NamedParam.scala b/src/repl/scala/tools/nsc/interpreter/NamedParam.scala
new file mode 100644
index 0000000000..a0af72940a
--- /dev/null
+++ b/src/repl/scala/tools/nsc/interpreter/NamedParam.scala
@@ -0,0 +1,46 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2013 LAMP/EPFL
+ * @author Paul Phillips
+ */
+
+package scala.tools.nsc
+package interpreter
+
+import NamedParam._
+import scala.language.implicitConversions
+import scala.reflect.runtime.{universe => ru}
+import scala.reflect.{ClassTag, classTag}
+import scala.tools.nsc.typechecker.{ TypeStrings }
+
+trait NamedParamCreator {
+  protected def freshName: () => String
+
+  def apply[T: ru.TypeTag : ClassTag](name: String, x: T): NamedParam = new Typed[T](name, x)
+  def apply[T: ru.TypeTag : ClassTag](x: T): NamedParam = apply(freshName(), x)
+  def clazz(name: String, x: Any): NamedParam = new Untyped(name, x)
+
+  implicit def tuple[T: ru.TypeTag : ClassTag](pair: (String, T)): NamedParam       = apply(pair._1, pair._2)
+}
+
+object NamedParam extends NamedParamCreator {
+  class Typed[T: ru.TypeTag : ClassTag](val name: String, val value: T) extends NamedParam {
+    val tpe = TypeStrings.fromTag[T]
+  }
+  class Untyped(val name: String, val value: Any) extends NamedParam {
+    val tpe = TypeStrings.fromValue(value)
+  }
+
+  protected val freshName = {
+    var counter = 0
+    () => { counter += 1; "p" + counter }
+  }
+}
+
+case class NamedParamClass(name: String, tpe: String, value: Any) extends NamedParam { }
+
+trait NamedParam {
+  def name: String
+  def tpe: String
+  def value: Any
+  override def toString = name + ": " + tpe
+}