SI-7916: ScriptEngine support

Refactor the ScriptEngine support to an adaptor atop the
IMain API.

Allow references to resolve to context attributes. (The
attributes must be defined at compilation time, though
they may resolve to updated values at evaluation time.)

This means that attributes are not bound statically in
REPL history. In particular, we forgo the trick of binding
attributes named "name: Type" as typed values.

Instead, an `x` bound in dynamic context is injected into
the script as a dynamic selection `$ctx.x` where `ctx`
performs the look-up in the script context.

When a compiled script is re-evaluated, a new instance of
the script class is created and defined symbols are
rebound.

The context stdout writer is handled with `Console.withOut`,
with bytes decoded using the default charset.

Compilation errors are thrown as ScriptException with the
first reported error.

This commit doesn't attempt dynamic selection from objects
in context. Currently, script must cast.

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)
+  }
+}