[CLI] add support running scripts in js compiler, extract common code with jvm part

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/AbstractScriptEvaluationExtension.kt

@@ -23,8 +23,6 @@ import kotlin.script.experimental.host.toScriptSource
 
 abstract class AbstractScriptEvaluationExtension : ScriptEvaluationExtension {
 
-    abstract fun getSourcePath(arguments: CommonCompilerArguments): String
-
     abstract fun setupScriptConfiguration(configuration: CompilerConfiguration, sourcePath: String)
 
     abstract fun createEnvironment(
@@ -40,11 +38,7 @@ abstract class AbstractScriptEvaluationExtension : ScriptEvaluationExtension {
         scriptCompilationConfiguration: ScriptCompilationConfiguration
     ): ResultWithDiagnostics<CompiledScript<*>>
 
-    abstract suspend fun preprocessEvaluation(
-        scriptEvaluator: ScriptEvaluator,
-        scriptCompilationConfiguration: ScriptCompilationConfiguration,
-        evaluationConfiguration: ScriptEvaluationConfiguration
-    )
+    protected abstract fun ScriptEvaluationConfiguration.Builder.platformEvaluationConfiguration()
 
     override fun eval(
         arguments: CommonCompilerArguments,
@@ -57,12 +51,14 @@ abstract class AbstractScriptEvaluationExtension : ScriptEvaluationExtension {
             messageCollector.report(CompilerMessageSeverity.ERROR, "Unable to process the script, scripting plugin is not configured")
             return ExitCode.COMPILATION_ERROR
         }
-        val sourcePath = getSourcePath(arguments)
+        val sourcePath = arguments.freeArgs.first()
 
         setupScriptConfiguration(configuration, sourcePath)
 
         val environment = createEnvironment(projectEnvironment, configuration)
 
+        if (messageCollector.hasErrors()) return ExitCode.COMPILATION_ERROR
+
         val scriptFile = File(sourcePath)
         if (scriptFile.isDirectory || !scriptDefinitionProvider.isScript(scriptFile)) {
             val extensionHint =
@@ -82,6 +78,8 @@ abstract class AbstractScriptEvaluationExtension : ScriptEvaluationExtension {
 
         val evaluationConfiguration = definition.evaluationConfiguration.with {
             constructorArgs(scriptArgs.toTypedArray())
+            platformEvaluationConfiguration()
+
         }
         val scriptCompilationConfiguration = definition.compilationConfiguration
 
@@ -99,7 +97,6 @@ abstract class AbstractScriptEvaluationExtension : ScriptEvaluationExtension {
                 return@runBlocking ExitCode.COMPILATION_ERROR
             }
 
-            preprocessEvaluation(scriptEvaluator, scriptCompilationConfiguration, evaluationConfiguration)
             val evalResult = scriptEvaluator.invoke(compiledScript, evaluationConfiguration).valueOr {
                 for (report in it.reports) {
                     messageCollector.report(report.severity.toCompilerMessageSeverity(), report.render(withSeverity = false))

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/JsScriptEvaluationExtension.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.scripting.definitions.ScriptDefinition
 import org.jetbrains.kotlin.scripting.definitions.platform
 import org.jetbrains.kotlin.scripting.repl.js.CompiledToJsScript
 import org.jetbrains.kotlin.scripting.repl.js.JsScriptCompiler
+import org.jetbrains.kotlin.scripting.repl.js.JsScriptDependencyCompiler
 import org.jetbrains.kotlin.scripting.repl.js.JsScriptEvaluator
 import kotlin.script.experimental.api.*
 import kotlin.script.experimental.host.ScriptingHostConfiguration
@@ -35,10 +36,6 @@ fun loadScriptConfiguration(configuration: CompilerConfiguration) {
 
 class JsScriptEvaluationExtension : AbstractScriptEvaluationExtension() {
 
-    override fun getSourcePath(arguments: CommonCompilerArguments): String {
-        return (arguments as K2JSCompilerArguments).scriptPath!!
-    }
-
     override fun setupScriptConfiguration(configuration: CompilerConfiguration, sourcePath: String) {
         loadScriptConfiguration(configuration)
     }
@@ -59,8 +56,12 @@ class JsScriptEvaluationExtension : AbstractScriptEvaluationExtension() {
     }
 
     private var environment: KotlinCoreEnvironment? = null
+    private var dependencyJsCode: String? = null
     private val scriptCompiler: JsScriptCompiler by lazy {
-        JsScriptCompiler(environment!!)
+        val env = environment ?: error("Expected environment is initialized prior to compiler instantiation")
+        JsScriptCompiler(env).apply {
+            dependencyJsCode = JsScriptDependencyCompiler(env.configuration, nameTables, symbolTable).compile(dependencies)
+        }
     }
 
     override suspend fun compilerInvoke(
@@ -68,22 +69,22 @@ class JsScriptEvaluationExtension : AbstractScriptEvaluationExtension() {
         script: SourceCode,
         scriptCompilationConfiguration: ScriptCompilationConfiguration
     ): ResultWithDiagnostics<CompiledScript<*>> {
+
         this.environment = environment
-        return scriptCompiler.invoke(script, scriptCompilationConfiguration)
+
+        return scriptCompiler.invoke(script, scriptCompilationConfiguration).onSuccess {
+            val compiledResult = it as CompiledToJsScript
+            val actualResult = dependencyJsCode?.let { d ->
+                dependencyJsCode = null
+                CompiledToJsScript(d + "\n" + compiledResult.jsCode, compiledResult.compilationConfiguration)
+            } ?: compiledResult
+
+            ResultWithDiagnostics.Success(actualResult)
+        }
     }
 
-    override suspend fun preprocessEvaluation(
-        scriptEvaluator: ScriptEvaluator,
-        scriptCompilationConfiguration: ScriptCompilationConfiguration,
-        evaluationConfiguration: ScriptEvaluationConfiguration
-    ) {
-        scriptEvaluator.invoke(
-            CompiledToJsScript(
-                scriptCompiler.scriptDependencyBinary,
-                scriptCompilationConfiguration
-            ),
-            evaluationConfiguration
-        )
+    override fun ScriptEvaluationConfiguration.Builder.platformEvaluationConfiguration() {
+
     }
 
     override fun isAccepted(arguments: CommonCompilerArguments): Boolean {

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/JvmCliScriptEvaluationExtension.kt

@@ -16,11 +16,15 @@ import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.scripting.compiler.plugin.impl.ScriptJvmCompilerFromEnvironment
 import kotlin.script.experimental.api.*
 import kotlin.script.experimental.jvm.BasicJvmScriptEvaluator
+import kotlin.script.experimental.jvm.baseClassLoader
+import kotlin.script.experimental.jvm.jvm
 
 class JvmCliScriptEvaluationExtension : AbstractScriptEvaluationExtension() {
 
-    override fun getSourcePath(arguments: CommonCompilerArguments): String {
-        return arguments.freeArgs.first()
+    override fun ScriptEvaluationConfiguration.Builder.platformEvaluationConfiguration() {
+        jvm {
+            baseClassLoader(null)
+        }
     }
 
     override fun setupScriptConfiguration(configuration: CompilerConfiguration, sourcePath: String) {
@@ -53,14 +57,6 @@ class JvmCliScriptEvaluationExtension : AbstractScriptEvaluationExtension() {
         return scriptCompiler.compile(script, scriptCompilationConfiguration)
     }
 
-    override suspend fun preprocessEvaluation(
-        scriptEvaluator: ScriptEvaluator,
-        scriptCompilationConfiguration: ScriptCompilationConfiguration,
-        evaluationConfiguration: ScriptEvaluationConfiguration
-    ) {
-        //do nothing
-    }
-
     override fun isAccepted(arguments: CommonCompilerArguments): Boolean =
         arguments is K2JVMCompilerArguments && arguments.script
 }

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/pluginRegisrar.kt

@@ -51,6 +51,7 @@ class ScriptingCompilerConfigurationComponentRegistrar : ComponentRegistrar {
                                                                 )
             )
             ScriptEvaluationExtension.registerExtensionIfRequired(project, JvmCliScriptEvaluationExtension())
+            ScriptEvaluationExtension.registerExtensionIfRequired(project, JsScriptEvaluationExtension())
             ShellExtension.registerExtensionIfRequired(project, JvmCliReplShellExtension())
             ReplFactoryExtension.registerExtensionIfRequired(project,
                                                              JvmStandardReplFactoryExtension()