Merge pull request #4819 from som-snytt/issue/7916-ScriptEngine-deferred

SI-7916: ScriptEngine support

11 files changed, 471 insertions, 189 deletions

diff --git a/build.xml b/build.xml
index 8790bf637d..778bcc561b 100644
--- a/build.xml
+++ b/build.xml
@@ -1163,7 +1163,7 @@ TODO:
       </pre>
       <!-- JSR-223 support introduced in 2.11 -->
       <jar-opts>
-        <service type="javax.script.ScriptEngineFactory" provider="scala.tools.nsc.interpreter.IMain$Factory"/>
+        <service type="javax.script.ScriptEngineFactory" provider="scala.tools.nsc.interpreter.Scripted$Factory"/>
       </jar-opts>
     </staged-pack>
   </target>
diff --git a/src/repl/scala/tools/nsc/interpreter/IMain.scala b/src/repl/scala/tools/nsc/interpreter/IMain.scala
index 8c91242b36..a42a12a6fc 100644
--- a/src/repl/scala/tools/nsc/interpreter/IMain.scala
+++ b/src/repl/scala/tools/nsc/interpreter/IMain.scala
@@ -20,7 +20,6 @@ import scala.tools.nsc.typechecker.{StructuredTypeStrings, TypeStrings}
 import scala.tools.nsc.util._
 import ScalaClassLoader.URLClassLoader
 import scala.tools.nsc.util.Exceptional.unwrap
-import javax.script.{AbstractScriptEngine, Bindings, Compilable, CompiledScript, ScriptContext, ScriptEngine, ScriptEngineFactory, ScriptException}
 import java.net.URL
 import scala.tools.util.PathResolver
 
@@ -56,10 +55,11 @@ import scala.tools.util.PathResolver
  *  @author Moez A. Abdel-Gawad
  *  @author Lex Spoon
  */
-class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Settings, protected val out: JPrintWriter) extends AbstractScriptEngine with Compilable with Imports with PresentationCompilation {
+class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends Imports with PresentationCompilation {
   imain =>
 
-  setBindings(createBindings, ScriptContext.ENGINE_SCOPE)
+  def this(initialSettings: Settings) = this(initialSettings, IMain.defaultOut)
+
   object replOutput extends ReplOutput(settings.Yreploutdir) { }
 
   @deprecated("Use replOutput.dir instead", "2.11.0")
@@ -104,13 +104,6 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set
     finally if (!saved) settings.nowarn.value = false
   }
 
-  /** construct an interpreter that reports to Console */
-  def this(settings: Settings, out: JPrintWriter) = this(null, settings, out)
-  def this(factory: ScriptEngineFactory, settings: Settings) = this(factory, settings, new NewLinePrintWriter(new ConsoleWriter, true))
-  def this(settings: Settings) = this(settings, new NewLinePrintWriter(new ConsoleWriter, true))
-  def this(factory: ScriptEngineFactory) = this(factory, new Settings())
-  def this() = this(new Settings())
-
   // the expanded prompt but without color escapes and without leading newline, for purposes of indenting
   lazy val formatting = Formatting.forPrompt(replProps.promptText)
   lazy val reporter: ReplReporter = new ReplReporter(this)
@@ -464,7 +457,7 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set
     pos
   }
 
