Sorting default jvm props and basic implementations

libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/BasicJvmScriptingHost.kt

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.script.experimental.jvmhost
+
+import kotlin.script.experimental.api.ScriptEvaluator
+import kotlin.script.experimental.host.BasicScriptingHost
+
+open class BasicJvmScriptingHost(
+    compiler: JvmScriptCompiler = JvmScriptCompiler(),
+    evaluator: ScriptEvaluator = BasicJvmScriptEvaluator()
+) : BasicScriptingHost(compiler, evaluator)

libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJVMCompilerImpl.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
  * that can be found in the license/LICENSE.txt file.
  */
 package kotlin.script.experimental.jvmhost.impl
@@ -41,12 +41,12 @@ import kotlin.script.experimental.dependencies.DependenciesResolver
 import kotlin.script.experimental.host.getMergedScriptText
 import kotlin.script.experimental.jvm.JvmDependency
 import kotlin.script.experimental.jvm.JvmScriptCompileConfigurationProperties
-import kotlin.script.experimental.jvm.JvmScriptEvaluationEnvironmentProperties
-import kotlin.script.experimental.jvm.KJVMCompilerProxy
 import kotlin.script.experimental.jvm.impl.BridgeDependenciesResolver
+import kotlin.script.experimental.jvmhost.JvmScriptEvaluationEnvironmentProperties
+import kotlin.script.experimental.jvmhost.KJvmCompilerProxy
 import kotlin.script.experimental.util.chainPropertyBags
 
