diff --git a/libraries/examples/scripting/jvm-maven-deps/script/src/org/jetbrains/kotlin/script/examples/jvm/resolve/maven/scriptDef.kt b/libraries/examples/scripting/jvm-maven-deps/script/src/org/jetbrains/kotlin/script/examples/jvm/resolve/maven/scriptDef.kt index c70ea30d61f..054e7fc8cca 100644 --- a/libraries/examples/scripting/jvm-maven-deps/script/src/org/jetbrains/kotlin/script/examples/jvm/resolve/maven/scriptDef.kt +++ b/libraries/examples/scripting/jvm-maven-deps/script/src/org/jetbrains/kotlin/script/examples/jvm/resolve/maven/scriptDef.kt @@ -27,9 +27,9 @@ abstract class MyScriptWithMavenDeps { // abstract fun body(vararg args: String): Int } -val myJvmConfigParams = jvmJavaHomeParams + with(ScriptCompileConfigurationParams) { +val myJvmConfigParams = jvmJavaHomeParams + with(ScriptCompileConfigurationProperties) { listOf( - scriptSignature to ScriptSignature(MyScriptWithMavenDeps::class, ProvidedDeclarations()), + baseClass(), importedPackages(DependsOn::class.qualifiedName!!, Repository::class.qualifiedName!!), dependencies( JvmDependency( @@ -53,10 +53,11 @@ class MyConfigurator(val environment: ChainedPropertyBag) : ScriptCompilationCon defaultConfiguration.asSuccess() override suspend fun refineConfiguration( + scriptSource: ScriptSource, configuration: ScriptCompileConfiguration, processedScriptData: ProcessedScriptData ): ResultWithDiagnostics { - val annotations = processedScriptData.getOrNull(ProcessedScriptDataParams.annotations)?.toList()?.takeIf { it.isNotEmpty() } + val annotations = processedScriptData.getOrNull(ProcessedScriptDataProperties.foundAnnotations)?.toList()?.takeIf { it.isNotEmpty() } ?: return configuration.asSuccess() val scriptContents = object : ScriptContents { override val annotations: Iterable = annotations @@ -74,8 +75,8 @@ class MyConfigurator(val environment: ChainedPropertyBag) : ScriptCompilationCon ?: return configuration.asSuccess(diagnostics) val newDependency = JvmDependency(resolvedClasspath) val updatedDeps = - configuration.getOrNull(ScriptCompileConfigurationParams.dependencies)?.plus(newDependency) ?: listOf(newDependency) - ChainedPropertyBag(configuration, ScriptCompileConfigurationParams.dependencies(updatedDeps)).asSuccess(diagnostics) + configuration.getOrNull(ScriptCompileConfigurationProperties.dependencies)?.plus(newDependency) ?: listOf(newDependency) + ChainedPropertyBag(configuration, ScriptCompileConfigurationProperties.dependencies(updatedDeps)).asSuccess(diagnostics) } catch (e: Throwable) { ResultWithDiagnostics.Failure(*diagnostics.toTypedArray(), e.asDiagnostics()) } diff --git a/libraries/examples/scripting/jvm-simple-script/host/src/org/jetbrains/kotlin/script/examples/jvm/simple/host/host.kt b/libraries/examples/scripting/jvm-simple-script/host/src/org/jetbrains/kotlin/script/examples/jvm/simple/host/host.kt index cdaec6321f2..4594fd7053a 100644 --- a/libraries/examples/scripting/jvm-simple-script/host/src/org/jetbrains/kotlin/script/examples/jvm/simple/host/host.kt +++ b/libraries/examples/scripting/jvm-simple-script/host/src/org/jetbrains/kotlin/script/examples/jvm/simple/host/host.kt @@ -15,9 +15,9 @@ import kotlin.script.experimental.jvm.* import kotlin.script.experimental.jvmhost.impl.KJVMCompilerImpl import kotlin.script.experimental.misc.* -val myJvmConfigParams = jvmJavaHomeParams + with(ScriptCompileConfigurationParams) { +val myJvmConfigParams = jvmJavaHomeParams + with(ScriptCompileConfigurationProperties) { listOf( - scriptSignature to ScriptSignature(MyScript::class, ProvidedDeclarations()), + baseClass(), dependencies(JvmDependency(scriptCompilationClasspathFromContext("script" /* script library jar name */))) ) } diff --git a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptProcessedDataParams.kt b/libraries/scripting/common/src/kotlin/script/experimental/api/processedScriptProperties.kt similarity index 51% rename from libraries/scripting/common/src/kotlin/script/experimental/api/scriptProcessedDataParams.kt rename to libraries/scripting/common/src/kotlin/script/experimental/api/processedScriptProperties.kt index 463afb63830..11225c45a12 100644 --- a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptProcessedDataParams.kt +++ b/libraries/scripting/common/src/kotlin/script/experimental/api/processedScriptProperties.kt @@ -3,10 +3,13 @@ * that can be found in the license/LICENSE.txt file. */ +@file:Suppress("unused") + package kotlin.script.experimental.api -object ProcessedScriptDataParams { - val annotations by typedKey>() +object ProcessedScriptDataProperties { + val foundAnnotations by typedKey>() - val fragments by typedKey>() + val foundFragments by typedKey>() } + diff --git a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptConfiguration.kt b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptConfiguration.kt index 410f882f87e..331dd6b9225 100644 --- a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptConfiguration.kt +++ b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptConfiguration.kt @@ -22,6 +22,7 @@ interface ScriptCompilationConfigurator { suspend fun baseConfiguration(scriptSource: ScriptSource): ResultWithDiagnostics suspend fun refineConfiguration( + scriptSource: ScriptSource, configuration: ScriptCompileConfiguration, processedScriptData: ProcessedScriptData = ProcessedScriptData() ): ResultWithDiagnostics diff --git a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptConfigurationParams.kt b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptConfigurationParams.kt deleted file mode 100644 index 0ddf49aa995..00000000000 --- a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptConfigurationParams.kt +++ /dev/null @@ -1,34 +0,0 @@ -/* - * Copyright 2000-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.api - -import kotlin.reflect.KClass - -object ScriptCompileConfigurationParams { - - val baseClass by typedKey>() - - val scriptSourceFragments by typedKey() - - val scriptSignature by typedKey() - - val importedPackages by typedKey>() - - val restrictions by typedKey() - - val importedScripts by typedKey>() - - val dependencies by typedKey>() - - val compilerOptions by typedKey>() // Q: CommonCompilerOptions instead? - - val updateConfigurationOnAnnotations by typedKey>>() - - val updateConfigurationOnSections by typedKey>() -} - diff --git a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptConfigurationProperties.kt b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptConfigurationProperties.kt new file mode 100644 index 00000000000..611c3b373ab --- /dev/null +++ b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptConfigurationProperties.kt @@ -0,0 +1,39 @@ +/* + * Copyright 2000-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.api + +import kotlin.reflect.KClass +import kotlin.reflect.KType + +object ScriptCompileConfigurationProperties { + + val sourceFragments by typedKey>() + + val baseClass = ScriptingEnvironmentProperties.baseClass + + val scriptBodyTarget by typedKey() + + val scriptImplicitReceivers by typedKey>() // in the order from outer to inner scope + + val contextVariables by typedKey>() // external variables + + val importedPackages by typedKey>() + + val restrictions by typedKey>() + + val importedScripts by typedKey>() + + val dependencies by typedKey>() + + val compilerOptions by typedKey>() // Q: CommonCompilerOptions instead? + + val updateConfigurationOnAnnotations by typedKey>>() + + val updateConfigurationOnSections by typedKey>() +} + diff --git a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptData.kt b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptData.kt index 92685151689..f7a9f5750a0 100644 --- a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptData.kt +++ b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptData.kt @@ -22,37 +22,22 @@ interface ScriptSource { data class ScriptSourceNamedFragment(val name: String?, val range: ScriptSource.Range) -open class ScriptSourceFragments( - val originalSource: ScriptSource, - val fragments: List?) - -open class ProvidedDeclarations( - val implicitReceivers: List = emptyList(), // previous scripts, etc. - val contextVariables: Map = emptyMap() // external variables - // Q: do we need context constants and/or types here, e.g. - // val contextConstants: Map // or with KType as well - // val contextTypes: List // additional (to the classpath) types provided by the environment - // alternatively: - // val contextDeclarations: List // kind, name, type, value - // OR: it should be a HeterogeneousMap too -) { - object Empty : ProvidedDeclarations() +enum class ScriptBodyTarget { + Constructor, + SingleAbstractMethod } -open class ScriptSignature( - val scriptBase: KClass<*>, - val providedDeclarations: ProvidedDeclarations -) - -open class ResolvingRestrictions { - data class Rule( - val allow: Boolean, - val pattern: String // FQN wildcard - ) - - val rules: Iterable = arrayListOf() +data class ResolvingRestrictionRule( + val action: Action, + val pattern: String // FQN wildcard +) { + enum class Action { + Allow, + Deny + } } interface ScriptDependency { // Q: anything generic here? } + diff --git a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptDefinitionProperties.kt b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptDefinitionProperties.kt index 0205fb7d068..d72172c6d70 100644 --- a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptDefinitionProperties.kt +++ b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptDefinitionProperties.kt @@ -9,8 +9,8 @@ package kotlin.script.experimental.api object ScriptDefinitionProperties { - val name by typedKey() + val name by typedKey() // Name of the script type, by default "Kotlin script" - val fileExtension by typedKey() + val fileExtension by typedKey() // default: "kts" } diff --git a/libraries/scripting/common/src/kotlin/script/experimental/basic/basicScript.kt b/libraries/scripting/common/src/kotlin/script/experimental/basic/basicScript.kt index d9554a2b73e..e5c95bd40ff 100644 --- a/libraries/scripting/common/src/kotlin/script/experimental/basic/basicScript.kt +++ b/libraries/scripting/common/src/kotlin/script/experimental/basic/basicScript.kt @@ -10,14 +10,13 @@ import kotlin.script.experimental.api.* class PassThroughCompilationConfigurator(val environment: ChainedPropertyBag) : ScriptCompilationConfigurator { - override val defaultConfiguration = ScriptCompileConfiguration( - ScriptCompileConfigurationParams.baseClass to environment[ScriptingEnvironmentProperties.baseClass] - ) + override val defaultConfiguration = ScriptCompileConfiguration(environment) override suspend fun baseConfiguration(scriptSource: ScriptSource): ResultWithDiagnostics = defaultConfiguration.asSuccess() override suspend fun refineConfiguration( + script: ScriptSource, configuration: ScriptCompileConfiguration, processedScriptData: ProcessedScriptData ): ResultWithDiagnostics = diff --git a/libraries/scripting/common/src/kotlin/script/experimental/host/scriptHostUtil.kt b/libraries/scripting/common/src/kotlin/script/experimental/host/scriptHostUtil.kt index cda9290f615..01190d4f575 100644 --- a/libraries/scripting/common/src/kotlin/script/experimental/host/scriptHostUtil.kt +++ b/libraries/scripting/common/src/kotlin/script/experimental/host/scriptHostUtil.kt @@ -9,8 +9,6 @@ import java.io.File import java.net.URL import kotlin.script.experimental.api.* -fun ScriptSourceFragments.isWholeFile(): Boolean = fragments?.isEmpty() ?: true - fun ScriptSource.getScriptText(): String = when { text != null -> text!! location != null -> @@ -20,13 +18,13 @@ fun ScriptSource.getScriptText(): String = when { fun getMergedScriptText(script: ScriptSource, configuration: ScriptCompileConfiguration): String { val originalScriptText = script.getScriptText() - val sourceFragments = configuration.getOrNull(ScriptCompileConfigurationParams.scriptSourceFragments) - return if (sourceFragments == null || sourceFragments.isWholeFile()) { + val sourceFragments = configuration.getOrNull(ScriptCompileConfigurationProperties.sourceFragments) + return if (sourceFragments == null || sourceFragments.isEmpty()) { originalScriptText } else { val sb = StringBuilder(originalScriptText.length) var prevFragment: ScriptSourceNamedFragment? = null - for (fragment in sourceFragments!!.fragments!!) { + for (fragment in sourceFragments) { val fragmentStartPos = fragment.range.start.absolutePos val fragmentEndPos = fragment.range.end.absolutePos if (fragmentStartPos == null || fragmentEndPos == null) diff --git a/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJVMCompilerImpl.kt b/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJVMCompilerImpl.kt index b7dc14588eb..42785da2b99 100644 --- a/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJVMCompilerImpl.kt +++ b/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJVMCompilerImpl.kt @@ -15,7 +15,10 @@ import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity import org.jetbrains.kotlin.cli.common.messages.MessageCollector -import org.jetbrains.kotlin.cli.jvm.compiler.* +import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles +import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment +import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace +import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot import org.jetbrains.kotlin.cli.jvm.config.JvmModulePathRoot import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots @@ -37,8 +40,8 @@ import kotlin.script.experimental.api.* import kotlin.script.experimental.dependencies.DependenciesResolver import kotlin.script.experimental.host.getMergedScriptText import kotlin.script.experimental.jvm.JvmDependency -import kotlin.script.experimental.jvm.JvmScriptCompileConfigurationParams -import kotlin.script.experimental.jvm.JvmScriptEvaluationEnvironmentParams +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 @@ -49,8 +52,8 @@ class KJVMCompiledScript( ) : CompiledScript { override suspend fun instantiate(scriptEvaluationEnvironment: ScriptEvaluationEnvironment): ResultWithDiagnostics = try { - val baseClassLoader = scriptEvaluationEnvironment.getOrNull(JvmScriptEvaluationEnvironmentParams.baseClassLoader) - val dependencies = configuration.getOrNull(ScriptCompileConfigurationParams.dependencies) + val baseClassLoader = scriptEvaluationEnvironment.getOrNull(JvmScriptEvaluationEnvironmentProperties.baseClassLoader) + val dependencies = configuration.getOrNull(ScriptCompileConfigurationProperties.dependencies) ?.flatMap { (it as? JvmDependency)?.classpath?.map { it.toURI().toURL() } ?: emptyList() } // TODO: previous dependencies and classloaders should be taken into account here val classLoaderWithDeps = @@ -82,14 +85,14 @@ class KJVMCompilerImpl : KJVMCompilerProxy { var environment: KotlinCoreEnvironment? = null var updatedScriptCompileConfiguration = scriptCompilerConfiguration - fun updateClasspath(classpath: Iterable) { + fun updateClasspath(classpath: List) { environment!!.updateClasspath(classpath.map(::JvmClasspathRoot)) - val updatedDeps = updatedScriptCompileConfiguration.getOrNull(ScriptCompileConfigurationParams.dependencies)?.plus( + val updatedDeps = updatedScriptCompileConfiguration.getOrNull(ScriptCompileConfigurationProperties.dependencies)?.plus( JvmDependency(classpath) ) ?: listOf(JvmDependency(classpath)) updatedScriptCompileConfiguration = ChainedPropertyBag( updatedScriptCompileConfiguration, - ScriptCompileConfigurationParams.dependencies to updatedDeps + ScriptCompileConfigurationProperties.dependencies to updatedDeps ) } @@ -103,13 +106,13 @@ class KJVMCompilerImpl : KJVMCompilerProxy { put(JVMConfigurationKeys.RETAIN_OUTPUT_IN_MEMORY, true) var isModularJava = false - scriptCompilerConfiguration.getOrNull(JvmScriptCompileConfigurationParams.javaHomeDir)?.let { + scriptCompilerConfiguration.getOrNull(JvmScriptCompileConfigurationProperties.javaHomeDir)?.let { put(JVMConfigurationKeys.JDK_HOME, it) isModularJava = CoreJrtFileSystem.isModularJdk(it) } var explicitStdlib = false - scriptCompilerConfiguration.getOrNull(ScriptCompileConfigurationParams.dependencies)?.let { + scriptCompilerConfiguration.getOrNull(ScriptCompileConfigurationProperties.dependencies)?.let { addJvmClasspathRoots( it.flatMap { (it as JvmDependency).classpath.also { @@ -242,9 +245,9 @@ internal class BridgeScriptDefinition( scriptCompilerConfiguration: ScriptCompileConfiguration, scriptConfigurator: ScriptCompilationConfigurator?, updateClasspath: (List) -> Unit -) : KotlinScriptDefinition(scriptCompilerConfiguration[ScriptCompileConfigurationParams.scriptSignature].scriptBase as KClass) { +) : KotlinScriptDefinition(scriptCompilerConfiguration[ScriptingEnvironmentProperties.baseClass] as KClass) { override val acceptedAnnotations = - scriptCompilerConfiguration.getOrNull(ScriptCompileConfigurationParams.updateConfigurationOnAnnotations)?.toList() ?: emptyList() + scriptCompilerConfiguration.getOrNull(ScriptCompileConfigurationProperties.updateConfigurationOnAnnotations)?.toList() ?: emptyList() override val dependencyResolver: DependenciesResolver = BridgeDependenciesResolver(scriptConfigurator, scriptCompilerConfiguration, updateClasspath) diff --git a/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/impl/BridgeDependenciesResolver.kt b/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/impl/BridgeDependenciesResolver.kt index f9cb5a63c76..6db95c20f8f 100644 --- a/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/impl/BridgeDependenciesResolver.kt +++ b/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/impl/BridgeDependenciesResolver.kt @@ -36,15 +36,14 @@ class BridgeDependenciesResolver( val diagnostics = arrayListOf() val processedScriptData = - ProcessedScriptData(ProcessedScriptDataParams.annotations to scriptContents.annotations) - - val scriptCompilerConfiguration = ChainedPropertyBag( - baseScriptCompilerConfiguration, - ScriptCompileConfigurationParams.scriptSourceFragments to scriptContents.toScriptSourceFragments() - ) + ProcessedScriptData(ProcessedScriptDataProperties.foundAnnotations to scriptContents.annotations) val refinedConfiguration = scriptConfigurator?.let { - val res = scriptConfigurator.refineConfiguration(scriptCompilerConfiguration, processedScriptData) + val res = scriptConfigurator.refineConfiguration( + scriptContents.toScriptSource(), + baseScriptCompilerConfiguration, + processedScriptData + ) when (res) { is ResultWithDiagnostics.Failure -> return@resolveAsync DependenciesResolver.ResolveResult.Failure(res.reports.mapScriptReportsToDiagnostics()) @@ -53,12 +52,12 @@ class BridgeDependenciesResolver( res.value } } - } ?: scriptCompilerConfiguration + } ?: baseScriptCompilerConfiguration - val newClasspath = refinedConfiguration.getOrNull(ScriptCompileConfigurationParams.dependencies) + val newClasspath = refinedConfiguration.getOrNull(ScriptCompileConfigurationProperties.dependencies) ?.flatMap { (it as JvmDependency).classpath } ?: emptyList() - if (refinedConfiguration != scriptCompilerConfiguration) { - val oldClasspath = scriptCompilerConfiguration.getOrNull(ScriptCompileConfigurationParams.dependencies) + if (refinedConfiguration != baseScriptCompilerConfiguration) { + val oldClasspath = baseScriptCompilerConfiguration.getOrNull(ScriptCompileConfigurationProperties.dependencies) ?.flatMap { (it as JvmDependency).classpath } ?: emptyList() if (newClasspath != oldClasspath) { onClasspathUpdated(newClasspath) @@ -67,16 +66,14 @@ class BridgeDependenciesResolver( DependenciesResolver.ResolveResult.Success( ScriptDependencies( classpath = newClasspath, // TODO: maybe it should return only increment from the initial config - imports = refinedConfiguration.getOrNull(ScriptCompileConfigurationParams.importedPackages)?.toList() + imports = refinedConfiguration.getOrNull(ScriptCompileConfigurationProperties.importedPackages)?.toList() ?: emptyList() ), diagnostics ) } catch (e: Throwable) { DependenciesResolver.ResolveResult.Failure( - ScriptReport( - e.message ?: "unknown error $e" - ) + ScriptReport(e.message ?: "unknown error $e") ) } } @@ -85,13 +82,9 @@ class BridgeDependenciesResolver( internal fun List.mapScriptReportsToDiagnostics() = map { ScriptReport(it.message, mapToLegacyScriptReportSeverity(it.severity), mapToLegacyScriptReportPosition(it.location)) } -internal fun ScriptContents.toScriptSourceFragments(): ScriptSourceFragments = - ScriptSourceFragments( - when { - text != null -> text!!.toString().toScriptSource() - file != null -> file!!.toScriptSource() - else -> throw IllegalArgumentException("Unable to convert script contents $this into script source") - }, - null - ) +internal fun ScriptContents.toScriptSource(): ScriptSource = when { + text != null -> text!!.toString().toScriptSource() + file != null -> file!!.toScriptSource() + else -> throw IllegalArgumentException("Unable to convert script contents $this into script source") +} diff --git a/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptCompilation.kt b/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptCompilation.kt index d59199fd79b..781468a7919 100644 --- a/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptCompilation.kt +++ b/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptCompilation.kt @@ -19,11 +19,10 @@ open class JvmScriptCompiler( configuration: ScriptCompileConfiguration, configurator: ScriptCompilationConfigurator? ): ResultWithDiagnostics> { - val refinedConfiguration = configurator?.refineConfiguration(configuration)?.let { + val refinedConfiguration = configurator?.refineConfiguration(script, configuration)?.let { when (it) { is ResultWithDiagnostics.Failure -> return it is ResultWithDiagnostics.Success -> it.value - ?: return ResultWithDiagnostics.Failure("Null script compile configuration received".asErrorDiagnostics()) } } ?: configuration val cached = cache.get(script, refinedConfiguration) @@ -32,7 +31,7 @@ open class JvmScriptCompiler( return compilerProxy.compile(script, refinedConfiguration, configurator).also { if (it is ResultWithDiagnostics.Success) { - cache.store(it.value as CompiledScript<*>) + cache.store(it.value, refinedConfiguration) } } } @@ -40,7 +39,7 @@ open class JvmScriptCompiler( interface CompiledJvmScriptsCache { fun get(script: ScriptSource, configuration: ScriptCompileConfiguration): CompiledScript<*>? - fun store(compiledScript: CompiledScript<*>) + fun store(compiledScript: CompiledScript<*>, configuration: ScriptCompileConfiguration) } interface KJVMCompilerProxy { @@ -53,6 +52,6 @@ interface KJVMCompilerProxy { class DummyCompiledJvmScriptCache : CompiledJvmScriptsCache { override fun get(script: ScriptSource, configuration: ScriptCompileConfiguration): CompiledScript<*>? = null - override fun store(compiledScript: CompiledScript<*>) {} + override fun store(compiledScript: CompiledScript<*>, configuration: ScriptCompileConfiguration) {} } diff --git a/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptConfiguration.kt b/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptConfiguration.kt index e4ac6c44307..711cb27066b 100644 --- a/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptConfiguration.kt +++ b/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptConfiguration.kt @@ -9,7 +9,7 @@ import kotlinx.coroutines.experimental.runBlocking import kotlin.script.experimental.api.* import java.io.File -val jvmJavaHomeParams = with(JvmScriptCompileConfigurationParams) { +val jvmJavaHomeParams = with(JvmScriptCompileConfigurationProperties) { listOf(javaHomeDir to File(System.getProperty("java.home"))) } diff --git a/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptData.kt b/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptData.kt index f09ae218fe8..231e7550f33 100644 --- a/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptData.kt +++ b/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptData.kt @@ -9,9 +9,11 @@ import java.io.File import kotlin.script.experimental.api.ScriptDependency import kotlin.script.experimental.api.typedKey -object JvmScriptCompileConfigurationParams { +object JvmScriptCompileConfigurationProperties { val javaHomeDir by typedKey() } -class JvmDependency(val classpath: Iterable) : ScriptDependency +class JvmDependency(val classpath: List) : ScriptDependency { + constructor(vararg classpathEntries: File) : this(classpathEntries.asList()) +} diff --git a/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptEvaluation.kt b/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptEvaluation.kt index f8e42dcc9d0..c43e39372aa 100644 --- a/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptEvaluation.kt +++ b/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptEvaluation.kt @@ -18,6 +18,6 @@ open class JvmBasicScriptingHost( evaluator: ScriptEvaluator ) : BasicScriptingHost(configurationExtractor, compiler, evaluator) -object JvmScriptEvaluationEnvironmentParams { +object JvmScriptEvaluationEnvironmentProperties { val baseClassLoader by typedKey() } diff --git a/libraries/scripting/misc/src/kotlin/script/experimental/misc/propertiesDsl.kt b/libraries/scripting/misc/src/kotlin/script/experimental/misc/propertiesDsl.kt index b0dde13958b..ae472f2dd22 100644 --- a/libraries/scripting/misc/src/kotlin/script/experimental/misc/propertiesDsl.kt +++ b/libraries/scripting/misc/src/kotlin/script/experimental/misc/propertiesDsl.kt @@ -18,6 +18,9 @@ inline operator fun TypedKey>.invoke(vararg vs: E): Pair TypedKey>.invoke(vararg vs: E): Pair>, Iterable> = this to vs.toList() +inline operator fun TypedKey>.invoke(vararg vs: Pair): Pair>, Map> = + this to hashMapOf(*vs) + // TODO: make tests from examples below /* val x = with(kotlin.script.experimental.api.ScriptingEnvironmentProperties) { diff --git a/plugins/scripting/scripting-cli/src/org/jetbrains/kotlin/scripting/compiler/plugin/KotlinScriptDefinitionAdapterFromNewAPI.kt b/plugins/scripting/scripting-cli/src/org/jetbrains/kotlin/scripting/compiler/plugin/KotlinScriptDefinitionAdapterFromNewAPI.kt index ee6f9d1e5de..857858fd179 100644 --- a/plugins/scripting/scripting-cli/src/org/jetbrains/kotlin/scripting/compiler/plugin/KotlinScriptDefinitionAdapterFromNewAPI.kt +++ b/plugins/scripting/scripting-cli/src/org/jetbrains/kotlin/scripting/compiler/plugin/KotlinScriptDefinitionAdapterFromNewAPI.kt @@ -13,14 +13,15 @@ import org.jetbrains.kotlin.psi.KtScript import org.jetbrains.kotlin.script.KotlinScriptDefinition import kotlin.reflect.KClass import kotlin.reflect.KType -import kotlin.script.experimental.api.ScriptCompileConfigurationParams +import kotlin.script.experimental.api.ScriptCompileConfigurationProperties import kotlin.script.experimental.api.ScriptDefinition import kotlin.script.experimental.api.ScriptDefinitionProperties +import kotlin.script.experimental.api.ScriptingEnvironmentProperties import kotlin.script.experimental.dependencies.DependenciesResolver import kotlin.script.experimental.jvm.impl.BridgeDependenciesResolver class KotlinScriptDefinitionAdapterFromNewAPI(val scriptDefinition: ScriptDefinition) : - KotlinScriptDefinition(scriptDefinition.compilationConfigurator.defaultConfiguration[ScriptCompileConfigurationParams.baseClass]) { + KotlinScriptDefinition(scriptDefinition.compilationConfigurator.defaultConfiguration[ScriptingEnvironmentProperties.baseClass]) { override val name: String get() = scriptDefinition.properties[ScriptDefinitionProperties.name] @@ -46,12 +47,12 @@ class KotlinScriptDefinitionAdapterFromNewAPI(val scriptDefinition: ScriptDefini } override val acceptedAnnotations: List> by lazy { - scriptDefinition.compilationConfigurator.defaultConfiguration.getOrNull(ScriptCompileConfigurationParams.updateConfigurationOnAnnotations)?.toList() + scriptDefinition.compilationConfigurator.defaultConfiguration.getOrNull(ScriptCompileConfigurationProperties.updateConfigurationOnAnnotations)?.toList() ?: emptyList() } override val implicitReceivers: List by lazy { - scriptDefinition.compilationConfigurator.defaultConfiguration.getOrNull(ScriptCompileConfigurationParams.scriptSignature)?.providedDeclarations?.implicitReceivers + scriptDefinition.compilationConfigurator.defaultConfiguration.getOrNull(ScriptCompileConfigurationProperties.scriptImplicitReceivers) ?: emptyList() } }