Refactor scripting properties:

- flatten the structure
- add some parameters
- replace iterables with lists
- renaming all scope objects uniformily
also:
- fix passing and usage of script sources
- renamings and other minor improvements

libraries/scripting/jvm/src/kotlin/script/experimental/jvm/impl/BridgeDependenciesResolver.kt

@@ -36,15 +36,14 @@ class BridgeDependenciesResolver(
 
             val diagnostics = arrayListOf<ScriptReport>()
             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<ScriptDiagnostic>.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")
+}
 

libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptCompilation.kt

@@ -19,11 +19,10 @@ open class JvmScriptCompiler(
         configuration: ScriptCompileConfiguration,
         configurator: ScriptCompilationConfigurator?
     ): ResultWithDiagnostics<CompiledScript<*>> {
-        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) {}
 }
 

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")))
 }
 

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<File>()
 }
 
-class JvmDependency(val classpath: Iterable<File>) : ScriptDependency
+class JvmDependency(val classpath: List<File>) : ScriptDependency {
+    constructor(vararg classpathEntries: File) : this(classpathEntries.asList())
+}
 

libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptEvaluation.kt

@@ -18,6 +18,6 @@ open class JvmBasicScriptingHost<ScriptBase : Any>(
     evaluator: ScriptEvaluator<ScriptBase>
 ) : BasicScriptingHost<ScriptBase>(configurationExtractor, compiler, evaluator)
 
-object JvmScriptEvaluationEnvironmentParams {
+object JvmScriptEvaluationEnvironmentProperties {
     val baseClassLoader by typedKey<ClassLoader?>()
 }