Move compiler and compiler tests to compiler dir

1 files changed, 100 insertions, 0 deletions

diff --git a/compiler/src/dotty/tools/dotc/repl/REPL.scala b/compiler/src/dotty/tools/dotc/repl/REPL.scala
new file mode 100644
index 000000000..211e3c931
--- /dev/null
+++ b/compiler/src/dotty/tools/dotc/repl/REPL.scala
@@ -0,0 +1,100 @@
+package dotty.tools
+package dotc
+package repl
+
+import core.Contexts.Context
+import reporting.Reporter
+import io.{AbstractFile, PlainFile, VirtualDirectory}
+import scala.reflect.io.{PlainDirectory, Directory}
+import java.io.{BufferedReader, File => JFile, FileReader, PrintWriter}
+import java.net.{URL, URLClassLoader}
+
+/** A compiler which stays resident between runs.
+ *  Usage:
+ *
+ *  > scala dotty.tools.dotc.Resident <options> <initial files>
+ *
+ *  dotc> "more options and files to compile"
+ *
+ *  ...
+ *
+ *  dotc> :reset  // reset all options to the ones passed on the command line
+ *
+ *  ...
+ *
+ *  dotc> :q     // quit
+ */
+class REPL extends Driver {
+
+  lazy val config = new REPL.Config
+
+  override def setup(args: Array[String], rootCtx: Context): (List[String], Context) = {
+    val (strs, ctx) = super.setup(args, rootCtx)
+    (strs, config.context(ctx))
+  }
+
+  override def newCompiler(implicit ctx: Context): Compiler =
+    new repl.CompilingInterpreter(config.output, ctx, config.classLoader)
+
+  override def sourcesRequired = false
+
+  override def doCompile(compiler: Compiler, fileNames: List[String])(implicit ctx: Context): Reporter = {
+    if (fileNames.isEmpty)
+      new InterpreterLoop(compiler, config).run()
+    else
+      ctx.error(s"don't now what to do with $fileNames%, %")
+    ctx.reporter
+  }
+}
+
+object REPL {
+  class Config {
+    val prompt             = "scala> "
+    val continuationPrompt = "       "
+    val version            = ".next (pre-alpha)"
+
+    def context(ctx: Context): Context = ctx
+
+    /** The first interpreted commands always take a couple of seconds due to
+     *  classloading. To bridge the gap, we warm up the interpreter by letting
+     *  it interpret at least a dummy line while waiting for the first line of
+     *  input to be entered.
+     */
+    val initialCommands: List[String] =
+      "val theAnswerToLifeInTheUniverseAndEverything = 21 * 2" :: Nil
+
+    /** Before exiting, the interpreter will also run the cleanup commands
+     *  issued in the variable below. This is useful if your REPL creates
+     *  things during its run that should be dealt with before shutdown.
+     */
+    val cleanupCommands: List[String] = Nil
+
+    /** Initial values in the REPL can also be bound from runtime. Override
+     *  this variable in the following manner to bind a variable at the start
+     *  of the REPL session:
+     *
+     *  {{{
+     *  override val boundValues = Array("exampleList" -> List(1, 1, 2, 3, 5))
+     *  }}}
+     *
+     *  This is useful if you've integrated the REPL as part of your project
+     *  and already have objects available during runtime that you'd like to
+     *  inspect.
+     */
+    val boundValues: Array[(String, Any)] = Array.empty[(String, Any)]
+
+    /** To pass a custom ClassLoader to the Dotty REPL, overwride this value */
+    val classLoader: Option[ClassLoader] = None
+
+    /** The default input reader */
+    def input(in: Interpreter)(implicit ctx: Context): InteractiveReader = {
+      val emacsShell = System.getProperty("env.emacs", "") != ""
+      //println("emacsShell="+emacsShell) //debug
+      if (emacsShell) new SimpleReader()
+      else InteractiveReader.createDefault(in)
+    }
+
+    /** The default output writer */
+    def output: PrintWriter = new NewLinePrintWriter(new ConsoleWriter, true)
+  }
+}