Refactor configurations handling:

- rearrange compile call parameters for clarity, more defaults
- remove baseConfiguration method - it is now covered by defaultConfiguration
for static part, and refineConfiguration call if a config parameter is
specified
- implement proper configurations chaining, documented in comment to compile function
- minor renamings and refactorings

libraries/examples/scripting/jvm-maven-deps/script/src/org/jetbrains/kotlin/script/examples/jvm/resolve/maven/scriptDef.kt

@@ -39,7 +39,7 @@ val myJvmConfigParams = jvmJavaHomeParams + with(ScriptCompileConfigurationPrope
                 )
             )
         ),
-        updateConfigurationOnAnnotations(DependsOn::class, Repository::class)
+        refineConfigurationOnAnnotations(DependsOn::class, Repository::class)
     )
 }
 
@@ -49,9 +49,6 @@ class MyConfigurator(val environment: ScriptingEnvironment) : ScriptCompilationC
 
     override val defaultConfiguration = ScriptCompileConfiguration(environment, myJvmConfigParams)
 
-    override suspend fun baseConfiguration(scriptSource: ScriptSource): ResultWithDiagnostics<ScriptCompileConfiguration> =
-        defaultConfiguration.asSuccess()
-
     override suspend fun refineConfiguration(
         scriptSource: ScriptSource,
         configuration: ScriptCompileConfiguration,

libraries/scripting/common/src/kotlin/script/experimental/api/scriptCompilation.kt

@@ -9,8 +9,8 @@ interface ScriptCompiler {
 
     suspend fun compile(
         script: ScriptSource,
-        configuration: ScriptCompileConfiguration,
+        configurator: ScriptCompilationConfigurator? = null,
-        configurator: ScriptCompilationConfigurator? = null
+        additionalConfiguration: ScriptCompileConfiguration? = null // overrides parameters from configurator.defaultConfiguration
     ): ResultWithDiagnostics<CompiledScript<*>>
 }
 

libraries/scripting/common/src/kotlin/script/experimental/api/scriptConfiguration.kt

@@ -21,8 +21,6 @@ interface ScriptCompilationConfigurator {
 
     val defaultConfiguration: ScriptCompileConfiguration
 
-    suspend fun baseConfiguration(scriptSource: ScriptSource): ResultWithDiagnostics<ScriptCompileConfiguration>
-
     suspend fun refineConfiguration(
         scriptSource: ScriptSource,
         configuration: ScriptCompileConfiguration,

libraries/scripting/common/src/kotlin/script/experimental/api/scriptConfigurationProperties.kt

@@ -33,8 +33,10 @@ object ScriptCompileConfigurationProperties {
 
     val compilerOptions by typedKey<List<String>>() // Q: CommonCompilerOptions instead?
 
-    val updateConfigurationOnAnnotations by typedKey<List<KClass<out Annotation>>>()
+    val refineBeforeParsing by typedKey<Boolean>() // default: false
 
-    val updateConfigurationOnSections by typedKey<List<String>>()
+    val refineConfigurationOnAnnotations by typedKey<List<KClass<out Annotation>>>()
+
+    val refineConfigurationOnSections by typedKey<List<String>>()
 }
 

libraries/scripting/common/src/kotlin/script/experimental/basic/basicScript.kt

@@ -12,9 +12,6 @@ class PassThroughCompilationConfigurator(val environment: ScriptingEnvironment)
 
     override val defaultConfiguration = ScriptCompileConfiguration(environment)
 
-    override suspend fun baseConfiguration(scriptSource: ScriptSource): ResultWithDiagnostics<ScriptCompileConfiguration> =
-        defaultConfiguration.asSuccess()
-
     override suspend fun refineConfiguration(
         script: ScriptSource,
         configuration: ScriptCompileConfiguration,

libraries/scripting/common/src/kotlin/script/experimental/host/BasicScriptingHost.kt

@@ -35,7 +35,7 @@ abstract class BasicScriptingHost<ScriptBase : Any>(
         environment: ScriptEvaluationEnvironment
     ): ResultWithDiagnostics<EvaluationResult> =
         runInCoroutineContext {
-            val compiled = compiler.compile(script, compileConfiguration, configurator)
+            val compiled = compiler.compile(script, configurator, compileConfiguration)
             when (compiled) {
                 is ResultWithDiagnostics.Failure -> compiled
                 is ResultWithDiagnostics.Success -> {

libraries/scripting/common/src/kotlin/script/experimental/util/propertyBag.kt

@@ -17,12 +17,19 @@ class TypedKeyDelegate<T> {
 
 fun <T> typedKey() = TypedKeyDelegate<T>()
 
-class ChainedPropertyBag(private val parent: ChainedPropertyBag? = null, pairs: Iterable<Pair<TypedKey<*>, Any?>>) {
+class ChainedPropertyBag private constructor(private val parent: ChainedPropertyBag?, private val data: Map<TypedKey<*>, Any?>) {
+    constructor(parent: ChainedPropertyBag? = null, pairs: Iterable<Pair<TypedKey<*>, Any?>>) :
+            this(parent, HashMap<TypedKey<*>, Any?>().also { it.putAll(pairs) })
+
     constructor(pairs: Iterable<Pair<TypedKey<*>, Any?>>) : this(null, pairs)
     constructor(parent: ChainedPropertyBag, vararg pairs: Pair<TypedKey<*>, Any?>) : this(parent, pairs.asIterable())
     constructor(vararg pairs: Pair<TypedKey<*>, Any?>) : this(null, pairs.asIterable())
 
-    private val data = HashMap<TypedKey<*>, Any?>().also { it.putAll(pairs) }
+    fun cloneWithNewParent(newParent: ChainedPropertyBag?): ChainedPropertyBag = when {
+        newParent == null -> this
+        parent == null -> ChainedPropertyBag(newParent, data)
+        else -> ChainedPropertyBag(parent.cloneWithNewParent(newParent), data)
+    }
 
     inline operator fun <reified T> get(key: TypedKey<T>): T = getUnchecked(key) as T
 

libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJVMCompilerImpl.kt

@@ -73,8 +73,8 @@ class KJVMCompilerImpl : KJVMCompilerProxy {
 
     override fun compile(
         script: ScriptSource,
-        scriptCompilerConfiguration: ScriptCompileConfiguration,
+        configurator: ScriptCompilationConfigurator?,
-        configurator: ScriptCompilationConfigurator?
+        additionalConfiguration: ScriptCompileConfiguration
     ): ResultWithDiagnostics<CompiledScript<*>> {
         val messageCollector = ScriptDiagnosticsMessageCollector()
 
@@ -83,7 +83,7 @@ class KJVMCompilerImpl : KJVMCompilerProxy {
 
         try {
             var environment: KotlinCoreEnvironment? = null
-            var updatedScriptCompileConfiguration = scriptCompilerConfiguration
+            var updatedScriptCompileConfiguration = additionalConfiguration
 
             fun updateClasspath(classpath: List<File>) {
                 environment!!.updateClasspath(classpath.map(::JvmClasspathRoot))
@@ -100,19 +100,19 @@ class KJVMCompilerImpl : KJVMCompilerProxy {
             val kotlinCompilerConfiguration = org.jetbrains.kotlin.config.CompilerConfiguration().apply {
                 add(
                     JVMConfigurationKeys.SCRIPT_DEFINITIONS,
-                    BridgeScriptDefinition(scriptCompilerConfiguration, configurator, ::updateClasspath)
+                    BridgeScriptDefinition(additionalConfiguration, configurator, ::updateClasspath)
                 )
                 put<MessageCollector>(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
                 put(JVMConfigurationKeys.RETAIN_OUTPUT_IN_MEMORY, true)
 
                 var isModularJava = false
-                scriptCompilerConfiguration.getOrNull(JvmScriptCompileConfigurationProperties.javaHomeDir)?.let {
+                additionalConfiguration.getOrNull(JvmScriptCompileConfigurationProperties.javaHomeDir)?.let {
                     put(JVMConfigurationKeys.JDK_HOME, it)
                     isModularJava = CoreJrtFileSystem.isModularJdk(it)
                 }
 
                 var explicitStdlib = false
-                scriptCompilerConfiguration.getOrNull(ScriptCompileConfigurationProperties.dependencies)?.let {
+                additionalConfiguration.getOrNull(ScriptCompileConfigurationProperties.dependencies)?.let {
                     addJvmClasspathRoots(
                         it.flatMap {
                             (it as JvmDependency).classpath.also {
@@ -152,7 +152,7 @@ class KJVMCompilerImpl : KJVMCompilerProxy {
             val analyzerWithCompilerReport = AnalyzerWithCompilerReport(messageCollector, environment.configuration.languageVersionSettings)
 
             val psiFileFactory: PsiFileFactoryImpl = PsiFileFactory.getInstance(environment.project) as PsiFileFactoryImpl
-            val scriptText = getMergedScriptText(script, scriptCompilerConfiguration)
+            val scriptText = getMergedScriptText(script, additionalConfiguration)
             val scriptFileName = "script" // TODO: extract from file/url if available
             val virtualFile = LightVirtualFile(
                 "$scriptFileName${KotlinParserDefinition.STD_SCRIPT_EXT}",
@@ -247,7 +247,8 @@ internal class BridgeScriptDefinition(
     updateClasspath: (List<File>) -> Unit
 ) : KotlinScriptDefinition(scriptCompilerConfiguration[ScriptingEnvironmentProperties.baseClass] as KClass<out Any>) {
     override val acceptedAnnotations =
-        scriptCompilerConfiguration.getOrNull(ScriptCompileConfigurationProperties.updateConfigurationOnAnnotations)?.toList() ?: emptyList()
+        scriptCompilerConfiguration.getOrNull(ScriptCompileConfigurationProperties.refineConfigurationOnAnnotations)?.toList()
+                ?: emptyList()
 
     override val dependencyResolver: DependenciesResolver =
         BridgeDependenciesResolver(scriptConfigurator, scriptCompilerConfiguration, updateClasspath)

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

@@ -16,20 +16,31 @@ open class JvmScriptCompiler(
 
     override suspend fun compile(
         script: ScriptSource,
-        configuration: ScriptCompileConfiguration,
+        configurator: ScriptCompilationConfigurator?,
-        configurator: ScriptCompilationConfigurator?
+        additionalConfiguration: ScriptCompileConfiguration?
     ): ResultWithDiagnostics<CompiledScript<*>> {
-        val refinedConfiguration = configurator?.refineConfiguration(script, configuration)?.let {
+        val baseConfiguration = additionalConfiguration?.cloneWithNewParent(configurator?.defaultConfiguration)
-            when (it) {
+                ?: configurator?.defaultConfiguration
-                is ResultWithDiagnostics.Failure -> return it
+                ?: ScriptCompileConfiguration()
-                is ResultWithDiagnostics.Success -> it.value
+        val refinedConfiguration =
+            if (baseConfiguration.getOrNull(ScriptCompileConfigurationProperties.refineBeforeParsing) == true) {
+                if (configurator == null) {
+                    return ResultWithDiagnostics.Failure("Non-null configurator expected".asErrorDiagnostics())
+                }
+                configurator.refineConfiguration(script, baseConfiguration).let {
+                    when (it) {
+                        is ResultWithDiagnostics.Failure -> return it
+                        is ResultWithDiagnostics.Success -> it.value
+                    }
+                }
+            } else {
+                baseConfiguration
             }
-        } ?: configuration
         val cached = cache.get(script, refinedConfiguration)
 
         if (cached != null) return cached.asSuccess()
 
-        return compilerProxy.compile(script, refinedConfiguration, configurator).also {
+        return compilerProxy.compile(script, configurator, refinedConfiguration).also {
             if (it is ResultWithDiagnostics.Success) {
                 cache.store(it.value, refinedConfiguration)
             }
@@ -45,8 +56,8 @@ interface CompiledJvmScriptsCache {
 interface KJVMCompilerProxy {
     fun compile(
         script: ScriptSource,
-        scriptCompilerConfiguration: ScriptCompileConfiguration,
+        configurator: ScriptCompilationConfigurator?,
-        configurator: ScriptCompilationConfigurator?
+        additionalConfiguration: ScriptCompileConfiguration
     ): ResultWithDiagnostics<CompiledScript<*>>
 }
 

plugins/scripting/scripting-cli/src/org/jetbrains/kotlin/scripting/compiler/plugin/KotlinScriptDefinitionAdapterFromNewAPI.kt

@@ -47,7 +47,7 @@ class KotlinScriptDefinitionAdapterFromNewAPI(val scriptDefinition: ScriptDefini
     }
 
     override val acceptedAnnotations: List<KClass<out Annotation>> by lazy {
-        scriptDefinition.compilationConfigurator.defaultConfiguration.getOrNull(ScriptCompileConfigurationProperties.updateConfigurationOnAnnotations)?.toList()
+        scriptDefinition.compilationConfigurator.defaultConfiguration.getOrNull(ScriptCompileConfigurationProperties.refineConfigurationOnAnnotations)?.toList()
                 ?: emptyList()
     }