diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptDefinitionsManager.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptDefinitionsManager.kt index f34d2bc532a..b7c017bc358 100644 --- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptDefinitionsManager.kt +++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptDefinitionsManager.kt @@ -208,7 +208,7 @@ fun loadDefinitionsFromTemplates( ) } template.annotations.firstIsInstanceOrNull() != null -> { - val hostEnvironment = ScriptingEnvironment.create { + val hostEnvironment = ScriptingEnvironment { include(defaultJvmScriptingEnvironment) configurationDependencies(JvmDependency(classpath)) } 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 a29328e34c9..c36d440e5c7 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 @@ -18,7 +18,6 @@ import kotlin.script.experimental.jvm.compat.mapLegacyDiagnosticSeverity import kotlin.script.experimental.jvm.compat.mapLegacyScriptPosition import kotlin.script.experimental.jvm.dependenciesFromCurrentContext import kotlin.script.experimental.jvm.jvm -import kotlin.script.experimental.util.getOrNull @KotlinScript( extension = "scriptwithdeps.kts", @@ -28,8 +27,8 @@ abstract class MyScriptWithMavenDeps { // abstract fun body(vararg args: String): Int } -object MyScriptDefinition : ScriptDefinition { - override val properties = properties { +object MyScriptDefinition : ScriptDefinition( + { defaultImports() defaultImports(Repository::class) jvm { @@ -47,7 +46,7 @@ object MyScriptDefinition : ScriptDefinition { // other triggers: beforeParsing, onSections } } -} +) class MyConfigurator : RefineScriptCompilationConfigurationHandler { @@ -59,7 +58,7 @@ class MyConfigurator : RefineScriptCompilationConfigurationHandler { configuration: ScriptCompileConfiguration?, processedScriptData: ProcessedScriptData? ): ResultWithDiagnostics { - val annotations = processedScriptData?.getOrNull(ProcessedScriptData.foundAnnotations)?.takeIf { it.isNotEmpty() } + val annotations = processedScriptData?.get(ProcessedScriptData.foundAnnotations)?.takeIf { it.isNotEmpty() } ?: return configuration.asSuccess() val scriptContents = object : ScriptContents { override val annotations: Iterable = annotations @@ -75,7 +74,7 @@ class MyConfigurator : RefineScriptCompilationConfigurationHandler { ?: return configuration.asSuccess(diagnostics) val resolvedClasspath = newDepsFromResolver.classpath.toList().takeIf { it.isNotEmpty() } ?: return configuration.asSuccess(diagnostics) - ScriptCompileConfiguration.create { + ScriptCompileConfiguration { dependencies(JvmDependency(resolvedClasspath)) }.asSuccess(diagnostics) } catch (e: Throwable) { 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 d37a93f5227..16de8bfb243 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 @@ -17,7 +17,7 @@ import kotlin.script.experimental.jvm.jvm import kotlin.script.experimental.jvmhost.makeBasicHostFromAnnotatedScriptBaseClass fun evalFile(scriptFile: File): ResultWithDiagnostics { - val additionalCompilationProperties = ScriptCompileConfiguration.create { + val additionalCompilationProperties = ScriptCompileConfiguration { jvm { dependenciesFromCurrentContext( "scripting-jvm-simple-script" /* script library jar name */ 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 5f1716c46e1..c039670b60f 100644 --- a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptConfiguration.kt +++ b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptConfiguration.kt @@ -9,45 +9,52 @@ package kotlin.script.experimental.api import kotlin.script.experimental.util.PropertiesCollection -interface ScriptCompileConfiguration : PropertiesCollection { +interface ScriptCompileConfigurationKeys + +class ScriptCompileConfiguration(baseConfigurations: Iterable, body: Builder.() -> Unit) : + PropertiesCollection(Builder(baseConfigurations).apply(body).data) { + + constructor(body: Builder.() -> Unit = {}) : this(emptyList(), body) + constructor( + vararg baseConfigurations: ScriptCompileConfiguration, body: Builder.() -> Unit = {} + ) : this(baseConfigurations.asIterable(), body) + + class Builder internal constructor(baseConfigurations: Iterable) : + ScriptCompileConfigurationKeys, + PropertiesCollection.Builder(baseConfigurations) - companion object : ScriptCompileConfiguration { - - class Builder internal constructor() : PropertiesCollection.Builder(), ScriptCompileConfiguration { - override val properties = data - } - - fun create(body: Builder.() -> Unit): ScriptCompileConfiguration = Builder().apply(body) - } + companion object : ScriptCompileConfigurationKeys } -val ScriptCompileConfiguration.sourceFragments by PropertiesCollection.key>() +val ScriptCompileConfigurationKeys.sourceFragments by PropertiesCollection.key>() -val ScriptCompileConfiguration.scriptBodyTarget by PropertiesCollection.keyCopy(ScriptDefinition.scriptBodyTarget) +val ScriptCompileConfigurationKeys.scriptBodyTarget by PropertiesCollection.keyCopy(ScriptDefinition.scriptBodyTarget) -val ScriptCompileConfiguration.scriptImplicitReceivers by PropertiesCollection.keyCopy(ScriptDefinition.scriptImplicitReceivers) +val ScriptCompileConfigurationKeys.scriptImplicitReceivers by PropertiesCollection.keyCopy(ScriptDefinition.scriptImplicitReceivers) -val ScriptCompileConfiguration.contextVariables by PropertiesCollection.keyCopy(ScriptDefinition.contextVariables) +val ScriptCompileConfigurationKeys.contextVariables by PropertiesCollection.keyCopy(ScriptDefinition.contextVariables) -val ScriptCompileConfiguration.defaultImports by PropertiesCollection.keyCopy(ScriptDefinition.defaultImports) +val ScriptCompileConfigurationKeys.defaultImports by PropertiesCollection.keyCopy(ScriptDefinition.defaultImports) -val ScriptCompileConfiguration.restrictions by PropertiesCollection.keyCopy(ScriptDefinition.restrictions) +val ScriptCompileConfigurationKeys.restrictions by PropertiesCollection.keyCopy(ScriptDefinition.restrictions) -val ScriptCompileConfiguration.importedScripts by PropertiesCollection.keyCopy(ScriptDefinition.importedScripts) +val ScriptCompileConfigurationKeys.importedScripts by PropertiesCollection.keyCopy(ScriptDefinition.importedScripts) -val ScriptCompileConfiguration.dependencies by PropertiesCollection.keyCopy(ScriptDefinition.dependencies) +val ScriptCompileConfigurationKeys.dependencies by PropertiesCollection.keyCopy(ScriptDefinition.dependencies) -val ScriptCompileConfiguration.compilerOptions by PropertiesCollection.keyCopy(ScriptDefinition.compilerOptions) +val ScriptCompileConfigurationKeys.compilerOptions by PropertiesCollection.keyCopy(ScriptDefinition.compilerOptions) -interface ProcessedScriptData : PropertiesCollection { +interface ProcessedScriptDataKeys - companion object : ProcessedScriptData +class ProcessedScriptData(properties: Map, Any>) : PropertiesCollection(properties) { + + companion object : ProcessedScriptDataKeys } -val ProcessedScriptData.foundAnnotations by PropertiesCollection.key>() +val ProcessedScriptDataKeys.foundAnnotations by PropertiesCollection.key>() -val ProcessedScriptData.foundFragments by PropertiesCollection.key>() +val ProcessedScriptDataKeys.foundFragments by PropertiesCollection.key>() interface RefineScriptCompilationConfigurationHandler { diff --git a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptDefinition.kt b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptDefinition.kt index a1bffd70185..23cbb9f1492 100644 --- a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptDefinition.kt +++ b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptDefinition.kt @@ -10,57 +10,62 @@ package kotlin.script.experimental.api import kotlin.reflect.KClass import kotlin.script.experimental.util.PropertiesCollection -interface ScriptDefinition : PropertiesCollection { +interface ScriptDefinitionKeys - companion object : ScriptDefinition { +open class ScriptDefinition(baseDefinitions: Iterable, body: Builder.() -> Unit) : + PropertiesCollection(Builder(baseDefinitions).apply(body).data) { - class Builder internal constructor() : PropertiesCollection.Builder(), ScriptDefinition { - override val properties = data - } + constructor(body: Builder.() -> Unit = {}) : this(emptyList(), body) + constructor(vararg baseDefinitions: ScriptDefinition, body: Builder.() -> Unit = {}) : this(baseDefinitions.asIterable(), body) - fun create(body: Builder.() -> Unit): ScriptDefinition = Builder().apply(body) + class Builder internal constructor(baseDefinitions: Iterable) : + ScriptDefinitionKeys, + PropertiesCollection.Builder(baseDefinitions) + + // inherited from script definition for using as a keys anchor + companion object : ScriptDefinitionKeys { + + val Default = ScriptDefinition() } - - object Default : ScriptDefinition } -val ScriptDefinition.name by PropertiesCollection.key("Kotlin script") // Name of the script type +val ScriptDefinitionKeys.name by PropertiesCollection.key("Kotlin script") // Name of the script type -val ScriptDefinition.fileExtension by PropertiesCollection.key("kts") // file extension +val ScriptDefinitionKeys.fileExtension by PropertiesCollection.key("kts") // file extension -val ScriptDefinition.baseClass by PropertiesCollection.key() // script base class +val ScriptDefinitionKeys.baseClass by PropertiesCollection.key() // script base class -val ScriptDefinition.scriptBodyTarget by PropertiesCollection.key(ScriptBodyTarget.Constructor) +val ScriptDefinitionKeys.scriptBodyTarget by PropertiesCollection.key(ScriptBodyTarget.Constructor) -val ScriptDefinition.scriptImplicitReceivers by PropertiesCollection.key>() // in the order from outer to inner scope +val ScriptDefinitionKeys.scriptImplicitReceivers by PropertiesCollection.key>() // in the order from outer to inner scope -val ScriptDefinition.contextVariables by PropertiesCollection.key>() // external variables +val ScriptDefinitionKeys.contextVariables by PropertiesCollection.key>() // external variables -val ScriptDefinition.defaultImports by PropertiesCollection.key>() +val ScriptDefinitionKeys.defaultImports by PropertiesCollection.key>() -val ScriptDefinition.restrictions by PropertiesCollection.key>() +val ScriptDefinitionKeys.restrictions by PropertiesCollection.key>() -val ScriptDefinition.importedScripts by PropertiesCollection.key>() +val ScriptDefinitionKeys.importedScripts by PropertiesCollection.key>() -val ScriptDefinition.dependencies by PropertiesCollection.key>() +val ScriptDefinitionKeys.dependencies by PropertiesCollection.key>() -val ScriptDefinition.generatedClassAnnotations by PropertiesCollection.key>() +val ScriptDefinitionKeys.generatedClassAnnotations by PropertiesCollection.key>() -val ScriptDefinition.generatedMethodAnnotations by PropertiesCollection.key>() +val ScriptDefinitionKeys.generatedMethodAnnotations by PropertiesCollection.key>() -val ScriptDefinition.compilerOptions by PropertiesCollection.key>() // Q: CommonCompilerOptions instead? +val ScriptDefinitionKeys.compilerOptions by PropertiesCollection.key>() // Q: CommonCompilerOptions instead? -val ScriptDefinition.refineConfigurationHandler by PropertiesCollection.key() // dynamic configurator +val ScriptDefinitionKeys.refineConfigurationHandler by PropertiesCollection.key() // dynamic configurator -val ScriptDefinition.refineConfigurationBeforeParsing by PropertiesCollection.key() // default: false +val ScriptDefinitionKeys.refineConfigurationBeforeParsing by PropertiesCollection.key() // default: false -val ScriptDefinition.refineConfigurationOnAnnotations by PropertiesCollection.key>() +val ScriptDefinitionKeys.refineConfigurationOnAnnotations by PropertiesCollection.key>() -val ScriptDefinition.refineConfigurationOnSections by PropertiesCollection.key>() +val ScriptDefinitionKeys.refineConfigurationOnSections by PropertiesCollection.key>() // DSL: -val ScriptDefinition.refineConfiguration get() = RefineConfigurationBuilder() +val ScriptDefinition.Builder.refineConfiguration get() = RefineConfigurationBuilder() class RefineConfigurationBuilder : PropertiesCollection.Builder() { diff --git a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptEvaluation.kt b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptEvaluation.kt index 99d539244d7..52bf3eeb403 100644 --- a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptEvaluation.kt +++ b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptEvaluation.kt @@ -9,25 +9,30 @@ package kotlin.script.experimental.api import kotlin.script.experimental.util.PropertiesCollection -interface ScriptEvaluationEnvironment : PropertiesCollection { +interface ScriptEvaluationEnvironmentKeys - companion object : ScriptEvaluationEnvironment { +class ScriptEvaluationEnvironment(baseEvaluationEnvironments: Iterable, body: Builder.() -> Unit) : + PropertiesCollection(Builder(baseEvaluationEnvironments).apply(body).data) { - class Builder internal constructor() : PropertiesCollection.Builder(), ScriptEvaluationEnvironment { - override val properties = data - } + constructor(body: Builder.() -> Unit = {}) : this(emptyList(), body) + constructor( + vararg baseEvaluationEnvironments: ScriptEvaluationEnvironment, body: Builder.() -> Unit = {} + ) : this(baseEvaluationEnvironments.asIterable(), body) - fun create(body: Builder.() -> Unit): ScriptEvaluationEnvironment = Builder().apply(body) - } + class Builder internal constructor(baseEvaluationEnvironments: Iterable) : + ScriptDefinitionKeys, + PropertiesCollection.Builder(baseEvaluationEnvironments) + + companion object : ScriptEvaluationEnvironmentKeys } -val ScriptEvaluationEnvironment.implicitReceivers by PropertiesCollection.key>() +val ScriptEvaluationEnvironmentKeys.implicitReceivers by PropertiesCollection.key>() -val ScriptEvaluationEnvironment.contextVariables by PropertiesCollection.key>() // external variables +val ScriptEvaluationEnvironmentKeys.contextVariables by PropertiesCollection.key>() // external variables -val ScriptEvaluationEnvironment.constructorArgs by PropertiesCollection.key>() +val ScriptEvaluationEnvironmentKeys.constructorArgs by PropertiesCollection.key>() -val ScriptEvaluationEnvironment.runArgs by PropertiesCollection.key>() +val ScriptEvaluationEnvironmentKeys.runArgs by PropertiesCollection.key>() sealed class ResultValue { class Value(val name: String, val value: Any?, val type: String) : ResultValue() { diff --git a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptingEnvironment.kt b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptingEnvironment.kt index 52f66510d23..d2cb5ffa621 100644 --- a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptingEnvironment.kt +++ b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptingEnvironment.kt @@ -7,37 +7,42 @@ package kotlin.script.experimental.api import kotlin.reflect.KClass import kotlin.script.experimental.util.PropertiesCollection -import kotlin.script.experimental.util.getOrNull -interface ScriptingEnvironment : PropertiesCollection { +interface ScriptingEnvironmentKeys - companion object : ScriptingEnvironment { +class ScriptingEnvironment(baseScriptingEnvironments: Iterable, body: Builder.() -> Unit) : + PropertiesCollection(Builder(baseScriptingEnvironments).apply(body).data) { - class Builder internal constructor() : PropertiesCollection.Builder(), ScriptingEnvironment { - override val properties = data - } + constructor(body: Builder.() -> Unit = {}) : this(emptyList(), body) + constructor( + vararg baseScriptingEnvironments: ScriptingEnvironment, body: Builder.() -> Unit = {} + ) : this(baseScriptingEnvironments.asIterable(), body) - fun create(body: Builder.() -> Unit): ScriptingEnvironment = Builder().apply(body) - } + class Builder internal constructor(baseScriptingEnvironments: Iterable) : + ScriptingEnvironmentKeys, + PropertiesCollection.Builder(baseScriptingEnvironments) + + companion object : ScriptingEnvironmentKeys } // should contain all dependencies needed for baseClass and compilationConfigurator -val ScriptingEnvironment.configurationDependencies by PropertiesCollection.key>() +val ScriptingEnvironmentKeys.configurationDependencies by PropertiesCollection.key>() // do not use configurationDependencies as script dependencies, so only the dependencies defined by compilationConfigurator will be used // (NOTE: in this case they should include the dependencies for the base class anyway, since this class is needed for script // compilation and instantiation, but compilationConfigurator could be excluded) -val ScriptingEnvironment.isolatedDependencies by PropertiesCollection.key(false) +val ScriptingEnvironmentKeys.isolatedDependencies by PropertiesCollection.key(false) // a "class loader" for KotlinTypes -val ScriptingEnvironment.getScriptingClass by PropertiesCollection.key() +val ScriptingEnvironmentKeys.getScriptingClass by PropertiesCollection.key() + interface GetScriptingClass { operator fun invoke(classType: KotlinType, contextClass: KClass<*>, environment: ScriptingEnvironment): KClass<*> } fun ScriptingEnvironment.getScriptingClass(type: KotlinType, contextClass: KClass<*>): KClass<*> { - val getClass = getOrNull(ScriptingEnvironment.getScriptingClass) + val getClass = get(ScriptingEnvironment.getScriptingClass) ?: throw IllegalArgumentException("Expecting 'getScriptingClass' property in the scripting environment: unable to load scripting class $type") return getClass(type, contextClass, this) } diff --git a/libraries/scripting/common/src/kotlin/script/experimental/definitions/definitionFromAnnotation.kt b/libraries/scripting/common/src/kotlin/script/experimental/definitions/definitionFromAnnotation.kt index 16d1d0936e5..2d48a260172 100644 --- a/libraries/scripting/common/src/kotlin/script/experimental/definitions/definitionFromAnnotation.kt +++ b/libraries/scripting/common/src/kotlin/script/experimental/definitions/definitionFromAnnotation.kt @@ -12,7 +12,6 @@ import kotlin.script.experimental.annotations.KotlinScript import kotlin.script.experimental.annotations.KotlinScriptFileExtension import kotlin.script.experimental.annotations.KotlinScriptProperties import kotlin.script.experimental.api.* -import kotlin.script.experimental.util.getOrNull private const val ERROR_MSG_PREFIX = "Unable to construct script definition: " @@ -25,7 +24,7 @@ fun createScriptDefinitionFromAnnotatedBaseClass( contextClass: KClass<*> = ScriptDefinition::class ): ScriptDefinition { - val getScriptingClass = environment.getOrNull(ScriptingEnvironment.getScriptingClass) + val getScriptingClass = environment[ScriptingEnvironment.getScriptingClass] ?: throw IllegalArgumentException("${ERROR_MSG_PREFIX}Expecting 'getScriptingClass' parameter in the scripting environment") val baseClass: KClass<*> = @@ -44,17 +43,15 @@ fun createScriptDefinitionFromAnnotatedBaseClass( throw IllegalArgumentException(ILLEGAL_CONFIG_ANN_ARG, e) } - return object : ScriptDefinition { - override val properties = properties { - baseClass(baseClassType) - fileExtension(baseClass.findAnnotation()?.extension ?: mainAnnotation.extension) - name(mainAnnotation.name) + return ScriptDefinition { + baseClass(baseClassType) + fileExtension(baseClass.findAnnotation()?.extension ?: mainAnnotation.extension) + name(mainAnnotation.name) - include(scriptingPropsInstance(mainAnnotation.definition)) + include(scriptingPropsInstance(mainAnnotation.definition)) - baseClass.annotations.filterIsInstance(KotlinScriptProperties::class.java).forEach { ann -> - include(scriptingPropsInstance(ann.definition)) - } + baseClass.annotations.filterIsInstance(KotlinScriptProperties::class.java).forEach { ann -> + include(scriptingPropsInstance(ann.definition)) } } } 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 a5117d9cde7..faae662e029 100644 --- a/libraries/scripting/common/src/kotlin/script/experimental/host/scriptHostUtil.kt +++ b/libraries/scripting/common/src/kotlin/script/experimental/host/scriptHostUtil.kt @@ -11,7 +11,6 @@ import kotlin.script.experimental.api.ScriptCompileConfiguration import kotlin.script.experimental.api.ScriptSource import kotlin.script.experimental.api.ScriptSourceNamedFragment import kotlin.script.experimental.api.sourceFragments -import kotlin.script.experimental.util.getOrNull fun ScriptSource.getScriptText(): String = when { text != null -> text!! @@ -22,7 +21,7 @@ fun ScriptSource.getScriptText(): String = when { fun getMergedScriptText(script: ScriptSource, configuration: ScriptCompileConfiguration?): String { val originalScriptText = script.getScriptText() - val sourceFragments = configuration?.getOrNull(ScriptCompileConfiguration.sourceFragments) + val sourceFragments = configuration?.get(ScriptCompileConfiguration.sourceFragments) return if (sourceFragments == null || sourceFragments.isEmpty()) { originalScriptText } else { diff --git a/libraries/scripting/common/src/kotlin/script/experimental/repl/replEvaluation.kt b/libraries/scripting/common/src/kotlin/script/experimental/repl/replEvaluation.kt index 30e2471ff0e..b563cd2f6f7 100644 --- a/libraries/scripting/common/src/kotlin/script/experimental/repl/replEvaluation.kt +++ b/libraries/scripting/common/src/kotlin/script/experimental/repl/replEvaluation.kt @@ -9,16 +9,21 @@ import kotlin.script.experimental.api.EvaluationResult import kotlin.script.experimental.api.ResultWithDiagnostics import kotlin.script.experimental.util.PropertiesCollection -interface ReplEvaluationEnvironment : PropertiesCollection { +interface ReplEvaluationEnvironmentKeys - companion object : ReplEvaluationEnvironment { +class ReplEvaluationEnvironment(baseEvaluationEnvironments: Iterable, body: Builder.() -> Unit) : + PropertiesCollection(Builder(baseEvaluationEnvironments).apply(body).data) { - class Builder internal constructor() : PropertiesCollection.Builder(), ReplEvaluationEnvironment { - override val properties = data - } + constructor(body: Builder.() -> Unit = {}) : this(emptyList(), body) + constructor( + vararg baseEvaluationEnvironments: ReplEvaluationEnvironment, body: Builder.() -> Unit = {} + ) : this(baseEvaluationEnvironments.asIterable(), body) - fun create(body: Builder.() -> Unit): ReplEvaluationEnvironment = Builder().apply(body) - } + class Builder internal constructor(baseEvaluationEnvironments: Iterable) : + ReplEvaluationEnvironmentKeys, + PropertiesCollection.Builder(baseEvaluationEnvironments) + + companion object : ReplEvaluationEnvironmentKeys } interface ReplSnippetEvaluator { diff --git a/libraries/scripting/common/src/kotlin/script/experimental/repl/replHost.kt b/libraries/scripting/common/src/kotlin/script/experimental/repl/replHost.kt index 40411324f5c..7d655661984 100644 --- a/libraries/scripting/common/src/kotlin/script/experimental/repl/replHost.kt +++ b/libraries/scripting/common/src/kotlin/script/experimental/repl/replHost.kt @@ -22,19 +22,24 @@ interface ReplCommandProcessor { data class ReplCommand(val commandName: String, val processor: ReplCommandProcessor) -interface ReplHostEnvironment : PropertiesCollection { +interface ReplHostEnvironmentKeys - companion object : ReplHostEnvironment { +class ReplHostEnvironment(baseReplHostEnvironments: Iterable, body: Builder.() -> Unit) : + PropertiesCollection(Builder(baseReplHostEnvironments).apply(body).data) { - class Builder internal constructor() : PropertiesCollection.Builder(), ReplHostEnvironment { - override val properties = data - } + constructor(body: Builder.() -> Unit = {}) : this(emptyList(), body) + constructor( + vararg baseReplHostEnvironments: ReplHostEnvironment, body: Builder.() -> Unit = {} + ) : this(baseReplHostEnvironments.asIterable(), body) - fun create(body: Builder.() -> Unit): ReplHostEnvironment = Builder().apply(body) - } + class Builder internal constructor(baseReplHostEnvironments: Iterable) : + ReplHostEnvironmentKeys, + PropertiesCollection.Builder(baseReplHostEnvironments) + + companion object : ReplHostEnvironmentKeys } -val ReplHostEnvironment.replCommands by PropertiesCollection.key>() +val ReplHostEnvironmentKeys.replCommands by PropertiesCollection.key>() abstract class ReplHost( val environment: ReplHostEnvironment, diff --git a/libraries/scripting/common/src/kotlin/script/experimental/util/propertiesCollection.kt b/libraries/scripting/common/src/kotlin/script/experimental/util/propertiesCollection.kt index 21387306246..b0336a4fb0a 100644 --- a/libraries/scripting/common/src/kotlin/script/experimental/util/propertiesCollection.kt +++ b/libraries/scripting/common/src/kotlin/script/experimental/util/propertiesCollection.kt @@ -10,9 +10,7 @@ import kotlin.reflect.KProperty import kotlin.reflect.KType import kotlin.script.experimental.api.KotlinType -interface PropertiesCollection { - - val properties: Map, Any> get() = emptyMap() +open class PropertiesCollection(val properties: Map, Any> = emptyMap()) { data class Key(val name: String, val defaultValue: T? = null) @@ -25,22 +23,27 @@ interface PropertiesCollection { operator fun getValue(thisRef: Any?, property: KProperty<*>): Key = source } + @Suppress("UNCHECKED_CAST") + operator fun get(key: PropertiesCollection.Key): T? = + properties[key]?.let { it as T } ?: key.defaultValue + + companion object { fun key(defaultValue: T? = null) = PropertyKeyDelegate(defaultValue) fun keyCopy(source: Key) = PropertyKeyCopyDelegate(source) } - fun properties(body: Builder.() -> Unit): Map, Any> = Builder().apply(body).data - // properties builder base class (DSL for building properties collection) - open class Builder { + open class Builder(baseProperties: Iterable = emptyList()) { - val data: MutableMap, Any> = LinkedHashMap() + val data: MutableMap, Any> = LinkedHashMap, Any>().apply { + baseProperties.forEach { putAll(it.properties) } + } // generic builder for all properties operator fun PropertiesCollection.Key.invoke(v: T) { - set(this, v) + data[this] = v } // generic for lists @@ -59,28 +62,28 @@ interface PropertiesCollection { @JvmName("invoke_string_fqn_from_generic") inline operator fun PropertiesCollection.Key.invoke() { - set(this, K::class.qualifiedName!!) + data[this] = K::class.java.name } @JvmName("invoke_string_fqn_from_reflected_class") operator fun PropertiesCollection.Key.invoke(kclass: KClass<*>) { - set(this, kclass.qualifiedName!!) + data[this] = kclass.java.name } @JvmName("invoke_string_list_fqn_from_generic") inline operator fun PropertiesCollection.Key>.invoke() { - append(K::class.qualifiedName!!) + append(K::class.java.name) } @JvmName("invoke_string_list_fqn_from_reflected_class") operator fun PropertiesCollection.Key>.invoke(vararg kclasses: KClass<*>) { - append(kclasses.map { it.qualifiedName!! }) + append(kclasses.map { it.java.name }) } // for KotlinType: inline operator fun PropertiesCollection.Key.invoke() { - set(this, KotlinType(K::class)) + data[this] = KotlinType(K::class) } operator fun PropertiesCollection.Key.invoke(kclass: KClass<*>) { @@ -138,7 +141,7 @@ interface PropertiesCollection { } @Suppress("UNCHECKED_CAST") - operator fun get(key: PropertiesCollection.Key): T? = data[key]?.let { it as T } + private operator fun get(key: PropertiesCollection.Key): T? = data[key]?.let { it as T } // appenders to list and map properties @@ -174,15 +177,22 @@ interface PropertiesCollection { this.body() this@Builder.data.putAll(this.data) } + + // a class for extending properties + interface BuilderExtension { + fun get(): T + } + + // include another builder extension + operator fun BuilderExtension.invoke(body: T.() -> Unit) { + val builder = this.get().apply(body) + this@Builder.data.putAll(builder.data) + } } } -@Suppress("UNCHECKED_CAST") -fun PropertiesCollection.getOrNull(key: PropertiesCollection.Key): T? = - properties[key]?.let { it as T } ?: key.defaultValue - -fun PropertiesCollection.getOrError(key: PropertiesCollection.Key): T = - getOrNull(key) ?: throw IllegalArgumentException("Unknown key $key") +fun PropertiesCollection.getOrError(key: PropertiesCollection.Key): T = + get(key) ?: throw IllegalArgumentException("Unknown key $key") @Suppress("UNCHECKED_CAST") fun getFirstFromChainOrNull(key: PropertiesCollection.Key, vararg propertyCollections: PropertiesCollection?): T? { @@ -193,16 +203,3 @@ fun getFirstFromChainOrNull(key: PropertiesCollection.Key, vararg propert return key.defaultValue } -@Suppress("UNCHECKED_CAST") -fun getMergedFromChainOrNull(key: PropertiesCollection.Key>, vararg propertyCollections: PropertiesCollection?): List? { - var found = false - val res = ArrayList() - for (collection in propertyCollections) { - val value = collection?.properties?.get(key) - if (value != null) { - found = true - res.addAll(value as List) - } - } - return if (found) res else key.defaultValue -} 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 c4044c3d780..a926defbc3c 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 @@ -40,16 +40,15 @@ 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.JvmScriptCompilationConfiguration import kotlin.script.experimental.jvm.impl.BridgeDependenciesResolver import kotlin.script.experimental.jvm.javaHome +import kotlin.script.experimental.jvm.jvm import kotlin.script.experimental.jvmhost.JvmScriptEvaluationEnvironment import kotlin.script.experimental.jvmhost.KJvmCompilerProxy import kotlin.script.experimental.jvmhost.baseClassLoader import kotlin.script.experimental.util.getFirstFromChainOrNull import kotlin.script.experimental.util.getMergedFromChainOrNull import kotlin.script.experimental.util.getOrError -import kotlin.script.experimental.util.getOrNull class KJvmCompiledScript( override val definition: ScriptDefinition, @@ -59,9 +58,9 @@ class KJvmCompiledScript( ) : CompiledScript { override suspend fun instantiate(scriptEvaluationEnvironment: ScriptEvaluationEnvironment?): ResultWithDiagnostics = try { - val baseClassLoader = scriptEvaluationEnvironment?.getOrNull(JvmScriptEvaluationEnvironment.baseClassLoader) + val baseClassLoader = scriptEvaluationEnvironment?.get(JvmScriptEvaluationEnvironment.baseClassLoader) ?: Thread.currentThread().contextClassLoader - val dependencies = additionalConfiguration?.getOrNull(ScriptDefinition.dependencies) + val dependencies = additionalConfiguration?.get(ScriptDefinition.dependencies) ?.flatMap { (it as? JvmDependency)?.classpath?.map { it.toURI().toURL() } ?: emptyList() } // TODO: previous dependencies and classloaders should be taken into account here val classLoaderWithDeps = @@ -98,7 +97,7 @@ class KJvmCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJvmCompiler fun updateClasspath(classpath: List) { environment!!.updateClasspath(classpath.map(::JvmClasspathRoot)) if (classpath.isNotEmpty()) { - updatedScriptCompileConfiguration = ScriptCompileConfiguration.create { + updatedScriptCompileConfiguration = ScriptCompileConfiguration { include(updatedScriptCompileConfiguration) dependencies.append(JvmDependency(classpath)) } @@ -115,7 +114,7 @@ class KJvmCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJvmCompiler put(JVMConfigurationKeys.RETAIN_OUTPUT_IN_MEMORY, true) var isModularJava = false - getFirstFromChainOrNull(JvmScriptCompilationConfiguration.javaHome, updatedScriptCompileConfiguration, hostEnvironment)?.let { + getFirstFromChainOrNull(ScriptCompileConfiguration.jvm.javaHome, updatedScriptCompileConfiguration, hostEnvironment)?.let { put(JVMConfigurationKeys.JDK_HOME, it) isModularJava = CoreJrtFileSystem.isModularJdk(it) } @@ -254,7 +253,7 @@ internal class BridgeScriptDefinition( ) { override val acceptedAnnotations = run { val cl = this::class.java.classLoader - additionalCompilationConfiguration?.getOrNull(ScriptDefinition.refineConfigurationOnAnnotations) + additionalCompilationConfiguration?.get(ScriptDefinition.refineConfigurationOnAnnotations) ?.map { (cl.loadClass(it.typeName) as Class).kotlin } ?: emptyList() } diff --git a/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/jvmHostUtil.kt b/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/jvmHostUtil.kt index 943df4772a8..012f742d5c4 100644 --- a/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/jvmHostUtil.kt +++ b/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/jvmHostUtil.kt @@ -14,7 +14,7 @@ internal fun mergeConfigurations(vararg configurations: ScriptCompileConfigurati return when { nonEmptyConfigurations.isEmpty() -> null nonEmptyConfigurations.size == 1 -> nonEmptyConfigurations.first()!! - else -> ScriptCompileConfiguration.create { + else -> ScriptCompileConfiguration { for (configuration in nonEmptyConfigurations) { include(configuration!!) } @@ -28,8 +28,5 @@ fun ScriptingEnvironment.withDefaults(): ScriptingEnvironment = }) { this } else { - ScriptingEnvironment.create { - include(defaultJvmScriptingEnvironment) - include(this) - } + ScriptingEnvironment(defaultJvmScriptingEnvironment, this) } diff --git a/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/jvmScriptCompilation.kt b/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/jvmScriptCompilation.kt index ae69f09236d..a3a2103d6e5 100644 --- a/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/jvmScriptCompilation.kt +++ b/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/jvmScriptCompilation.kt @@ -12,7 +12,6 @@ import kotlin.script.experimental.jvm.defaultJvmScriptingEnvironment import kotlin.script.experimental.jvmhost.impl.KJvmCompilerImpl import kotlin.script.experimental.jvmhost.impl.mergeConfigurations import kotlin.script.experimental.jvmhost.impl.withDefaults -import kotlin.script.experimental.util.getOrNull interface CompiledJvmScriptsCache { fun get(script: ScriptSource, scriptDefinition: ScriptDefinition, configuration: ScriptCompileConfiguration?): CompiledScript<*>? @@ -41,9 +40,9 @@ open class JvmScriptCompiler( scriptDefinition: ScriptDefinition, additionalConfiguration: ScriptCompileConfiguration? ): ResultWithDiagnostics> { - val refineConfigurationFn = scriptDefinition.getOrNull(ScriptDefinition.refineConfigurationHandler) + val refineConfigurationFn = scriptDefinition[ScriptDefinition.refineConfigurationHandler] val refinedConfiguration = - if (scriptDefinition.getOrNull(ScriptDefinition.refineConfigurationBeforeParsing) == true) { + if (scriptDefinition[ScriptDefinition.refineConfigurationBeforeParsing] == true) { if (refineConfigurationFn == null) { return ResultWithDiagnostics.Failure("Non-null configurator expected".asErrorDiagnostics()) } diff --git a/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/jvmScriptEvaluation.kt b/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/jvmScriptEvaluation.kt index 90d47cea765..9eb6a25554a 100644 --- a/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/jvmScriptEvaluation.kt +++ b/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/jvmScriptEvaluation.kt @@ -9,7 +9,6 @@ package kotlin.script.experimental.jvmhost import kotlin.script.experimental.api.* import kotlin.script.experimental.util.PropertiesCollection -import kotlin.script.experimental.util.getOrNull open class JvmScriptEvaluationEnvironment : PropertiesCollection.Builder() { @@ -38,7 +37,7 @@ open class BasicJvmScriptEvaluator : ScriptEvaluator { if (scriptObject !is Class<*>) ResultWithDiagnostics.Failure(ScriptDiagnostic("expecting class in this implementation, got ${scriptObject?.javaClass}")) else { - val receivers = scriptEvaluationEnvironment?.getOrNull(ScriptEvaluationEnvironment.implicitReceivers) + val receivers = scriptEvaluationEnvironment?.get(ScriptEvaluationEnvironment.implicitReceivers) val instance = if (receivers == null) { scriptObject.getConstructor().newInstance() } else { 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 663a7aaf574..cd6593a86a3 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 @@ -19,7 +19,6 @@ import kotlin.script.experimental.jvm.JvmDependency import kotlin.script.experimental.jvm.compat.mapToLegacyScriptReportPosition import kotlin.script.experimental.jvm.compat.mapToLegacyScriptReportSeverity import kotlin.script.experimental.util.getFirstFromChainOrNull -import kotlin.script.experimental.util.getOrNull class BridgeDependenciesResolver( val scriptDefinition: ScriptDefinition, @@ -36,13 +35,13 @@ class BridgeDependenciesResolver( return try { val diagnostics = arrayListOf() - val processedScriptData = object : ProcessedScriptData { - override val properties = properties { - foundAnnotations.append(scriptContents.annotations) - } - } + val processedScriptData = ProcessedScriptData( + mapOf( + ProcessedScriptData.foundAnnotations to scriptContents.annotations + ) + ) - val refineFn = scriptDefinition.getOrNull(ScriptDefinition.refineConfigurationHandler) + val refineFn = scriptDefinition[ScriptDefinition.refineConfigurationHandler] val refinedConfiguration = if (refineFn == null) null else { @@ -59,7 +58,7 @@ class BridgeDependenciesResolver( } } - val newClasspath = refinedConfiguration?.getOrNull(ScriptDefinition.dependencies) + val newClasspath = refinedConfiguration?.get(ScriptDefinition.dependencies) ?.flatMap { (it as JvmDependency).classpath } ?: emptyList() if (newClasspath.isNotEmpty()) { val oldClasspath = 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 b126b63838f..53477d8eb0e 100644 --- a/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptConfiguration.kt +++ b/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptConfiguration.kt @@ -7,14 +7,22 @@ package kotlin.script.experimental.jvm -import kotlin.script.experimental.api.ScriptCompileConfiguration +import kotlin.script.experimental.api.ScriptCompileConfigurationKeys +import kotlin.script.experimental.api.ScriptingEnvironment import kotlin.script.experimental.util.PropertiesCollection -open class JvmScriptCompilationConfiguration : JvmScriptDefinition() { +interface JvmScriptCompilationConfigurationKeys - companion object : JvmScriptCompilationConfiguration() +open class JvmScriptCompilationConfigurationBuilder : JvmScriptCompilationConfigurationKeys, JvmScriptDefinition() { + + companion object : + PropertiesCollection.Builder.BuilderExtension, + JvmScriptCompilationConfigurationKeys { + + override fun get() = JvmScriptCompilationConfigurationBuilder() + } } -val JvmScriptCompilationConfiguration.javaHome by PropertiesCollection.keyCopy(JvmScriptingEnvironment.javaHome) +val JvmScriptCompilationConfigurationKeys.javaHome by PropertiesCollection.keyCopy(ScriptingEnvironment.jvm.javaHome) -val ScriptCompileConfiguration.jvm get() = JvmScriptCompilationConfiguration() +val ScriptCompileConfigurationKeys.jvm get() = JvmScriptCompilationConfigurationBuilder() diff --git a/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptDefinition.kt b/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptDefinition.kt index 5900f50e723..1824b107f7f 100644 --- a/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptDefinition.kt +++ b/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptDefinition.kt @@ -8,16 +8,14 @@ package kotlin.script.experimental.jvm import org.jetbrains.kotlin.script.util.scriptCompilationClasspathFromContext import java.io.File import kotlin.script.experimental.api.ScriptDefinition +import kotlin.script.experimental.api.ScriptDefinitionKeys import kotlin.script.experimental.api.ScriptDependency import kotlin.script.experimental.api.dependencies import kotlin.script.experimental.util.PropertiesCollection -open class JvmScriptDefinition : PropertiesCollection.Builder() { +open class JvmScriptDefinition : PropertiesCollection.Builder() - companion object : JvmScriptDefinition() -} - -val ScriptDefinition.jvm get() = JvmScriptDefinition() +val ScriptDefinitionKeys.jvm get() = JvmScriptDefinition() class JvmDependency(val classpath: List) : ScriptDependency { diff --git a/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptEnvironment.kt b/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptEnvironment.kt index 7b48e701b95..06fc68d6dab 100644 --- a/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptEnvironment.kt +++ b/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptEnvironment.kt @@ -10,17 +10,23 @@ import java.net.URLClassLoader import kotlin.reflect.KClass import kotlin.script.experimental.api.* import kotlin.script.experimental.util.PropertiesCollection -import kotlin.script.experimental.util.getOrNull -open class JvmScriptingEnvironment : PropertiesCollection.Builder() { - companion object : JvmScriptingEnvironment() +interface JvmScriptingEnvironmentKeys + +open class JvmScriptingEnvironmentBuilder : JvmScriptingEnvironmentKeys, PropertiesCollection.Builder() { + + companion object : PropertiesCollection.Builder.BuilderExtension, JvmScriptingEnvironmentKeys { + override fun get() = JvmScriptingEnvironmentBuilder() + } } -val JvmScriptingEnvironment.javaHome by PropertiesCollection.key(File(System.getProperty("java.home"))) +val JvmScriptingEnvironmentKeys.javaHome by PropertiesCollection.key(File(System.getProperty("java.home"))) -val ScriptingEnvironment.jvm get() = JvmScriptingEnvironment() +@Suppress("unused") +val ScriptingEnvironmentKeys.jvm + get() = JvmScriptingEnvironmentBuilder -val defaultJvmScriptingEnvironment = ScriptingEnvironment.create { +val defaultJvmScriptingEnvironment = ScriptingEnvironment { getScriptingClass(JvmGetScriptingClass()) } @@ -43,7 +49,7 @@ class JvmGetScriptingClass : GetScriptingClass { if (actualClassLoadersChain.any { it == fromClass.java.classLoader }) return fromClass } - val newDeps = environment.getOrNull(ScriptingEnvironment.configurationDependencies) + val newDeps = environment[ScriptingEnvironment.configurationDependencies] if (dependencies == null) { dependencies = newDeps } else { @@ -62,7 +68,7 @@ class JvmGetScriptingClass : GetScriptingClass { if (classLoader == null) { val classpath = dependencies?.flatMap { dependency -> - when(dependency) { + when (dependency) { is JvmDependency -> dependency.classpath.map { it.toURI().toURL() } else -> throw IllegalArgumentException("unknown dependency type $dependency") } 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 c7d545354d8..aff75740c28 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 @@ -19,7 +19,6 @@ import kotlin.script.experimental.dependencies.DependenciesResolver import kotlin.script.experimental.jvm.impl.BridgeDependenciesResolver import kotlin.script.experimental.location.ScriptExpectedLocation import kotlin.script.experimental.util.getOrError -import kotlin.script.experimental.util.getOrNull // temporary trick with passing Any as a template and overwriting it below, TODO: fix after introducing new script definitions hierarchy abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinition(Any::class) { @@ -37,7 +36,7 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit override val template: KClass<*> get() = baseClass override val name: String - get() = scriptDefinition.getOrNull(ScriptDefinition.name) ?: "Kotlin Script" + get() = scriptDefinition[ScriptDefinition.name] ?: "Kotlin Script" override val fileType: LanguageFileType = KotlinFileType.INSTANCE @@ -57,24 +56,24 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit } override val acceptedAnnotations: List> by lazy(LazyThreadSafetyMode.PUBLICATION) { - scriptDefinition.getOrNull(ScriptDefinition.refineConfigurationOnAnnotations) + scriptDefinition[ScriptDefinition.refineConfigurationOnAnnotations] .orEmpty() .map { getScriptingClass(it) as KClass } } override val implicitReceivers: List by lazy(LazyThreadSafetyMode.PUBLICATION) { - scriptDefinition.getOrNull(ScriptDefinition.scriptImplicitReceivers) + scriptDefinition[ScriptDefinition.scriptImplicitReceivers] .orEmpty() .map { getScriptingClass(it).starProjectedType } } override val environmentVariables: List> by lazy(LazyThreadSafetyMode.PUBLICATION) { - scriptDefinition.getOrNull(ScriptDefinition.contextVariables) + scriptDefinition[ScriptDefinition.contextVariables] ?.map { (k, v) -> k to getScriptingClass(v).starProjectedType }.orEmpty() } override val additionalCompilerArguments: List - get() = scriptDefinition.getOrNull(ScriptDefinition.compilerOptions) + get() = scriptDefinition[ScriptDefinition.compilerOptions] .orEmpty() override val scriptExpectedLocations: List = @@ -84,15 +83,15 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit ) override val targetClassAnnotations: List - get() = scriptDefinition.getOrNull(ScriptDefinition.generatedClassAnnotations) + get() = scriptDefinition[ScriptDefinition.generatedClassAnnotations] .orEmpty() override val targetMethodAnnotations: List - get() = scriptDefinition.getOrNull(ScriptDefinition.generatedMethodAnnotations) + get() = scriptDefinition[ScriptDefinition.generatedMethodAnnotations] .orEmpty() private val scriptingClassGetter by lazy(LazyThreadSafetyMode.PUBLICATION) { - hostEnvironment.getOrNull(ScriptingEnvironment.getScriptingClass) + hostEnvironment[ScriptingEnvironment.getScriptingClass] ?: throw IllegalArgumentException("Expecting 'getScriptingClass' property in the scripting environment") } @@ -110,8 +109,8 @@ class KotlinScriptDefinitionAdapterFromNewAPI( override val hostEnvironment: ScriptingEnvironment ) : KotlinScriptDefinitionAdapterFromNewAPIBase() { - override val name: String get() = scriptDefinition.getOrNull(ScriptDefinition.name) ?: super.name + override val name: String get() = scriptDefinition[ScriptDefinition.name] ?: super.name override val scriptFileExtensionWithDot = - "." + (scriptDefinition.getOrNull(ScriptDefinition.fileExtension) ?: "kts") + "." + (scriptDefinition[ScriptDefinition.fileExtension] ?: "kts") } diff --git a/plugins/scripting/scripting-cli/src/org/jetbrains/kotlin/scripting/compiler/plugin/LazyScriptDefinitionFromDiscoveredClass.kt b/plugins/scripting/scripting-cli/src/org/jetbrains/kotlin/scripting/compiler/plugin/LazyScriptDefinitionFromDiscoveredClass.kt index b9d8894536b..443efa7a4d3 100644 --- a/plugins/scripting/scripting-cli/src/org/jetbrains/kotlin/scripting/compiler/plugin/LazyScriptDefinitionFromDiscoveredClass.kt +++ b/plugins/scripting/scripting-cli/src/org/jetbrains/kotlin/scripting/compiler/plugin/LazyScriptDefinitionFromDiscoveredClass.kt @@ -19,7 +19,6 @@ import kotlin.script.experimental.api.* import kotlin.script.experimental.definitions.createScriptDefinitionFromAnnotatedBaseClass import kotlin.script.experimental.jvm.JvmDependency import kotlin.script.experimental.jvm.defaultJvmScriptingEnvironment -import kotlin.script.experimental.util.getOrNull class LazyScriptDefinitionFromDiscoveredClass internal constructor( private val annotationsFromAsm: ArrayList, @@ -36,7 +35,7 @@ class LazyScriptDefinitionFromDiscoveredClass internal constructor( ) : this(loadAnnotationsFromClass(classBytes), className, classpath, messageCollector) override val hostEnvironment: ScriptingEnvironment by lazy(LazyThreadSafetyMode.PUBLICATION) { - ScriptingEnvironment.create { + ScriptingEnvironment { include(defaultJvmScriptingEnvironment) configurationDependencies(JvmDependency(classpath)) } @@ -70,7 +69,7 @@ class LazyScriptDefinitionFromDiscoveredClass internal constructor( // TODO: check whether it actually works ?: annotationsFromAsm.find { it.name == KotlinScript::class.simpleName }?.args?.get(1) ?: scriptDefinition.let { - it.getOrNull(ScriptDefinition.fileExtension) ?: "kts" + it[ScriptDefinition.fileExtension] ?: "kts" } ".$ext" } @@ -81,4 +80,4 @@ class LazyScriptDefinitionFromDiscoveredClass internal constructor( } } -object InvalidScriptDefinition : ScriptDefinition +val InvalidScriptDefinition = ScriptDefinition()