-class KJVMCompiledScript<out ScriptBase : Any>(
+class KJvmCompiledScript<out ScriptBase : Any>(
     override val configuration: ScriptCompileConfiguration,
     val generationState: GenerationState,
     val scriptClassFQName: String
@@ -70,7 +70,7 @@ class KJVMCompiledScript<out ScriptBase : Any>(
     }
 }
 
-class KJVMCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJVMCompilerProxy {
+class KJvmCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJvmCompilerProxy {
 
     override fun compile(
         script: ScriptSource,
@@ -192,7 +192,7 @@ class KJVMCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJVMCompiler
                 org.jetbrains.kotlin.codegen.CompilationErrorHandler.THROW_EXCEPTION
             )
 
-            val res = KJVMCompiledScript<Any>(updatedScriptCompileConfiguration, generationState, scriptFileName.capitalize())
+            val res = KJvmCompiledScript<Any>(updatedScriptCompileConfiguration, generationState, scriptFileName.capitalize())
 
             return ResultWithDiagnostics.Success(res, messageCollector.diagnostics)
         } catch (ex: Throwable) {

libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/jvmScriptCompilation.kt

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+@file:Suppress("unused")
+
+package kotlin.script.experimental.jvmhost
+
+import kotlin.script.experimental.api.*
+import kotlin.script.experimental.jvm.defaultJvmScriptingEnvironment
+import kotlin.script.experimental.jvmhost.impl.KJvmCompilerImpl
+import kotlin.script.experimental.util.chainPropertyBags
+
+interface CompiledJvmScriptsCache {
+    fun get(script: ScriptSource, configuration: ScriptCompileConfiguration): CompiledScript<*>?
+    fun store(compiledScript: CompiledScript<*>, configuration: ScriptCompileConfiguration)
+
+    object NoCache : CompiledJvmScriptsCache {
+        override fun get(script: ScriptSource, configuration: ScriptCompileConfiguration): CompiledScript<*>? = null
+        override fun store(compiledScript: CompiledScript<*>, configuration: ScriptCompileConfiguration) {}
+    }
+}
+
+open class JvmScriptCompiler(
+    hostEnvironment: ScriptingEnvironment = defaultJvmScriptingEnvironment,
+    val compilerProxy: KJvmCompilerProxy = KJvmCompilerImpl(hostEnvironment.cloneWithNewParent(defaultJvmScriptingEnvironment)),
+    val cache: CompiledJvmScriptsCache = CompiledJvmScriptsCache.NoCache
+) : ScriptCompiler {
+
+    override suspend operator fun invoke(
+        script: ScriptSource,
+        scriptDefinition: ScriptDefinition,
+        additionalConfiguration: ScriptCompileConfiguration?
+    ): ResultWithDiagnostics<CompiledScript<*>> {
+        val baseConfiguration = chainPropertyBags(additionalConfiguration, scriptDefinition)
+        val refineConfigurationFn = baseConfiguration.getOrNull(ScriptDefinitionProperties.refineConfigurationHandler)
+        val refinedConfiguration =
+            if (baseConfiguration.getOrNull(ScriptDefinitionProperties.refineConfigurationBeforeParsing) == true) {
+                if (refineConfigurationFn == null) {
+                    return ResultWithDiagnostics.Failure("Non-null configurator expected".asErrorDiagnostics())
+                }
+                refineConfigurationFn(script, baseConfiguration).let {
+                    when (it) {
+                        is ResultWithDiagnostics.Failure -> return it
+                        is ResultWithDiagnostics.Success -> it.value
+                    }
+                }
+            } else {
+                baseConfiguration
+            }
+        val cached = cache.get(script, refinedConfiguration)
+
+        if (cached != null) return cached.asSuccess()
+
+        return compilerProxy.compile(script, scriptDefinition, refinedConfiguration).also {
+            if (it is ResultWithDiagnostics.Success) {
+                cache.store(it.value, refinedConfiguration)
+            }
+        }
+    }
+}
+
+interface KJvmCompilerProxy {
+    fun compile(
+        script: ScriptSource,
+        scriptDefinition: ScriptDefinition,
+        additionalConfiguration: ScriptCompileConfiguration
+    ): ResultWithDiagnostics<CompiledScript<*>>
+}
+

libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/jvmScriptEvaluation.kt

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+@file:Suppress("unused")
+
+package kotlin.script.experimental.jvmhost
+
+import kotlin.script.experimental.api.*
+import kotlin.script.experimental.util.typedKey
+
+object JvmScriptEvaluationEnvironmentProperties {
+    val baseClassLoader by typedKey<ClassLoader?>(Thread.currentThread().contextClassLoader)
+}
+
+open class BasicJvmScriptEvaluator : ScriptEvaluator {
+
+    override suspend operator fun invoke(
+        compiledScript: CompiledScript<*>,
+        scriptEvaluationEnvironment: ScriptEvaluationEnvironment
+    ): ResultWithDiagnostics<EvaluationResult> =
+        try {
+            val obj = compiledScript.instantiate(scriptEvaluationEnvironment)
+            when (obj) {
+                is ResultWithDiagnostics.Failure -> obj
+                is ResultWithDiagnostics.Success -> {
+                    // in the future, when (if) we'll stop to compile everything into constructor
+                    // run as SAM
+                    // return res
+                    val scriptObject = obj.value
+                    if (scriptObject !is Class<*>)
+                        ResultWithDiagnostics.Failure(ScriptDiagnostic("expecting class in this implementation, got ${scriptObject?.javaClass}"))
+                    else {
+                        val receivers = scriptEvaluationEnvironment.getOrNull(ScriptEvaluationEnvironmentParams.implicitReceivers)
+                        val instance = if (receivers == null) {
+                            scriptObject.getConstructor().newInstance()
+                        } else {
+                            scriptObject.getConstructor(Array<Any>::class.java).newInstance(receivers.toTypedArray())
+                        }
+
+                        // TODO: fix result value
+                        ResultWithDiagnostics.Success(EvaluationResult(ResultValue.Value("", instance, ""), scriptEvaluationEnvironment))
+                    }
+                }
+            }
+        } catch (e: Throwable) {
+            ResultWithDiagnostics.Failure(e.asDiagnostics())
+        }
+}