Get rid of eval on daemon completely, fixes also JSR 223 examples

compiler/daemon/daemon-client/src/org/jetbrains/kotlin/daemon/client/KotlinRemoteReplCompilerClient.kt

@@ -32,7 +32,6 @@ open class KotlinRemoteReplCompilerClient(
         messageCollector: MessageCollector,
         templateClasspath: List<File>,
         templateClassName: String,
-        scriptArgsWithTypes: ScriptArgsWithTypes,
         port: Int = SOCKET_ANY_FREE_PORT
 ) : ReplCompiler {
     val services = BasicCompilerServicesWithResultsFacadeServer(messageCollector, null, port)
@@ -48,8 +47,7 @@ open class KotlinRemoteReplCompilerClient(
                     emptyArray()),
             services,
             templateClasspath,
-            templateClassName,
+            templateClassName
-            scriptArgsWithTypes
     ).get()
 
     // dispose should be called at the end of the repl lifetime to free daemon repl session and appropriate resources

compiler/daemon/daemon-common/src/org/jetbrains/kotlin/daemon/common/CompileService.kt

@@ -190,8 +190,7 @@ interface CompileService : Remote {
             compilationOptions: CompilationOptions,
             servicesFacade: CompilerServicesFacadeBase,
             templateClasspath: List<File>,
-            templateClassName: String,
+            templateClassName: String
-            scriptArgsWithTypes: ScriptArgsWithTypes?
     ): CallResult<Int>
 
     @Throws(RemoteException::class)

compiler/daemon/src/org/jetbrains/kotlin/daemon/CompileServiceImpl.kt

