Embryonic but functioning JSR223 support

Author: rjolly

compiler/resources/META-INF/services/javax.script.ScriptEngineFactory

@@ -0,0 +1 @@
+dotty.tools.repl.ScriptEngine$Factory

compiler/src/dotty/tools/repl/Rendering.scala

@@ -26,7 +26,7 @@ private[repl] class Rendering(parentClassLoader: Option[ClassLoader] = None) {
   private[this] var myClassLoader: ClassLoader = _
 
   /** Class loader used to load compiled code */
-  private[this] def classLoader()(implicit ctx: Context) =
+  private[repl] def classLoader()(implicit ctx: Context) =
     if (myClassLoader != null) myClassLoader
     else {
       val parent = parentClassLoader.getOrElse {

compiler/src/dotty/tools/repl/ScriptEngine.scala

@@ -0,0 +1,86 @@
+package dotty.tools
+package repl
+
+import java.io.{Reader, StringWriter}
+import javax.script.{AbstractScriptEngine, Bindings, ScriptContext, ScriptEngine => JScriptEngine, ScriptEngineFactory, ScriptException, SimpleBindings}
+import dotc.core.StdNames.str
+
+/** A JSR 223 (Scripting API) compatible wrapper around the REPL for improved
+ *  interoperability with software that supports it.
+ *
+ *  It works by instantiating a new script engine through the script engine manager.
+ *  The script engine provides a eval method to evaluate scripts in string form.
+ *  Example use:
+ *
+ *  val m = new javax.script.ScriptEngineManager()
+ *  val e = m.getEngineByName("scala")
+ *  println(e.eval("42"))
+ *
+ *  @param factory the script engine factory
+ */
+class ScriptEngine(factory: ScriptEngine.Factory) extends AbstractScriptEngine {
+  private[this] val driver = factory.driver
+  private[this] val rendering = new Rendering
+  private[this] var state: State = driver.initialState
+
+  def getFactory: ScriptEngineFactory = factory
+
+  def createBindings: Bindings = new SimpleBindings
+
+  /* Evaluate with the given context. */
+  @throws[ScriptException]
+  def eval(script: String, context: ScriptContext): Object = {
+    val vid = state.valIndex
+    state = driver.run(script)(state)
+    val oid = state.objectIndex
+    Class.forName(s"${str.REPL_SESSION_LINE}$oid", true, rendering.classLoader()(state.context))
+      .getDeclaredMethods.find(_.getName == s"${str.REPL_RES_PREFIX}$vid")
+      .map(_.invoke(null))
+      .getOrElse(null)
+  }
+
+  @throws[ScriptException]
+  def eval(reader: Reader, context: ScriptContext): Object = {
+    val writer = new StringWriter()
+    var c = reader.read()
+    while(c != -1) {
+      writer.write(c)
+      c = reader.read()
+    }
+    eval(writer.toString(), context)
+  }
+}
+
+object ScriptEngine {
+  import java.util.Arrays
+  import scala.util.Properties
+
+  class Factory extends ScriptEngineFactory {
+    val driver = new ReplDriver(Array("-usejavacp", "-color:never"), Console.out, None)
+
+    def getEngineName = "Scala REPL"
+    def getEngineVersion = "3.0"
+    def getExtensions = Arrays.asList("scala")
+    def getLanguageName = "Scala"
+    def getLanguageVersion = Properties.versionString
+    def getMimeTypes = Arrays.asList("application/x-scala")
+    def getNames = Arrays.asList("scala")
+
+    def getMethodCallSyntax(obj: String, m: String, args: String*) = s"$obj.$m(${args.mkString(", ")})"
+
+    def getOutputStatement(toDisplay: String) = s"""print("$toDisplay")"""
+
+    def getParameter(key: String): Object = key match {
+      case JScriptEngine.ENGINE           => getEngineName
+      case JScriptEngine.ENGINE_VERSION   => getEngineVersion
+      case JScriptEngine.LANGUAGE         => getLanguageName
+      case JScriptEngine.LANGUAGE_VERSION => getLanguageVersion
+      case JScriptEngine.NAME             => getNames.get(0)
+      case _ => null
+    }
+
+    def getProgram(statements: String*) = statements.mkString("; ")
+
+    def getScriptEngine: JScriptEngine = new ScriptEngine(this)
+  }
+}

tests/run-with-compiler/scripting.check

@@ -0,0 +1,3 @@
+val res0: Int = 42
+
+42

tests/run-with-compiler/scripting.scala

@@ -0,0 +1,8 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    val m = new javax.script.ScriptEngineManager(getClass().getClassLoader())
+    val e = m.getEngineByName("scala")
+    println(e.eval("42"))
+  }
+}
+