-  private[interpreter] def requestFromLine(line: String, synthetic: Boolean): Either[IR.Result, Request] = {
+  private[interpreter] def requestFromLine(line: String, synthetic: Boolean = false): Either[IR.Result, Request] = {
     val content = line
 
     val trees: List[global.Tree] = parse(content) match {
@@ -559,77 +552,8 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set
    */
   def interpret(line: String): IR.Result = interpret(line, synthetic = false)
   def interpretSynthetic(line: String): IR.Result = interpret(line, synthetic = true)
-  def interpret(line: String, synthetic: Boolean): IR.Result = compile(line, synthetic) match {
-    case Left(result) => result
-    case Right(req)   => new WrappedRequest(req).loadAndRunReq
-  }
-
-  private def compile(line: String, synthetic: Boolean): Either[IR.Result, Request] = {
-    if (global == null) Left(IR.Error)
-    else requestFromLine(line, synthetic) match {
-      case Left(result) => Left(result)
-      case Right(req)   =>
-       // null indicates a disallowed statement type; otherwise compile and
-       // fail if false (implying e.g. a type error)
-       if (req == null || !req.compile) Left(IR.Error) else Right(req)
-    }
-  }
-
-  var code = ""
-  var bound = false
-  def compiled(script: String): CompiledScript = {
-    if (!bound) {
-      quietBind("engine" -> this.asInstanceOf[ScriptEngine])
-      bound = true
-    }
-    val cat = code + script
-    compile(cat, false) match {
-      case Left(result) => result match {
-        case IR.Incomplete => {
-          code = cat + "\n"
-          new CompiledScript {
-            def eval(context: ScriptContext): Object = null
-            def getEngine: ScriptEngine = IMain.this
-          }
-        }
-        case _ => {
-          code = ""
-          throw new ScriptException("compile-time error")
-        }
-      }
-      case Right(req)   => {
-        code = ""
-        new WrappedRequest(req)
-      }
-    }
-  }
-
-  private class WrappedRequest(val req: Request) extends CompiledScript {
-    var recorded = false
-
-    /** In Java we would have to wrap any checked exception in the declared
-     *  ScriptException. Runtime exceptions and errors would be ok and would
-     *  not need to be caught. So let us do the same in Scala : catch and
-     *  wrap any checked exception, and let runtime exceptions and errors
-     *  escape. We could have wrapped runtime exceptions just like other
-     *  exceptions in ScriptException, this is a choice.
-     */
-    @throws[ScriptException]
-    def eval(context: ScriptContext): Object = {
-      val result = req.lineRep.evalEither match {
-        case Left(e: RuntimeException) => throw e
-        case Left(e: Exception) => throw new ScriptException(e)
-        case Left(e) => throw e
-        case Right(result) => result.asInstanceOf[Object]
-      }
-      if (!recorded) {
-        recordRequest(req)
-        recorded = true
-      }
-      result
-    }
-
-    def loadAndRunReq = classLoader.asContext {
+  def interpret(line: String, synthetic: Boolean): IR.Result = {
+    def loadAndRunReq(req: Request) = classLoader.asContext {
       val (result, succeeded) = req.loadAndRun
 
       /** To our displeasure, ConsoleReporter offers only printMessage,
@@ -654,12 +578,32 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set
       }
     }
 
-    def getEngine: ScriptEngine = IMain.this
+    compile(line, synthetic) match {
+      case Left(result) => result
+      case Right(req)   => loadAndRunReq(req)
+    }
+  }
+
+  // create a Request and compile it
+  private[interpreter] def compile(line: String, synthetic: Boolean): Either[IR.Result, Request] = {
+    if (global == null) Left(IR.Error)
+    else requestFromLine(line, synthetic) match {
+      case Right(null)                => Left(IR.Error)       // disallowed statement type
+      case Right(req) if !req.compile => Left(IR.Error)       // compile error
+      case ok @ Right(req)            => ok
+      case err @ Left(result)         => err
+    }
   }
 
   /** Bind a specified name to a specified value.  The name may
    *  later be used by expressions passed to interpret.
    *
+   *  A fresh `ReadEvalPrint`, which defines a `line` package, is used to compile
+   *  a custom `eval` object that wraps the bound value.
+   *
+   *  If the bound value is successfully installed, then bind the name
+   *  by interpreting `val name = $line42.$eval.value`.
+   *
    *  @param name      the variable name to bind
    *  @param boundType the type of the variable, as a string
    *  @param value     the object value to bind to it
@@ -667,22 +611,22 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set
    */
   def bind(name: String, boundType: String, value: Any, modifiers: List[String] = Nil): IR.Result = {
     val bindRep = new ReadEvalPrint()
-    bindRep.compile("""
-        |object %s {
-        |  var value: %s = _
-        |  def set(x: Any) = value = x.asInstanceOf[%s]
+    bindRep.compile(s"""
+        |object ${bindRep.evalName} {
+        |  var value: $boundType = _
+        |  def set(x: Any) = value = x.asInstanceOf[$boundType]
         |}
-      """.stripMargin.format(bindRep.evalName, boundType, boundType)
-      )
+      """.stripMargin
+    )
     bindRep.callEither("set", value) match {
       case Left(ex) =>
         repldbg("Set failed in bind(%s, %s, %s)".format(name, boundType, value))
         repldbg(util.stackTraceString(ex))
         IR.Error
-
       case Right(_) =>
-        val line = "%sval %s = %s.value".format(modifiers map (_ + " ") mkString, name, bindRep.evalPath)
-        repldbg("Interpreting: " + line)
+        val mods = if (modifiers.isEmpty) "" else modifiers.mkString("", " ", " ")
+        val line = s"${mods}val $name = ${ bindRep.evalPath }.value"
+        repldbg(s"Interpreting: $line")
         interpret(line)
     }
   }
@@ -1046,31 +990,6 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set
     override def toString = "Request(line=%s, %s trees)".format(line, trees.size)
   }
 
-  def createBindings: Bindings = new IBindings {
-    override def put(name: String, value: Object): Object = {
-      val n = name.indexOf(":")
-      val p: NamedParam = if (n < 0) (name, value) else {
-        val nme = name.substring(0, n).trim
-        val tpe = name.substring(n + 1).trim
-        NamedParamClass(nme, tpe, value)
-      }
-      if (!p.name.startsWith("javax.script")) bind(p)
-      null
-    }
-  }
-
-  @throws[ScriptException]
-  def compile(script: String): CompiledScript = eval("new javax.script.CompiledScript { def eval(context: javax.script.ScriptContext): Object = { " + script + " }.asInstanceOf[Object]; def getEngine: javax.script.ScriptEngine = engine }").asInstanceOf[CompiledScript]
-
-  @throws[ScriptException]
-  def compile(reader: java.io.Reader): CompiledScript = compile(stringFromReader(reader))
-
-  @throws[ScriptException]
-  def eval(script: String, context: ScriptContext): Object = compiled(script).eval(context)
-
-  @throws[ScriptException]
-  def eval(reader: java.io.Reader, context: ScriptContext): Object = eval(stringFromReader(reader), context)
-
   override def finalize = close
 
   /** Returns the name of the most recent interpreter result.
@@ -1267,54 +1186,9 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set
 
 /** Utility methods for the Interpreter. */
 object IMain {
-  import java.util.Arrays.{ asList => asJavaList }
   /** Dummy identifier fragement inserted at the cursor before presentation compilation. Needed to support completion of `global.def<TAB>` */
   val DummyCursorFragment = "_CURSOR_"
 
-  class Factory extends ScriptEngineFactory {
-    @BeanProperty
-    val engineName = "Scala Interpreter"
-
-    @BeanProperty
-    val engineVersion = "1.0"
-
-    @BeanProperty
-    val extensions: JList[String] = asJavaList("scala")
-
-    @BeanProperty
-    val languageName = "Scala"
-
-    @BeanProperty
-    val languageVersion = scala.util.Properties.versionString
-
-    def getMethodCallSyntax(obj: String, m: String, args: String*): String = null
-
-    @BeanProperty
-    val mimeTypes: JList[String] = asJavaList("application/x-scala")
-
-    @BeanProperty
-    val names: JList[String] = asJavaList("scala")
-
-    def getOutputStatement(toDisplay: String): String = null
-
-    def getParameter(key: String): Object = key match {
-      case ScriptEngine.ENGINE => engineName
-      case ScriptEngine.ENGINE_VERSION => engineVersion
-      case ScriptEngine.LANGUAGE => languageName
-      case ScriptEngine.LANGUAGE_VERSION => languageVersion
-      case ScriptEngine.NAME => names.get(0)
-      case _ => null
-    }
-
-    def getProgram(statements: String*): String = null
-
-    def getScriptEngine: ScriptEngine = {
-      val settings = new Settings()
-      settings.usemanifestcp.value = true
-      new IMain(this, settings)
-    }
-  }
-
   // The two name forms this is catching are the two sides of this assignment:
   //
   // $line3.$read.$iw.$iw.Bippy =
@@ -1366,5 +1240,10 @@ object IMain {
 
     def stripImpl(str: String): String = naming.unmangle(str)
   }
+  private[interpreter] def defaultSettings = new Settings()
+  private[scala] def defaultOut = new NewLinePrintWriter(new ConsoleWriter, true)
+
+  /** construct an interpreter that reports to Console */
+  def apply(initialSettings: Settings = defaultSettings, out: JPrintWriter = defaultOut) = new IMain(initialSettings, out)
 }
 
diff --git a/src/repl/scala/tools/nsc/interpreter/Scripted.scala b/src/repl/scala/tools/nsc/interpreter/Scripted.scala
new file mode 100644
index 0000000000..25d359bc0e
--- /dev/null
+++ b/src/repl/scala/tools/nsc/interpreter/Scripted.scala
@@ -0,0 +1,343 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2016 LAMP/EPFL
+ */
+package scala
+package tools.nsc
+package interpreter
+
+import scala.language.dynamics
+
+import scala.beans.BeanProperty
+import scala.collection.JavaConverters._
+import scala.reflect.classTag
+import scala.reflect.internal.util.Position
+import scala.tools.nsc.util.stringFromReader
+import javax.script._, ScriptContext.{ ENGINE_SCOPE, GLOBAL_SCOPE }
+import java.io.{ Closeable, Reader }
+
+/* A REPL adaptor for the javax.script API. */
+class Scripted(@BeanProperty val factory: ScriptEngineFactory, settings: Settings, out: JPrintWriter)
+  extends AbstractScriptEngine with Compilable {
+
+  def createBindings: Bindings = new SimpleBindings
+
+  // dynamic context bound under this name
+  final val ctx = "$ctx"
+
+  // the underlying interpreter, tweaked to handle dynamic bindings
+  val intp = new IMain(settings, out) {
+    import global.{ Name, TermName }
+
+    /* Modify the template to snag definitions from dynamic context.
+     * So object $iw { x + 42 } becomes object $iw { def x = $ctx.x ; x + 42 }
+     */
+    override protected def importsCode(wanted: Set[Name], wrapper: Request#Wrapper, definesClass: Boolean, generousImports: Boolean) = {
+
+      // cull references that can be satisfied from the current dynamic context
+      val contextual = wanted & contextNames
+
+      if (contextual.nonEmpty) {
+        val neededContext = (wanted &~ contextual) + TermName(ctx)
+        val ComputedImports(header, preamble, trailer, path) = super.importsCode(neededContext, wrapper, definesClass, generousImports)
+        val adjusted = contextual.map { n =>
+            val valname = n.decodedName
+            s"""def `$valname` = $ctx.`$valname`
+                def `${valname}_=`(x: Object) = $ctx.`$valname` = x"""
+          }.mkString(preamble, "\n", "\n")
+        ComputedImports(header, adjusted, trailer, path)
+      }
+      else super.importsCode(wanted, wrapper, definesClass, generousImports)
+    }
+
+    // names available in current dynamic context
+    def contextNames: Set[Name] = {
+      val ctx = compileContext
+      val terms = for {
+        scope   <- ctx.getScopes.asScala
+        binding <- Option(ctx.getBindings(scope)) map (_.asScala) getOrElse Nil
+        key = binding._1
+      } yield (TermName(key): Name)
+      terms.to[Set]
+    }
+
+    // save first error for exception; console display only if debugging
+    override lazy val reporter: ReplReporter = new ReplReporter(this) {
+      override def display(pos: Position, msg: String, severity: Severity): Unit =
+        if (isReplDebug) super.display(pos, msg, severity)
+      override def error(pos: Position, msg: String): Unit = {
+        if (firstError.isEmpty) firstError = Some((pos, msg))
+        super.error(pos, msg)
+      }
+      override def reset() = { super.reset() ; firstError = None }
+    }
+  }
+  intp.initializeSynchronous()
+
+  var compileContext: ScriptContext = getContext
+
+  val scriptContextRep = new intp.ReadEvalPrint
+
+  def dynamicContext_=(ctx: ScriptContext): Unit = scriptContextRep.callEither("set", ctx)
+
+  def dynamicContext: ScriptContext = scriptContextRep.callEither("value") match {
+    case Right(ctx: ScriptContext) => ctx
+    case Left(e) => throw e
+    case Right(other) => throw new ScriptException(s"Unexpected value for context: $other")
+  }
+
+  if (intp.isInitializeComplete) {
+    // compile the dynamic ScriptContext object holder
+    scriptContextRep compile s"""
+      |import javax.script._
+      |object ${scriptContextRep.evalName} {
+      |  var value: ScriptContext = _
+      |  def set(x: Any) = value = x.asInstanceOf[ScriptContext]
+      |}
+    """.stripMargin
+    dynamicContext = getContext
+
+    // Bridge dynamic references and script context
+    intp compileString s"""
+     |package scala.tools.nsc.interpreter
+     |import language.dynamics
+     |import javax.script._, ScriptContext.ENGINE_SCOPE
+     |object dynamicBindings extends Dynamic {
+     |  def context: ScriptContext = ${ scriptContextRep.evalPath }.value
+     |  // $ctx.x retrieves the attribute x
+     |  def selectDynamic(field: String): Object = context.getAttribute(field)
+     |  // $ctx.x = v
+     |  def updateDynamic(field: String)(value: Object) = context.setAttribute(field, value, ENGINE_SCOPE)
+     |}
+     |""".stripMargin
+    intp beQuietDuring {
+      intp interpret s"val $ctx: scala.tools.nsc.interpreter.dynamicBindings.type = scala.tools.nsc.interpreter.dynamicBindings"
+      intp bind ("$engine" -> (this: ScriptEngine with Compilable))
+    }
+  }
+
+  // Set the context for dynamic resolution and run the body.
+  // Defines attributes available for evaluation.
+  // Avoid reflective access if using default context.
+  def withScriptContext[A](context: ScriptContext)(body: => A): A =
+    if (context eq getContext) body else {
+      val saved = dynamicContext
+      dynamicContext = context
+      try body
+      finally dynamicContext = saved
+    }
+  // Defines attributes available for compilation.
+  def withCompileContext[A](context: ScriptContext)(body: => A): A = {
+    val saved = compileContext
+    compileContext = context
+    try body
+    finally compileContext = saved
+  }
+
+  // not obvious that ScriptEngine should accumulate code text
+  private var code = ""
+
+  private var firstError: Option[(Position, String)] = None
+
+  /* All scripts are compiled. The supplied context defines what references
+   * not in REPL history are allowed, though a different context may be
+   * supplied for evaluation of a compiled script.
+   */
+  def compile(script: String, context: ScriptContext): CompiledScript =
+    withCompileContext(context) {
+      val cat = code + script
+      intp.compile(cat, synthetic = false) match {
+        case Right(req)          =>
+          code = ""
+          new WrappedRequest(req)
+        case Left(IR.Incomplete) =>
+          code = cat + "\n"
+          new CompiledScript {
+            def eval(context: ScriptContext): Object = null
+            def getEngine: ScriptEngine = Scripted.this
+          }
+        case Left(_)             =>
+          code = ""
+          throw firstError map {
+            case (pos, msg) => new ScriptException(msg, script, pos.line, pos.column)
+          } getOrElse new ScriptException("compile-time error")
+      }
+    }
+
+  // documentation
+  //protected var context: ScriptContext
+  //def getContext: ScriptContext = context
+
+  /* Compile with the default context. All references must be resolvable. */
+  @throws[ScriptException]
+  def compile(script: String): CompiledScript = compile(script, context)
+
+  @throws[ScriptException]
+  def compile(reader: Reader): CompiledScript = compile(stringFromReader(reader), context)
+
+  /* Compile and evaluate with the given context. */
+  @throws[ScriptException]
+  def eval(script: String, context: ScriptContext): Object = compile(script, context).eval(context)
+
+  @throws[ScriptException]
+  def eval(reader: Reader, context: ScriptContext): Object = compile(stringFromReader(reader), context).eval(context)
+
+  private class WrappedRequest(val req: intp.Request) extends CompiledScript {
+    var first = true
+
+    private def evalEither(r: intp.Request, ctx: ScriptContext) = {
+      if (ctx.getWriter == null && ctx.getErrorWriter == null && ctx.getReader == null) r.lineRep.evalEither
+      else {
+        val closeables = Array.ofDim[Closeable](2)
+        val w = if (ctx.getWriter == null) Console.out else {
+          val v = new WriterOutputStream(ctx.getWriter)
+          closeables(0) = v
+          v
+        }
+        val e = if (ctx.getErrorWriter == null) Console.err else {
+          val v = new WriterOutputStream(ctx.getErrorWriter)
+          closeables(1) = v
+          v
+        }
+        val in = if (ctx.getReader == null) Console.in else ctx.getReader
+        try {
+          Console.withOut(w) {
+            Console.withErr(e) {
+              Console.withIn(in) {
+                r.lineRep.evalEither
+              }
+            }
+          }
+        } finally {
+          closeables foreach (c => if (c != null) c.close())
+        }
+      }
+    }
+
+    /* First time, cause lazy evaluation of a memoized result.
+     * Subsequently, instantiate a new object for evaluation.
+     * Per the API: Checked exception types thrown by underlying scripting implementations
+     * must be wrapped in instances of ScriptException.
+     */
+    @throws[ScriptException]
+    override def eval(context: ScriptContext) = withScriptContext(context) {
+      if (first) {
+        val result = evalEither(req, context) match {
+          case Left(e: RuntimeException) => throw e
+          case Left(e: Exception)        => throw new ScriptException(e)
+          case Left(e)                   => throw e
+          case Right(result)             => result.asInstanceOf[Object]
+        }
+        intp recordRequest req
+        first = false
+        result
+      } else {
+        val defines = req.defines
+        if (defines.isEmpty) {
+          Scripted.this.eval(s"new ${req.lineRep.readPath}")
+          intp recordRequest duplicate(req)
+          null
+        } else {
+          val instance = s"val $$INSTANCE = new ${req.lineRep.readPath};"
+          val newline  = (defines map (s => s"val ${s.name} = $$INSTANCE${req.accessPath}.${s.name}")).mkString(instance, ";", ";")
+          val newreq   = intp.requestFromLine(newline).right.get
+          val ok = newreq.compile
+
+          val result = evalEither(newreq, context) match {
+            case Left(e: RuntimeException) => throw e
+            case Left(e: Exception)        => throw new ScriptException(e)
+            case Left(e)                   => throw e
+            case Right(result)             => intp recordRequest newreq ; result.asInstanceOf[Object]
+          }
+          result
+        }
+      }
+    }
+
+    def duplicate(req: intp.Request) = new intp.Request(req.line, req.trees)
+
+    def getEngine: ScriptEngine = Scripted.this
+  }
+}
+
+object Scripted {
+  import IMain.{ defaultSettings, defaultOut }
+  import java.util.Arrays.asList
+  import scala.util.Properties.versionString
+
+  class Factory extends ScriptEngineFactory {
+    @BeanProperty val engineName      = "Scala REPL"
+
+    @BeanProperty val engineVersion   = "2.0"
+
+    @BeanProperty val extensions      = asList("scala")
+
+    @BeanProperty val languageName    = "Scala"
+
+    @BeanProperty val languageVersion = versionString
+
+    @BeanProperty val mimeTypes       = asList("application/x-scala")
+
+    @BeanProperty val names           = asList("scala")
+
+    def getMethodCallSyntax(obj: String, m: String, args: String*): String = args.mkString(s"$obj.$m(", ", ", ")")
+
+    def getOutputStatement(toDisplay: String): String = s"Console.println($toDisplay)"
+
+    def getParameter(key: String): Object = key match {
+      case ScriptEngine.ENGINE           => engineName
+      case ScriptEngine.ENGINE_VERSION   => engineVersion
+      case ScriptEngine.LANGUAGE         => languageName
+      case ScriptEngine.LANGUAGE_VERSION => languageVersion
+      case ScriptEngine.NAME             => names.get(0)
+      case _ => null
+    }
+
+    def getProgram(statements: String*): String = statements.mkString("object Main extends App {\n\t", "\n\t", "\n}")
+
+    def getScriptEngine: ScriptEngine = {
+      val settings = new Settings()
+      settings.usemanifestcp.value = true
+      Scripted(this, settings)
+    }
+  }
+
+  def apply(factory: ScriptEngineFactory = new Factory, settings: Settings = defaultSettings, out: JPrintWriter = defaultOut) = {
+    settings.Yreplclassbased.value = true
+    settings.usejavacp.value       = true
+    val s = new Scripted(factory, settings, out)
+    s.setBindings(s.createBindings, ScriptContext.ENGINE_SCOPE)
+    s
+  }
+}
+
+import java.io.Writer
+import java.nio.{ ByteBuffer, CharBuffer }
+import java.nio.charset.{ Charset, CodingErrorAction }
+import CodingErrorAction.{ REPLACE => Replace }
+
+/* An OutputStream that decodes bytes and flushes to the writer. */
+class WriterOutputStream(writer: Writer) extends OutputStream {
+  val decoder = Charset.defaultCharset.newDecoder
+  decoder onMalformedInput Replace
+  decoder onUnmappableCharacter Replace
+
+  val byteBuffer = ByteBuffer.allocate(64)
+  val charBuffer = CharBuffer.allocate(64)
+
+  override def write(b: Int): Unit = {
+    byteBuffer.put(b.toByte)
+    byteBuffer.flip()
+    val result = decoder.decode(byteBuffer, charBuffer, /*eoi=*/ false)
+    if (byteBuffer.remaining == 0) byteBuffer.clear()
+    if (charBuffer.position > 0) {
+      charBuffer.flip()
+      writer write charBuffer.toString
+      charBuffer.clear()
+    }
+  }
+  override def close(): Unit = {
+    decoder.decode(byteBuffer, charBuffer, /*eoi=*/ true)
+    decoder.flush(charBuffer)
+  }
+  override def toString = charBuffer.toString
+}
diff --git a/src/repl/scala/tools/nsc/interpreter/package.scala b/src/repl/scala/tools/nsc/interpreter/package.scala
index 97b32bfa86..55949b81a5 100644
--- a/src/repl/scala/tools/nsc/interpreter/package.scala
+++ b/src/repl/scala/tools/nsc/interpreter/package.scala
@@ -204,7 +204,7 @@ package object interpreter extends ReplConfig with ReplStrings {
 
   /* An s-interpolator that uses `stringOf(arg)` instead of `String.valueOf(arg)`. */
   private[nsc] implicit class `smart stringifier`(val sc: StringContext) extends AnyVal {
-    import StringContext._, runtime.ScalaRunTime.stringOf
+    import StringContext.treatEscapes, scala.runtime.ScalaRunTime.stringOf
     def ss(args: Any*): String = sc.standardInterpolator(treatEscapes, args map stringOf)
   }
   /* Try (body) lastly (more) */
diff --git a/test/files/run/repl-serialization.scala b/test/files/run/repl-serialization.scala
index 55b7519631..8bc0dd3a8b 100644
--- a/test/files/run/repl-serialization.scala
+++ b/test/files/run/repl-serialization.scala
@@ -36,7 +36,7 @@ object Test {
         |extract(() => new AA(x + getX() + y + z + zz + O.apply + u.x))
       """.stripMargin
 
-    imain = new IMain(settings)
+    imain = IMain(settings)
     println("== evaluating lines")
     imain.directBind("extract", "(AnyRef => Unit)", extract)
     code.lines.foreach(imain.interpret)
diff --git a/test/files/run/t1500.scala b/test/files/run/t1500.scala
index 30c026f70f..5a2735fbf1 100644
--- a/test/files/run/t1500.scala
+++ b/test/files/run/t1500.scala
@@ -20,7 +20,7 @@ object Test {
     
     val settings = new Settings()
     settings.classpath.value = System.getProperty("java.class.path")
-    val tool = new interpreter.IMain(settings)
+    val tool = interpreter.IMain(settings)
     val global = tool.global
 
     import global._
diff --git a/test/files/run/t7843-jsr223-service.check b/test/files/run/t7843-jsr223-service.check
deleted file mode 100644
index a668df3567..0000000000
--- a/test/files/run/t7843-jsr223-service.check
+++ /dev/null
@@ -1,2 +0,0 @@
-n: Object = 10
-12345678910
diff --git a/test/files/run/t7843-jsr223-service.scala b/test/files/run/t7843-jsr223-service.scala
deleted file mode 100644
index 31112212ea..0000000000
--- a/test/files/run/t7843-jsr223-service.scala
+++ /dev/null
@@ -1,8 +0,0 @@
-import scala.tools.nsc.interpreter.IMain
-
-object Test extends App {
-  val engine = new IMain.Factory getScriptEngine()
-  engine.asInstanceOf[IMain].settings.usejavacp.value = true
-  engine put ("n", 10)
-  engine eval "1 to n.asInstanceOf[Int] foreach print"
-}
diff --git a/test/files/run/t7933.check b/test/files/run/t7933.check
deleted file mode 100644
index 317e9677c3..0000000000
--- a/test/files/run/t7933.check
+++ /dev/null
@@ -1,2 +0,0 @@
-hello
-hello
diff --git a/test/files/run/t7933.scala b/test/files/run/t7933.scala
deleted file mode 100644
index b06dffcd80..0000000000
--- a/test/files/run/t7933.scala
+++ /dev/null
@@ -1,11 +0,0 @@
-import scala.tools.nsc.interpreter.IMain
-
-object Test extends App {
-  val engine = new IMain.Factory getScriptEngine()
-  engine.asInstanceOf[IMain].settings.usejavacp.value = true
-  val res2 = engine.asInstanceOf[javax.script.Compilable]
-  res2 compile "8" eval()
-  val res5 = res2 compile """println("hello") ; 8"""
-  res5 eval()
-  res5 eval()
-}
diff --git a/test/junit/scala/tools/nsc/interpreter/ScriptedTest.scala b/test/junit/scala/tools/nsc/interpreter/ScriptedTest.scala
new file mode 100644
index 0000000000..a8dc8eb3e0
--- /dev/null
+++ b/test/junit/scala/tools/nsc/interpreter/ScriptedTest.scala
@@ -0,0 +1,83 @@
+package scala.tools.nsc
+package interpreter
+
+import org.junit._, Assert._, runner.RunWith, runners.JUnit4
+import scala.tools.testing.AssertUtil.assertThrows
+
+@RunWith(classOf[JUnit4])
+class ScriptedTest {
+  import javax.script._
+  import scala.tools.nsc.interpreter.Scripted
+
+  def scripted: ScriptEngine with Compilable = Scripted()
+    // same as by service discovery
+    //new ScriptEngineManager().getEngineByName("scala").asInstanceOf[ScriptEngine with Compilable]
+
+  @Test def eval() = {
+    val engine = scripted
+    engine.put("foo","bar")
+    assert("bar" == engine.eval("foo"))
+    val bindings = engine.createBindings()
+    bindings.put("foo","baz")
+    assert("baz" == engine.eval("foo", bindings))
+    val c = engine.compile("def f = foo.asInstanceOf[String] ; f * 2")
+    assert("barbar" == c.eval())
+    assert("bazbaz" == c.eval(bindings))
+  }
+  @Test def `SI-7933 multiple eval compiled script`() = {
+    val engine = scripted
+    val init = """val i = new java.util.concurrent.atomic.AtomicInteger"""
+    val code = """i.getAndIncrement()"""
+    engine eval init
+    val c = engine compile code
+    assert(0 == c.eval())
+    assert(1 == c.eval())
+  }
+  @Test def `SI-8422 captured i/o`() = {
+    import java.io.StringWriter
+    val engine = scripted
+    val ctx    = new SimpleScriptContext
+    val w      = new StringWriter
+    val code = """print("hello, world")"""
+
+    ctx.setWriter(w)
+    engine.eval(code, ctx)
+    assertEquals("hello, world", w.toString)
+  }
+  @Test def `SI-8422 captured multi i/o`() = {
+    import java.io.{ StringWriter, StringReader }
+    import scala.compat.Platform.EOL
+    val engine = scripted
+    val ctx    = new SimpleScriptContext
+    val out    = new StringWriter
+    val err    = new StringWriter
+    val text   =
+    """Now is the time
+      |for all good
+      |dogs to come for supper.""".stripMargin
+    val in     = new StringReader(text)
+        
+    val code =
+    """var s: String = _
+      |var i: Int = 0
+      |do {
+      |  s = scala.io.StdIn.readLine()
+      |  val out = if ((i & 1) == 0) Console.out else Console.err
+      |  i += 1
+      |  Option(s) foreach out.println
+      |} while (s != null)""".stripMargin
+
+    ctx.setWriter(out)
+    ctx.setErrorWriter(err)
+    ctx.setReader(in)
+    engine.eval(code, ctx)
+    val lines = text.lines.toList
+    assertEquals(lines.head + EOL + lines.last + EOL, out.toString)
+    assertEquals(lines(1) + EOL, err.toString)
+  }
+  @Test def `on compile error`(): Unit = {
+    val engine = scripted
+    val err = "not found: value foo in def f = foo at line number 11 at column number 16"
+    assertThrows[ScriptException](engine.compile("def f = foo"), _ == err)
+  }
+}