@@ -455,7 +455,6 @@ class CompileServiceImpl(
             val compilerMessagesStream = PrintStream(BufferedOutputStream(RemoteOutputStreamClient(compilerMessagesOutputStream, DummyProfiler()), REMOTE_STREAM_BUFFER_SIZE))
             val messageCollector = KeepFirstErrorMessageCollector(compilerMessagesStream)
             val repl = KotlinJvmReplService(disposable, port, templateClasspath, templateClassName,
-                                            scriptArgs?.let { ScriptArgsWithTypes(it, scriptArgsTypes?.map { it.kotlin }?.toTypedArray() ?: emptyArray()) },
                                             messageCollector, operationsTracer)
             val sessionId = state.sessions.leaseSession(ClientOrSessionProxy(aliveFlagPath, repl, disposable))
 
@@ -486,9 +485,7 @@ class CompileServiceImpl(
             history: List<ReplCodeLine>?
     ): CompileService.CallResult<ReplEvalResult> =
             ifAlive(minAliveness = Aliveness.Alive) {
-                withValidRepl(sessionId) {
+                CompileService.CallResult.Error("Eval on daemon is not supported")
-                    CompileService.CallResult.Good(compileAndEval(codeLine, verifyHistory = history))
-                }
             }
 
     override fun leaseReplSession(aliveFlagPath: String?,
@@ -496,8 +493,7 @@ class CompileServiceImpl(
                                   compilationOptions: CompilationOptions,
                                   servicesFacade: CompilerServicesFacadeBase,
                                   templateClasspath: List<File>,
-                                  templateClassName: String,
+                                  templateClassName: String
-                                  scriptArgsWithTypes: ScriptArgsWithTypes?
     ): CompileService.CallResult<Int> = ifAlive(minAliveness = Aliveness.Alive)  {
         if (compilationOptions.targetPlatform != CompileService.TargetPlatform.JVM)
             CompileService.CallResult.Error("Sorry, only JVM target platform is supported now")
@@ -505,7 +501,7 @@ class CompileServiceImpl(
             val disposable = Disposer.newDisposable()
             val messageCollector = CompileServicesFacadeMessageCollector(servicesFacade, compilationOptions)
             val repl = KotlinJvmReplService(disposable, port, templateClasspath, templateClassName,
-                                            scriptArgsWithTypes, messageCollector, null)
+                                            messageCollector, null)
             val sessionId = state.sessions.leaseSession(ClientOrSessionProxy(aliveFlagPath, repl, disposable))
 
             CompileService.CallResult.Good(sessionId)

compiler/daemon/src/org/jetbrains/kotlin/daemon/KotlinRemoteReplService.kt

@@ -44,11 +44,10 @@ open class KotlinJvmReplService(
         val portForServers: Int,
         templateClasspath: List<File>,
         templateClassName: String,
-        protected val fallbackScriptArgs: ScriptArgsWithTypes?,
         protected val messageCollector: MessageCollector,
         @Deprecated("drop it")
         protected val operationsTracer: RemoteOperationsTracer?
-) : ReplCompileAction, ReplAtomicEvalAction, ReplCheckAction, CreateReplStageStateAction {
+) : ReplCompileAction, ReplCheckAction, CreateReplStageStateAction {
 
     protected val configuration = CompilerConfiguration().apply {
         addJvmClasspathRoots(PathUtil.getJdkClassesRoots())
@@ -90,12 +89,6 @@ open class KotlinJvmReplService(
         else GenericReplCompiler(disposable, scriptDef, configuration, messageCollector)
     }
 
-    private val replEvaluator: ReplFullEvaluator? by lazy {
-        replCompiler?.let { compiler ->
-            GenericReplCompilingEvaluator(compiler, configuration.jvmClasspathRoots, null, fallbackScriptArgs, ReplRepeatingMode.NONE)
-        }
-    }
-
     protected val statesLock = ReentrantReadWriteLock()
     // TODO: consider using values here for session cleanup
     protected val states = WeakHashMap<RemoteReplStateFacadeServer, Boolean>() // used as (missing) WeakHashSet
@@ -128,27 +121,12 @@ open class KotlinJvmReplService(
         }
     }
 
-    @Deprecated("eval is not supported on daemon")
-    override fun compileAndEval(state: IReplStageState<*>, codeLine: ReplCodeLine, scriptArgs: ScriptArgsWithTypes?, invokeWrapper: InvokeWrapper?): ReplEvalResult {
-        operationsTracer?.before("eval")
-        try {
-            return replEvaluator?.compileAndEval(state, codeLine, scriptArgs ?: fallbackScriptArgs, invokeWrapper)
-                   ?: ReplEvalResult.Error.Runtime("Initialization error")
-        }
-        finally {
-            operationsTracer?.after("eval")
-        }
-    }
-
     @Deprecated("Use check(state, line) instead")
     fun check(codeLine: ReplCodeLine): ReplCheckResult = check(defaultStateFacade.state, codeLine)
 
     @Deprecated("Use compile(state, line) instead")
     fun compile(codeLine: ReplCodeLine, verifyHistory: List<ReplCodeLine>?): ReplCompileResult = compile(defaultStateFacade.state, codeLine)
 
-    @Deprecated("eval is not supported on daemon")
-    fun compileAndEval(codeLine: ReplCodeLine, verifyHistory: List<ReplCodeLine>?): ReplEvalResult = ReplEvalResult.Error.Runtime("Eval is not supported on daemon")
-
     fun createRemoteState(port: Int = portForServers): RemoteReplStateFacadeServer = statesLock.write {
         val id = getValidId(stateIdCounter) { id -> states.none { it.key.getId() == id} }
         val stateFacade = RemoteReplStateFacadeServer(id, createState().asState(GenericReplCompilerState::class.java), port)

compiler/tests/org/jetbrains/kotlin/daemon/CompilerDaemonTest.kt

@@ -534,12 +534,12 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
 
     fun testDaemonReplLocalEvalNoParams() {
         withDaemon { daemon ->
-            val repl = KotlinRemoteReplCompilerClient(daemon!!, null, CompileService.TargetPlatform.JVM,
+            withDisposable { disposable ->
-                                                      emptyArray(),
+                val repl = KotlinRemoteReplCompilerClient(daemon!!, null, CompileService.TargetPlatform.JVM,
-                                                      TestMessageCollector(),
+                                                          emptyArray(),
-                                                      classpathFromClassloader(),
+                                                          TestMessageCollector(),
-                                                      ScriptWithNoParam::class.qualifiedName!!,
+                                                          classpathFromClassloader(),
-                                                      ScriptArgsWithTypes(emptyArray(), emptyArray()))
+                                                          ScriptWithNoParam::class.qualifiedName!!)
 
             val localEvaluator = GenericReplEvaluator(emptyList(), Thread.currentThread().contextClassLoader)
 
@@ -550,11 +550,11 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
 
     fun testDaemonReplLocalEvalStandardTemplate() {
         withDaemon { daemon ->
-            val repl = KotlinRemoteReplCompilerClient(disposable, daemon!!, null, CompileService.TargetPlatform.JVM, emptyArray(),
+            withDisposable { disposable ->
-                                                      TestMessageCollector(),
+                val repl = KotlinRemoteReplCompilerClient(daemon!!, null, CompileService.TargetPlatform.JVM, emptyArray(),
-                                                      classpathFromClassloader(),
+                                                          TestMessageCollector(),
-                                                      "kotlin.script.templates.standard.ScriptTemplateWithArgs",
+                                                          classpathFromClassloader(),
-                                                      ScriptArgsWithTypes(emptyArray(), emptyArray()))
+                                                          "kotlin.script.templates.standard.ScriptTemplateWithArgs")
 
             val localEvaluator = GenericReplEvaluator(emptyList(), Thread.currentThread().contextClassLoader,
                                                       ScriptArgsWithTypes(arrayOf(emptyArray<String>()), arrayOf(Array<String>::class)))
@@ -609,8 +609,7 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
                                                               emptyArray(),
                                                               TestMessageCollector(),
                                                               classpathFromClassloader(),
-                                                              ScriptWithNoParam::class.qualifiedName!!,
+                                                              ScriptWithNoParam::class.qualifiedName!!)
-                                                              ScriptArgsWithTypes(emptyArray(), emptyArray()))
 
             val compilerState = replCompiler.createState()
 

idea/idea-repl/src/org/jetbrains/kotlin/jsr223/KotlinJsr223JvmScriptEngine4Idea.kt

@@ -65,8 +65,7 @@ class KotlinJsr223JvmScriptEngine4Idea(
                                            emptyArray(),
                                            messageCollector,
                                            templateClasspath,
-                                           templateClassName,
+                                           templateClassName)
-                                           ScriptArgsWithTypes(emptyArray(), emptyArray()))
         }
     }
 

libraries/tools/kotlin-script-util/src/main/kotlin/org/jetbrains/kotlin/script/jsr223/KotlinJsr223JvmDaemonCompileScriptEngine.kt

@@ -57,8 +57,7 @@ class KotlinJsr223JvmDaemonCompileScriptEngine(
                     emptyArray(),
                     PrintingMessageCollector(PrintStream(compilerOut), MessageRenderer.WITHOUT_PATHS, false),
                     templateClasspath,
-                    templateClassName,
+                    templateClassName)
-                    getScriptArgs(context, scriptArgsTypes)!!)
         }
     }