Refactoring properties collection after review

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<ScriptReport>()
-            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 =

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<JvmScriptCompilationConfigurationBuilder>,
+        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()

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<File>) : ScriptDependency {

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<JvmScriptingEnvironmentBuilder>, JvmScriptingEnvironmentKeys {
+        override fun get() = JvmScriptingEnvironmentBuilder()
+    }
 }
 
-val JvmScriptingEnvironment.javaHome by PropertiesCollection.key<File>(File(System.getProperty("java.home")))
+val JvmScriptingEnvironmentKeys.javaHome by PropertiesCollection.key<File>(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")
                 }