Refactoring properties collection after review

Author: ligee

idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptDefinitionsManager.kt

@@ -208,7 +208,7 @@ fun loadDefinitionsFromTemplates(
                     )
                 }
                 template.annotations.firstIsInstanceOrNull<kotlin.script.experimental.annotations.KotlinScript>() != null -> {
-                    val hostEnvironment = ScriptingEnvironment.create {
+                    val hostEnvironment = ScriptingEnvironment {
                         include(defaultJvmScriptingEnvironment)
                         configurationDependencies(JvmDependency(classpath))
                     }

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<DependsOn>()
         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<ScriptCompileConfiguration?> {
-        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<Annotation> = 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) {

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<EvaluationResult> {
-    val additionalCompilationProperties = ScriptCompileConfiguration.create {
+    val additionalCompilationProperties = ScriptCompileConfiguration {
         jvm {
             dependenciesFromCurrentContext(
                 "scripting-jvm-simple-script" /* script library jar name */

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 {
-    
-    companion object : ScriptCompileConfiguration {
+interface ScriptCompileConfigurationKeys
+
+class ScriptCompileConfiguration(baseConfigurations: Iterable<ScriptCompileConfiguration>, body: Builder.() -> Unit) :
+    PropertiesCollection(Builder(baseConfigurations).apply(body).data) {
 
-        class Builder internal constructor() : PropertiesCollection.Builder(), ScriptCompileConfiguration {
-            override val properties = data
-        }
+    constructor(body: Builder.() -> Unit = {}) : this(emptyList(), body)
+    constructor(
+        vararg baseConfigurations: ScriptCompileConfiguration, body: Builder.() -> Unit = {}
+    ) : this(baseConfigurations.asIterable(), body)
 
-        fun create(body: Builder.() -> Unit): ScriptCompileConfiguration = Builder().apply(body)
-    }
+    class Builder internal constructor(baseConfigurations: Iterable<ScriptCompileConfiguration>) :
+        ScriptCompileConfigurationKeys,
+        PropertiesCollection.Builder(baseConfigurations)
+    
+    companion object : ScriptCompileConfigurationKeys
 }
 
-val ScriptCompileConfiguration.sourceFragments by PropertiesCollection.key<List<ScriptSourceNamedFragment>>()
+val ScriptCompileConfigurationKeys.sourceFragments by PropertiesCollection.key<List<ScriptSourceNamedFragment>>()
+
+val ScriptCompileConfigurationKeys.scriptBodyTarget by PropertiesCollection.keyCopy(ScriptDefinition.scriptBodyTarget)
 
-val ScriptCompileConfiguration.scriptBodyTarget by PropertiesCollection.keyCopy(ScriptDefinition.scriptBodyTarget)
+val ScriptCompileConfigurationKeys.scriptImplicitReceivers by PropertiesCollection.keyCopy(ScriptDefinition.scriptImplicitReceivers)
 
-val ScriptCompileConfiguration.scriptImplicitReceivers by PropertiesCollection.keyCopy(ScriptDefinition.scriptImplicitReceivers)
+val ScriptCompileConfigurationKeys.contextVariables by PropertiesCollection.keyCopy(ScriptDefinition.contextVariables)
 
-val ScriptCompileConfiguration.contextVariables by PropertiesCollection.keyCopy(ScriptDefinition.contextVariables)
+val ScriptCompileConfigurationKeys.defaultImports by PropertiesCollection.keyCopy(ScriptDefinition.defaultImports)
 
-val ScriptCompileConfiguration.defaultImports by PropertiesCollection.keyCopy(ScriptDefinition.defaultImports)
+val ScriptCompileConfigurationKeys.restrictions by PropertiesCollection.keyCopy(ScriptDefinition.restrictions)
 
-val ScriptCompileConfiguration.restrictions by PropertiesCollection.keyCopy(ScriptDefinition.restrictions)
+val ScriptCompileConfigurationKeys.importedScripts by PropertiesCollection.keyCopy(ScriptDefinition.importedScripts)
 
-val ScriptCompileConfiguration.importedScripts by PropertiesCollection.keyCopy(ScriptDefinition.importedScripts)
+val ScriptCompileConfigurationKeys.dependencies by PropertiesCollection.keyCopy(ScriptDefinition.dependencies)
 
-val ScriptCompileConfiguration.dependencies by PropertiesCollection.keyCopy(ScriptDefinition.dependencies)
+val ScriptCompileConfigurationKeys.compilerOptions by PropertiesCollection.keyCopy(ScriptDefinition.compilerOptions)
 
-val ScriptCompileConfiguration.compilerOptions by PropertiesCollection.keyCopy(ScriptDefinition.compilerOptions)
 
+interface ProcessedScriptDataKeys
 
-interface ProcessedScriptData : PropertiesCollection {
+class ProcessedScriptData(properties: Map<PropertiesCollection.Key<*>, Any>) : PropertiesCollection(properties) {
 
-    companion object : ProcessedScriptData
+    companion object : ProcessedScriptDataKeys
 }
 
-val ProcessedScriptData.foundAnnotations by PropertiesCollection.key<List<Annotation>>()
+val ProcessedScriptDataKeys.foundAnnotations by PropertiesCollection.key<List<Annotation>>()
 
-val ProcessedScriptData.foundFragments by PropertiesCollection.key<List<ScriptSourceNamedFragment>>()
+val ProcessedScriptDataKeys.foundFragments by PropertiesCollection.key<List<ScriptSourceNamedFragment>>()
 
 
 interface RefineScriptCompilationConfigurationHandler {

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<ScriptDefinition>, 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<ScriptDefinition>) :
+        ScriptDefinitionKeys,
+        PropertiesCollection.Builder(baseDefinitions)
+
+    // inherited from script definition for using as a keys anchor
+    companion object : ScriptDefinitionKeys {
 
-    object Default : ScriptDefinition
+        val Default = ScriptDefinition()
+    }
 }
 
-val ScriptDefinition.name by PropertiesCollection.key<String>("Kotlin script") // Name of the script type
+val ScriptDefinitionKeys.name by PropertiesCollection.key<String>("Kotlin script") // Name of the script type
 
-val ScriptDefinition.fileExtension by PropertiesCollection.key<String>("kts") // file extension
+val ScriptDefinitionKeys.fileExtension by PropertiesCollection.key<String>("kts") // file extension
 
-val ScriptDefinition.baseClass by PropertiesCollection.key<KotlinType>() // script base class
+val ScriptDefinitionKeys.baseClass by PropertiesCollection.key<KotlinType>() // script base class
 
-val ScriptDefinition.scriptBodyTarget by PropertiesCollection.key<ScriptBodyTarget>(ScriptBodyTarget.Constructor)
+val ScriptDefinitionKeys.scriptBodyTarget by PropertiesCollection.key<ScriptBodyTarget>(ScriptBodyTarget.Constructor)
 
-val ScriptDefinition.scriptImplicitReceivers by PropertiesCollection.key<List<KotlinType>>() // in the order from outer to inner scope
+val ScriptDefinitionKeys.scriptImplicitReceivers by PropertiesCollection.key<List<KotlinType>>() // in the order from outer to inner scope
 
-val ScriptDefinition.contextVariables by PropertiesCollection.key<Map<String, KotlinType>>() // external variables
+val ScriptDefinitionKeys.contextVariables by PropertiesCollection.key<Map<String, KotlinType>>() // external variables
 
-val ScriptDefinition.defaultImports by PropertiesCollection.key<List<String>>()
+val ScriptDefinitionKeys.defaultImports by PropertiesCollection.key<List<String>>()
 
-val ScriptDefinition.restrictions by PropertiesCollection.key<List<ResolvingRestrictionRule>>()
+val ScriptDefinitionKeys.restrictions by PropertiesCollection.key<List<ResolvingRestrictionRule>>()
 
-val ScriptDefinition.importedScripts by PropertiesCollection.key<List<ScriptSource>>()
+val ScriptDefinitionKeys.importedScripts by PropertiesCollection.key<List<ScriptSource>>()
 
-val ScriptDefinition.dependencies by PropertiesCollection.key<List<ScriptDependency>>()
+val ScriptDefinitionKeys.dependencies by PropertiesCollection.key<List<ScriptDependency>>()
 
-val ScriptDefinition.generatedClassAnnotations by PropertiesCollection.key<List<Annotation>>()
+val ScriptDefinitionKeys.generatedClassAnnotations by PropertiesCollection.key<List<Annotation>>()
 
-val ScriptDefinition.generatedMethodAnnotations by PropertiesCollection.key<List<Annotation>>()
+val ScriptDefinitionKeys.generatedMethodAnnotations by PropertiesCollection.key<List<Annotation>>()
 
-val ScriptDefinition.compilerOptions by PropertiesCollection.key<List<String>>() // Q: CommonCompilerOptions instead?
+val ScriptDefinitionKeys.compilerOptions by PropertiesCollection.key<List<String>>() // Q: CommonCompilerOptions instead?
 
-val ScriptDefinition.refineConfigurationHandler by PropertiesCollection.key<RefineScriptCompilationConfigurationHandler>() // dynamic configurator
+val ScriptDefinitionKeys.refineConfigurationHandler by PropertiesCollection.key<RefineScriptCompilationConfigurationHandler>() // dynamic configurator
 
-val ScriptDefinition.refineConfigurationBeforeParsing by PropertiesCollection.key<Boolean>() // default: false
+val ScriptDefinitionKeys.refineConfigurationBeforeParsing by PropertiesCollection.key<Boolean>() // default: false
 
-val ScriptDefinition.refineConfigurationOnAnnotations by PropertiesCollection.key<List<KotlinType>>()
+val ScriptDefinitionKeys.refineConfigurationOnAnnotations by PropertiesCollection.key<List<KotlinType>>()
 
-val ScriptDefinition.refineConfigurationOnSections by PropertiesCollection.key<List<String>>()
+val ScriptDefinitionKeys.refineConfigurationOnSections by PropertiesCollection.key<List<String>>()
 
 // DSL:
 
-val ScriptDefinition.refineConfiguration get() = RefineConfigurationBuilder()
+val ScriptDefinition.Builder.refineConfiguration get() = RefineConfigurationBuilder()
 
 
 class RefineConfigurationBuilder : PropertiesCollection.Builder() {

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<ScriptEvaluationEnvironment>, 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<ScriptEvaluationEnvironment>) :
+        ScriptDefinitionKeys,
+        PropertiesCollection.Builder(baseEvaluationEnvironments)
+
+    companion object : ScriptEvaluationEnvironmentKeys
 }
 
-val ScriptEvaluationEnvironment.implicitReceivers by PropertiesCollection.key<List<Any>>()
+val ScriptEvaluationEnvironmentKeys.implicitReceivers by PropertiesCollection.key<List<Any>>()
 
-val ScriptEvaluationEnvironment.contextVariables by PropertiesCollection.key<Map<String, Any?>>() // external variables
+val ScriptEvaluationEnvironmentKeys.contextVariables by PropertiesCollection.key<Map<String, Any?>>() // external variables
 
-val ScriptEvaluationEnvironment.constructorArgs by PropertiesCollection.key<List<Any?>>()
+val ScriptEvaluationEnvironmentKeys.constructorArgs by PropertiesCollection.key<List<Any?>>()
 
-val ScriptEvaluationEnvironment.runArgs by PropertiesCollection.key<List<Any?>>()
+val ScriptEvaluationEnvironmentKeys.runArgs by PropertiesCollection.key<List<Any?>>()
 
 sealed class ResultValue {
     class Value(val name: String, val value: Any?, val type: String) : ResultValue() {

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<ScriptingEnvironment>, 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<ScriptingEnvironment>) : 
+        ScriptingEnvironmentKeys, 
+        PropertiesCollection.Builder(baseScriptingEnvironments)
+    
+    companion object : ScriptingEnvironmentKeys
 }
 
 // should contain all dependencies needed for baseClass and compilationConfigurator
-val ScriptingEnvironment.configurationDependencies by PropertiesCollection.key<List<ScriptDependency>>()
+val ScriptingEnvironmentKeys.configurationDependencies by PropertiesCollection.key<List<ScriptDependency>>()
 
 // 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<Boolean>(false)
+val ScriptingEnvironmentKeys.isolatedDependencies by PropertiesCollection.key<Boolean>(false)
 
 // a "class loader" for KotlinTypes
-val ScriptingEnvironment.getScriptingClass by PropertiesCollection.key<GetScriptingClass>()
+val ScriptingEnvironmentKeys.getScriptingClass by PropertiesCollection.key<GetScriptingClass>()
+
 
 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)
 }

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<KotlinScriptFileExtension>()?.extension ?: mainAnnotation.extension)
-            name(mainAnnotation.name)
+    return ScriptDefinition {
+        baseClass(baseClassType)
+        fileExtension(baseClass.findAnnotation<KotlinScriptFileExtension>()?.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))
         }
     }
 }