Replace dedicated configurator with definition properties + refine fun

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

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.script.examples.jvm.resolve.maven.host
 
 import org.jetbrains.kotlin.script.examples.jvm.resolve.maven.MyScriptWithMavenDeps
-import org.jetbrains.kotlin.script.examples.jvm.resolve.maven.myJvmConfigParams
 import java.io.File
 import kotlin.script.experimental.api.*
 import kotlin.script.experimental.definitions.ScriptDefinitionFromAnnotatedBaseClass
@@ -16,7 +15,7 @@ import kotlin.script.experimental.jvm.JvmBasicScriptingHost
 import kotlin.script.experimental.jvm.JvmGetScriptingClass
 import kotlin.script.experimental.jvm.JvmScriptCompiler
 import kotlin.script.experimental.jvmhost.impl.KJVMCompilerImpl
-import kotlin.script.experimental.misc.*
+import kotlin.script.experimental.misc.invoke
 
 fun evalFile(scriptFile: File): ResultWithDiagnostics<EvaluationResult> {
     val scriptCompiler = JvmScriptCompiler(KJVMCompilerImpl(), DummyCompiledJvmScriptCache())
@@ -30,7 +29,7 @@ fun evalFile(scriptFile: File): ResultWithDiagnostics<EvaluationResult> {
     val host = JvmBasicScriptingHost(scriptCompiler, scriptDefinition.evaluator)
 
     return host.eval(
-        scriptFile.toScriptSource(), scriptDefinition, ScriptCompileConfiguration(myJvmConfigParams), ScriptEvaluationEnvironment()
+        scriptFile.toScriptSource(), scriptDefinition, ScriptCompileConfiguration(), ScriptEvaluationEnvironment()
     )
 }
 

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

@@ -13,51 +13,53 @@ import java.io.File
 import kotlin.script.dependencies.ScriptContents
 import kotlin.script.dependencies.ScriptDependenciesResolver
 import kotlin.script.experimental.annotations.KotlinScript
-import kotlin.script.experimental.annotations.KotlinScriptCompilationConfigurator
+import kotlin.script.experimental.annotations.KotlinScriptDefaultCompilationConfiguration
 import kotlin.script.experimental.annotations.KotlinScriptEvaluator
 import kotlin.script.experimental.annotations.KotlinScriptFileExtension
 import kotlin.script.experimental.api.*
 import kotlin.script.experimental.jvm.*
 import kotlin.script.experimental.jvm.runners.BasicJvmScriptEvaluator
 import kotlin.script.experimental.misc.*
+import kotlin.script.experimental.util.TypedKey
 
 @KotlinScript
 @KotlinScriptFileExtension("scriptwithdeps.kts")
-@KotlinScriptCompilationConfigurator(MyConfigurator::class)
+@KotlinScriptDefaultCompilationConfiguration(MyConfiguration::class)
 @KotlinScriptEvaluator(BasicJvmScriptEvaluator::class)
 abstract class MyScriptWithMavenDeps {
 //    abstract fun body(vararg args: String): Int
 }
 
-val myJvmConfigParams = jvmJavaHomeParams + with(ScriptCompileConfigurationProperties) {
+object MyConfiguration : ArrayList<Pair<TypedKey<*>, Any?>>(
-    listOf(
+    jvmJavaHomeParams + with(ScriptCompileConfigurationProperties) {
-        baseClass<MyScriptWithMavenDeps>(),
+        listOf(
-        defaultImports(DependsOn::class.qualifiedName!!, Repository::class.qualifiedName!!),
+            baseClass<MyScriptWithMavenDeps>(),
-        dependencies(
+            defaultImports(DependsOn::class.qualifiedName!!, Repository::class.qualifiedName!!),
-            JvmDependency(
+            dependencies(
-                scriptCompilationClasspathFromContext(
+                JvmDependency(
-                    "scripting-jvm-maven-deps", // script library jar name
+                    scriptCompilationClasspathFromContext(
-                    "kotlin-script-util" // DependsOn annotation is taken from script-util
+                        "scripting-jvm-maven-deps", // script library jar name
+                        "kotlin-script-util" // DependsOn annotation is taken from script-util
+                    )
                 )
-            )
+            ),
-        ),
+            refineConfiguration(MyConfigurator()),
-        refineConfigurationOnAnnotations(DependsOn::class, Repository::class)
+            refineConfigurationOnAnnotations(DependsOn::class, Repository::class)
-    )
+        )
-}
+    }
+)
 
-class MyConfigurator(val environment: ScriptingEnvironment) : ScriptCompilationConfigurator {
+class MyConfigurator : RefineScriptCompilationConfiguration {
 
     private val resolver = FilesAndMavenResolver()
 
-    override val defaultConfiguration = ScriptCompileConfiguration(environment, myJvmConfigParams)
+    override suspend operator fun invoke(
-
-    override suspend fun refineConfiguration(
         scriptSource: ScriptSource,
         configuration: ScriptCompileConfiguration,
         processedScriptData: ProcessedScriptData
     ): ResultWithDiagnostics<ScriptCompileConfiguration> {
         val annotations = processedScriptData.getOrNull(ProcessedScriptDataProperties.foundAnnotations)?.takeIf { it.isNotEmpty() }
-                ?: return configuration.asSuccess()
+            ?: return configuration.asSuccess()
         val scriptContents = object : ScriptContents {
             override val annotations: Iterable<Annotation> = annotations
             override val file: File? = null
@@ -69,9 +71,9 @@ class MyConfigurator(val environment: ScriptingEnvironment) : ScriptCompilationC
         }
         return try {
             val newDepsFromResolver = resolver.resolve(scriptContents, emptyMap(), ::report, null).get()
-                    ?: return configuration.asSuccess(diagnostics)
+                ?: return configuration.asSuccess(diagnostics)
             val resolvedClasspath = newDepsFromResolver.classpath.toList().takeIf { it.isNotEmpty() }
-                    ?: return configuration.asSuccess(diagnostics)
+                ?: return configuration.asSuccess(diagnostics)
             val newDependency = JvmDependency(resolvedClasspath)
             val updatedDeps =
                 configuration.getOrNull(ScriptCompileConfigurationProperties.dependencies)?.plus(newDependency) ?: listOf(newDependency)

libraries/scripting/common/src/kotlin/script/experimental/annotations/scriptAnnotations.kt

@@ -13,7 +13,6 @@
 package kotlin.script.experimental.annotations
 
 import kotlin.reflect.KClass
-import kotlin.script.experimental.api.ScriptCompilationConfigurator
 import kotlin.script.experimental.api.ScriptDefinition
 import kotlin.script.experimental.api.ScriptEvaluator
 import kotlin.script.experimental.definitions.ScriptDefinitionFromAnnotatedBaseClass
@@ -36,12 +35,6 @@ annotation class KotlinScriptFileExtension(
     val extension: String
 )
 
-@Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-annotation class KotlinScriptCompilationConfigurator(
-    val compilationConfigurator: KClass<out ScriptCompilationConfigurator>
-)
-
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
 annotation class KotlinScriptEvaluator(

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

@@ -14,18 +14,10 @@ typealias ScriptCompileConfiguration = ChainedPropertyBag
 
 typealias ProcessedScriptData = ChainedPropertyBag
 
-
+interface RefineScriptCompilationConfiguration {
-interface ScriptCompilationConfigurator {
+    suspend operator fun invoke(
-
-    // constructor(properties: ScriptDefinitionPropertiesBag) // the constructor is expected from implementations
-
-    val defaultConfiguration: ScriptCompileConfiguration
-
-    suspend fun refineConfiguration(
         scriptSource: ScriptSource,
         configuration: ScriptCompileConfiguration,
         processedScriptData: ProcessedScriptData = ProcessedScriptData()
-    ): ResultWithDiagnostics<ScriptCompileConfiguration> =
+    ): ResultWithDiagnostics<ScriptCompileConfiguration>
-        configuration.cloneWithNewParent(defaultConfiguration).asSuccess()
 }
-

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

@@ -35,6 +35,8 @@ object ScriptCompileConfigurationProperties {
 
     val compilerOptions by typedKey<List<String>>() // Q: CommonCompilerOptions instead?
 
+    val refineConfiguration by typedKey<RefineScriptCompilationConfiguration>() // dynamic configurator
+
     val refineBeforeParsing by typedKey<Boolean>() // default: false
 
     val refineConfigurationOnAnnotations by typedKey<List<KotlinType>>()

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

@@ -19,8 +19,6 @@ interface ScriptDefinition {
 
     val properties: ScriptDefinitionPropertiesBag
 
-    val compilationConfigurator: ScriptCompilationConfigurator?
-
     val evaluator: ScriptEvaluator<*>?
 }
 

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

@@ -31,7 +31,7 @@ interface GetScriptingClass {
 
 fun ScriptingEnvironment.getScriptingClass(type: KotlinType, contextClass: KClass<*>): KClass<*> {
     val getClass = getOrNull(ScriptingEnvironmentProperties.getScriptingClass)
-            ?: throw IllegalArgumentException("Expecting 'getScriptingClass' property in the scripting environment: unable to load scripting class $type")
+        ?: 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/basic/basicScript.kt

@@ -5,33 +5,7 @@
 
 package kotlin.script.experimental.basic
 
-import kotlin.reflect.full.createInstance
-import kotlin.script.experimental.annotations.KotlinScriptDefaultCompilationConfiguration
 import kotlin.script.experimental.api.*
-import kotlin.script.experimental.util.TypedKey
-
-private const val ILLEGAL_CONFIG_ANN_ARG =
-    "Illegal argument to KotlinScriptDefaultCompilationConfiguration annotation: expecting List-derived object or default-constructed class of configuration parameters"
-
-open class AnnotationsBasedCompilationConfigurator(val properties: ScriptDefinitionPropertiesBag) : ScriptCompilationConfigurator {
-
-    override val defaultConfiguration by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        val baseClass = properties.getScriptBaseClass(this)
-        val cfg = baseClass.annotations.filterIsInstance(KotlinScriptDefaultCompilationConfiguration::class.java).flatMap { ann ->
-            val params = try {
-                ann.compilationConfiguration.objectInstance ?: ann.compilationConfiguration.createInstance()
-            } catch (e: Throwable) {
-                throw IllegalArgumentException(ILLEGAL_CONFIG_ANN_ARG, e)
-            }
-            params.forEach { param ->
-                if (param !is Pair<*, *> || param.first !is TypedKey<*>)
-                    throw IllegalArgumentException("$ILLEGAL_CONFIG_ANN_ARG: invalid parameter $param")
-            }
-            params as List<Pair<TypedKey<*>, Any?>>
-        }
-        ScriptCompileConfiguration(properties, cfg)
-    }
-}
 
 class DummyEvaluator<ScriptBase : Any>(val environment: ScriptingEnvironment) : ScriptEvaluator<ScriptBase> {
     override suspend fun eval(

libraries/scripting/common/src/kotlin/script/experimental/definitions/definitionFromAnnotation.kt

@@ -6,17 +6,20 @@
 package kotlin.script.experimental.definitions
 
 import kotlin.reflect.KClass
+import kotlin.reflect.full.createInstance
 import kotlin.reflect.full.findAnnotation
 import kotlin.reflect.full.primaryConstructor
 import kotlin.script.experimental.annotations.*
 import kotlin.script.experimental.api.*
-import kotlin.script.experimental.basic.AnnotationsBasedCompilationConfigurator
 import kotlin.script.experimental.basic.DummyEvaluator
 import kotlin.script.experimental.util.TypedKey
 import kotlin.script.experimental.util.chainPropertyBags
 
 private const val ERROR_MSG_PREFIX = "Unable to construct script definition: "
 
+private const val ILLEGAL_CONFIG_ANN_ARG =
+    "Illegal argument to KotlinScriptDefaultCompilationConfiguration annotation: expecting List-derived object or default-constructed class of configuration parameters"
+
 open class ScriptDefinitionFromAnnotatedBaseClass(
     protected val baseClassType: KotlinType,
     val environment: ScriptingEnvironment
@@ -40,21 +43,28 @@ open class ScriptDefinitionFromAnnotatedBaseClass(
 
     override val properties = run {
         val baseProperties = chainPropertyBags(explicitDefinition?.properties, environment)
-        val propertiesData = arrayListOf<Pair<TypedKey<*>, Any>>(ScriptDefinitionProperties.baseClass to baseClassType)
+        val propertiesData = arrayListOf<Pair<TypedKey<*>, Any?>>(ScriptDefinitionProperties.baseClass to baseClassType)
         baseClass.findAnnotation<KotlinScriptFileExtension>()?.let {
             propertiesData += ScriptDefinitionProperties.fileExtension to it.extension
         }
         if (baseProperties.getOrNull(ScriptDefinitionProperties.name) == null) {
             propertiesData += ScriptDefinitionProperties.name to mainAnnotation.name
         }
+        baseClass.annotations.filterIsInstance(KotlinScriptDefaultCompilationConfiguration::class.java).forEach { ann ->
+            val params = try {
+                ann.compilationConfiguration.objectInstance ?: ann.compilationConfiguration.createInstance()
+            } catch (e: Throwable) {
+                throw IllegalArgumentException(ILLEGAL_CONFIG_ANN_ARG, e)
+            }
+            params.forEach { param ->
+                if (param !is Pair<*, *> || param.first !is TypedKey<*>)
+                    throw IllegalArgumentException("$ILLEGAL_CONFIG_ANN_ARG: invalid parameter $param")
+                propertiesData.add(param as Pair<TypedKey<*>, Any?>)
+            }
+        }
         ScriptingEnvironment(baseProperties, propertiesData)
     }
 
-    override val compilationConfigurator =
-        baseClass.findAnnotation<KotlinScriptCompilationConfigurator>()?.compilationConfigurator?.instantiateScriptHandler()
-            ?: explicitDefinition?.compilationConfigurator
-            ?: AnnotationsBasedCompilationConfigurator::class.instantiateScriptHandler()
-
     override val evaluator =
         baseClass.findAnnotation<KotlinScriptEvaluator>()?.evaluator?.instantiateScriptHandler()
             ?: explicitDefinition?.evaluator

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

@@ -85,11 +85,7 @@ class KJVMCompilerImpl : KJVMCompilerProxy {
         try {
             setIdeaIoUseFallback()
 
-            val scriptCompileConfiguration = chainPropertyBags(
+            val scriptCompileConfiguration = chainPropertyBags(additionalConfiguration, scriptDefinition.properties)
-                additionalConfiguration,
-                scriptDefinition.compilationConfigurator?.defaultConfiguration,
-                scriptDefinition.properties
-            )
             var environment: KotlinCoreEnvironment? = null
             var updatedScriptCompileConfiguration = scriptCompileConfiguration
 

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

@@ -37,21 +37,20 @@ class BridgeDependenciesResolver(
             val processedScriptData =
                 ProcessedScriptData(ProcessedScriptDataProperties.foundAnnotations to scriptContents.annotations)
 
-            val refinedConfiguration = scriptDefinition.compilationConfigurator?.let { scriptConfigurator ->
+            val refineFn = scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.refineConfiguration)
-                val res = scriptConfigurator.refineConfiguration(
+            val refinedConfiguration =
-                    scriptContents.toScriptSource(),
+                if (refineFn == null) calculatedBaseScriptCompilerConfiguration
-                    calculatedBaseScriptCompilerConfiguration,
+                else {
-                    processedScriptData
+                    val res = refineFn(scriptContents.toScriptSource(), calculatedBaseScriptCompilerConfiguration, processedScriptData)
-                )
+                    when (res) {
-                when (res) {
+                        is ResultWithDiagnostics.Failure ->
-                    is ResultWithDiagnostics.Failure ->
+                            return@resolveAsync DependenciesResolver.ResolveResult.Failure(res.reports.mapScriptReportsToDiagnostics())
-                        return@resolveAsync DependenciesResolver.ResolveResult.Failure(res.reports.mapScriptReportsToDiagnostics())
+                        is ResultWithDiagnostics.Success -> {
-                    is ResultWithDiagnostics.Success -> {
+                            diagnostics.addAll(res.reports.mapScriptReportsToDiagnostics())
-                        diagnostics.addAll(res.reports.mapScriptReportsToDiagnostics())
+                            res.value
-                        res.value
+                        }
                     }
                 }
-            } ?: calculatedBaseScriptCompilerConfiguration
 
             val newClasspath = refinedConfiguration.getOrNull(ScriptCompileConfigurationProperties.dependencies)
                 ?.flatMap { (it as JvmDependency).classpath } ?: emptyList()

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

@@ -8,6 +8,7 @@
 package kotlin.script.experimental.jvm
 
 import kotlin.script.experimental.api.*
+import kotlin.script.experimental.util.chainPropertyBags
 
 open class JvmScriptCompiler(
     val compilerProxy: KJVMCompilerProxy,
@@ -19,15 +20,14 @@ open class JvmScriptCompiler(
         scriptDefinition: ScriptDefinition,
         additionalConfiguration: ScriptCompileConfiguration?
     ): ResultWithDiagnostics<CompiledScript<*>> {
-        val baseConfiguration = additionalConfiguration?.cloneWithNewParent(scriptDefinition.compilationConfigurator?.defaultConfiguration)
+        val baseConfiguration = chainPropertyBags(additionalConfiguration, scriptDefinition.properties)
-                ?: scriptDefinition.compilationConfigurator?.defaultConfiguration
+        val refineConfigurationFn = baseConfiguration.getOrNull(ScriptCompileConfigurationProperties.refineConfiguration)
-                ?: ScriptCompileConfiguration()
         val refinedConfiguration =
             if (baseConfiguration.getOrNull(ScriptCompileConfigurationProperties.refineBeforeParsing) == true) {
-                if (scriptDefinition.compilationConfigurator == null) {
+                if (refineConfigurationFn == null) {
                     return ResultWithDiagnostics.Failure("Non-null configurator expected".asErrorDiagnostics())
                 }
-                scriptDefinition.compilationConfigurator!!.refineConfiguration(script, baseConfiguration).let {
+                refineConfigurationFn(script, baseConfiguration).let {
                     when (it) {
                         is ResultWithDiagnostics.Failure -> return it
                         is ResultWithDiagnostics.Success -> it.value

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

@@ -5,13 +5,8 @@
 
 package kotlin.script.experimental.jvm
 
-import kotlinx.coroutines.experimental.runBlocking
-import kotlin.script.experimental.api.*
 import java.io.File
 
 val jvmJavaHomeParams = with(JvmScriptCompileConfigurationProperties) {
     listOf(javaHomeDir to File(System.getProperty("java.home")))
 }
-
-val ScriptCompilationConfigurator?.defaultConfiguration: ScriptCompileConfiguration
-    get() = this?.let { runBlocking { defaultConfiguration } } ?: ScriptCompileConfiguration()

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

@@ -18,7 +18,6 @@ import kotlin.script.experimental.api.*
 import kotlin.script.experimental.dependencies.DependenciesResolver
 import kotlin.script.experimental.jvm.impl.BridgeDependenciesResolver
 import kotlin.script.experimental.location.ScriptExpectedLocation
-import kotlin.script.experimental.util.chainPropertyBags
 
 // 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) {
@@ -27,12 +26,8 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
 
     abstract val scriptFileExtensionWithDot: String
 
-    protected val baseCompilationConfiguration by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        chainPropertyBags(scriptDefinition.compilationConfigurator?.defaultConfiguration, scriptDefinition.properties)
-    }
-
     open val baseClass: KClass<*> by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        getScriptingClass(baseCompilationConfiguration[ScriptDefinitionProperties.baseClass])
+        getScriptingClass(scriptDefinition.properties[ScriptDefinitionProperties.baseClass])
     }
 
     override val template: KClass<*> get() = baseClass
@@ -54,28 +49,28 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
         get() = emptyList()
 
     override val dependencyResolver: DependenciesResolver by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        BridgeDependenciesResolver(scriptDefinition, baseCompilationConfiguration)
+        BridgeDependenciesResolver(scriptDefinition, scriptDefinition.properties)
     }
 
     override val acceptedAnnotations: List<KClass<out Annotation>> by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        baseCompilationConfiguration.getOrNull(ScriptCompileConfigurationProperties.refineConfigurationOnAnnotations)
+        scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.refineConfigurationOnAnnotations)
             .orEmpty()
             .map { getScriptingClass(it) as KClass<out Annotation> }
     }
 
     override val implicitReceivers: List<KType> by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        baseCompilationConfiguration.getOrNull(ScriptCompileConfigurationProperties.scriptImplicitReceivers)
+        scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.scriptImplicitReceivers)
             .orEmpty()
             .map { getScriptingClass(it).starProjectedType }
     }
 
     override val environmentVariables: List<Pair<String, KType>> by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        baseCompilationConfiguration.getOrNull(ScriptCompileConfigurationProperties.contextVariables)
+        scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.contextVariables)
             ?.map { (k, v) -> k to getScriptingClass(v).starProjectedType }.orEmpty()
     }
 
     override val additionalCompilerArguments: List<String>
-        get() = baseCompilationConfiguration.getOrNull(ScriptCompileConfigurationProperties.compilerOptions)
+        get() = scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.compilerOptions)
             .orEmpty()
 
     override val scriptExpectedLocations: List<ScriptExpectedLocation> =
@@ -85,11 +80,11 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
         )
 
     override val targetClassAnnotations: List<Annotation>
-        get() = baseCompilationConfiguration.getOrNull(ScriptCompileConfigurationProperties.generatedClassAnnotations)
+        get() = scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.generatedClassAnnotations)
             .orEmpty()
 
     override val targetMethodAnnotations: List<Annotation>
-        get() = baseCompilationConfiguration.getOrNull(ScriptCompileConfigurationProperties.generatedMethodAnnotations)
+        get() = scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.generatedMethodAnnotations)
             .orEmpty()
 
     private val scriptingClassGetter by lazy(LazyThreadSafetyMode.PUBLICATION) {

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

@@ -75,9 +75,6 @@ class LazyScriptDefinitionFromDiscoveredClass internal constructor(
 
 object InvalidScriptDefinition : ScriptDefinition {
     override val properties: ScriptDefinitionPropertiesBag = ScriptDefinitionPropertiesBag()
-    override val compilationConfigurator: ScriptCompilationConfigurator = object : ScriptCompilationConfigurator {
-        override val defaultConfiguration: ScriptCompileConfiguration = ScriptDefinitionPropertiesBag()
-    }
     override val evaluator: ScriptEvaluator<*>? = null
 }