Rename ScriptDefinition to ScriptCompileConfiguration

compiler/tests/org/jetbrains/kotlin/codegen/AbstractCustomScriptCodegenTest.kt

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.utils.PathUtil.KOTLIN_SCRIPTING_JVM_JAR
 import org.junit.Assert
 import java.io.File
 import kotlin.script.experimental.annotations.KotlinScript
-import kotlin.script.experimental.api.ScriptDefinition
+import kotlin.script.experimental.api.ScriptCompilationConfiguration
 import kotlin.script.experimental.api.implicitReceivers
 import kotlin.script.experimental.api.providedProperties
 
@@ -121,20 +121,20 @@ abstract class AbstractCustomScriptCodegenTest : CodegenTestCase() {
     }
 }
 
-object TestScriptWithReceiversConfiguration : ScriptDefinition(
+object TestScriptWithReceiversConfiguration : ScriptCompilationConfiguration(
     {
         implicitReceivers<String>()
     })
 
 @Suppress("unused")
-@KotlinScript(definition = TestScriptWithReceiversConfiguration::class)
+@KotlinScript(compilationConfiguration = TestScriptWithReceiversConfiguration::class)
 abstract class TestScriptWithReceivers
 
-object TestScriptWithSimpleEnvVarsConfiguration : ScriptDefinition(
+object TestScriptWithSimpleEnvVarsConfiguration : ScriptCompilationConfiguration(
     {
         providedProperties("stringVar1" to String::class)
     })
 
 @Suppress("unused")
-@KotlinScript(definition = TestScriptWithSimpleEnvVarsConfiguration::class)
+@KotlinScript(compilationConfiguration = TestScriptWithSimpleEnvVarsConfiguration::class)
 abstract class TestScriptWithSimpleEnvVars

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

@@ -51,7 +51,7 @@ import kotlin.script.dependencies.ScriptContents
 import kotlin.script.experimental.api.KotlinType
 import kotlin.script.experimental.api.ScriptingEnvironment
 import kotlin.script.experimental.api.configurationDependencies
-import kotlin.script.experimental.definitions.createScriptDefinitionFromAnnotatedBaseClass
+import kotlin.script.experimental.configuration.createScriptCompilationConfigurationFromAnnotatedBaseClass
 import kotlin.script.experimental.dependencies.DependenciesResolver
 import kotlin.script.experimental.dependencies.ScriptDependencies
 import kotlin.script.experimental.dependencies.asSuccess
@@ -213,7 +213,11 @@ fun loadDefinitionsFromTemplates(
                         configurationDependencies(JvmDependency(classpath))
                     }
                     KotlinScriptDefinitionAdapterFromNewAPI(
-                        createScriptDefinitionFromAnnotatedBaseClass(KotlinType(template), hostEnvironment, KotlinScriptDefinition::class),
+                        createScriptCompilationConfigurationFromAnnotatedBaseClass(
+                            KotlinType(
+                                template
+                            ), hostEnvironment, KotlinScriptDefinition::class
+                        ),
                         hostEnvironment
                     )
                 }

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

@@ -11,13 +11,13 @@ import kotlin.script.experimental.api.EvaluationResult
 import kotlin.script.experimental.api.ResultWithDiagnostics
 import kotlin.script.experimental.host.toScriptSource
 import kotlin.script.experimental.jvmhost.BasicJvmScriptingHost
-import kotlin.script.experimental.jvmhost.createBasicScriptDefinitionFromAnnotatedBaseClass
+import kotlin.script.experimental.jvmhost.createBasicScriptCompilationConfigurationFromAnnotatedBaseClass
 
 fun evalFile(scriptFile: File): ResultWithDiagnostics<EvaluationResult> {
 
-    val scriptDefinition = createBasicScriptDefinitionFromAnnotatedBaseClass<MyScriptWithMavenDeps>()
+    val compilationConfiguration = createBasicScriptCompilationConfigurationFromAnnotatedBaseClass<MyScriptWithMavenDeps>()
 
-    return BasicJvmScriptingHost().eval(scriptFile.toScriptSource(), scriptDefinition, null)
+    return BasicJvmScriptingHost().eval(scriptFile.toScriptSource(), compilationConfiguration, null)
 }
 
 fun main(vararg args: String) {

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

@@ -21,13 +21,13 @@ import kotlin.script.experimental.jvm.jvm
 
 @KotlinScript(
     extension = "scriptwithdeps.kts",
-    definition = MyScriptDefinition::class
+    compilationConfiguration = MyScriptCompilationConfiguration::class
 )
 abstract class MyScriptWithMavenDeps {
 //    abstract fun body(vararg args: String): Int
 }
 
-object MyScriptDefinition : ScriptDefinition(
+object MyScriptCompilationConfiguration : ScriptCompilationConfiguration(
     {
         defaultImports<DependsOn>()
         defaultImports(Repository::class)
@@ -49,7 +49,7 @@ object MyScriptDefinition : ScriptDefinition(
 
 private val resolver = FilesAndMavenResolver()
 
-fun myConfigureOnAnnotations(script: ScriptDataFacade): ResultWithDiagnostics<ScriptDefinition?> {
+fun myConfigureOnAnnotations(script: ScriptDataFacade): ResultWithDiagnostics<ScriptCompilationConfiguration?> {
     val annotations = script.collectedData?.get(ScriptCollectedData.foundAnnotations)?.takeIf { it.isNotEmpty() }
         ?: return null.asSuccess()
     val scriptContents = object : ScriptContents {
@@ -66,7 +66,7 @@ fun myConfigureOnAnnotations(script: ScriptDataFacade): ResultWithDiagnostics<Sc
             ?: return null.asSuccess(diagnostics)
         val resolvedClasspath = newDepsFromResolver.classpath.toList().takeIf { it.isNotEmpty() }
             ?: return null.asSuccess(diagnostics)
-        ScriptDefinition(script.definition) {
+        ScriptCompilationConfiguration(script.compilationConfiguration) {
             dependencies.append(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

@@ -13,10 +13,10 @@ import kotlin.script.experimental.host.toScriptSource
 import kotlin.script.experimental.jvm.dependenciesFromCurrentContext
 import kotlin.script.experimental.jvm.jvm
 import kotlin.script.experimental.jvmhost.BasicJvmScriptingHost
-import kotlin.script.experimental.jvmhost.createBasicScriptDefinitionFromAnnotatedBaseClass
+import kotlin.script.experimental.jvmhost.createBasicScriptCompilationConfigurationFromAnnotatedBaseClass
 
 fun evalFile(scriptFile: File): ResultWithDiagnostics<EvaluationResult> {
-    val scriptDefinition = createBasicScriptDefinitionFromAnnotatedBaseClass<MyScript> {
+    val compilationConfiguration = createBasicScriptCompilationConfigurationFromAnnotatedBaseClass<MyScript> {
         jvm {
             dependenciesFromCurrentContext(
                 "scripting-jvm-simple-script" /* script library jar name */
@@ -24,7 +24,7 @@ fun evalFile(scriptFile: File): ResultWithDiagnostics<EvaluationResult> {
         }
     }
 
-    return BasicJvmScriptingHost().eval(scriptFile.toScriptSource(), scriptDefinition, null)
+    return BasicJvmScriptingHost().eval(scriptFile.toScriptSource(), compilationConfiguration, null)
 }
 
 fun main(vararg args: String) {

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

@@ -13,14 +13,14 @@
 package kotlin.script.experimental.annotations
 
 import kotlin.reflect.KClass
-import kotlin.script.experimental.api.ScriptDefinition
+import kotlin.script.experimental.api.ScriptCompilationConfiguration
 
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
 annotation class KotlinScript(
     val name: String = "Kotlin script",
     val extension: String = "kts",
-    val definition: KClass<out ScriptDefinition> = ScriptDefinition.Default::class // object or class filled in 0-ary constructor
+    val compilationConfiguration: KClass<out ScriptCompilationConfiguration> = ScriptCompilationConfiguration.Default::class // object or class filled in 0-ary constructor
 )
 
 @Target(AnnotationTarget.CLASS)
@@ -32,5 +32,5 @@ annotation class KotlinScriptFileExtension(
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
 annotation class KotlinScriptProperties(
-    val definition: KClass<out ScriptDefinition> // object or class filled in 0-ary constructor
+    val compilationConfiguration: KClass<out ScriptCompilationConfiguration> // object or class filled in 0-ary constructor
 )

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

@@ -9,14 +9,14 @@ interface ScriptCompiler {
 
     suspend operator fun invoke(
         script: ScriptSource,
-        scriptDefinition: ScriptDefinition
+        scriptCompilationConfiguration: ScriptCompilationConfiguration
     ): ResultWithDiagnostics<CompiledScript<*>>
 }
 
 
 interface CompiledScript<out ScriptBase : Any> {
 
-    val definition: ScriptDefinition
+    val compilationConfiguration: ScriptCompilationConfiguration
 
     suspend fun instantiate(scriptEvaluationEnvironment: ScriptEvaluationEnvironment?): ResultWithDiagnostics<ScriptBase>
 }

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

@@ -23,11 +23,11 @@ val ScriptCollectedDataKeys.foundFragments by PropertiesCollection.key<List<Scri
 
 class ScriptDataFacade(
     val source: ScriptSource,
-    val definition: ScriptDefinition,
+    val compilationConfiguration: ScriptCompilationConfiguration,
     val collectedData: ScriptCollectedData? = null
 )
 
-typealias RefineScriptCompilationConfigurationHandler = (ScriptDataFacade) -> ResultWithDiagnostics<ScriptDefinition?>
+typealias RefineScriptCompilationConfigurationHandler = (ScriptDataFacade) -> ResultWithDiagnostics<ScriptCompilationConfiguration?>
 
 // to make it "hasheable" for cashing
 class RefineConfigurationBeforeParsingData(

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

@@ -10,65 +10,67 @@ package kotlin.script.experimental.api
 import kotlin.reflect.KClass
 import kotlin.script.experimental.util.PropertiesCollection
 
-interface ScriptDefinitionKeys
+interface ScriptCompilationConfigurationKeys
 
-open class ScriptDefinition(baseDefinitions: Iterable<ScriptDefinition>, body: Builder.() -> Unit) :
+open class ScriptCompilationConfiguration(baseConfigurations: Iterable<ScriptCompilationConfiguration>, body: Builder.() -> Unit) :
-    PropertiesCollection(Builder(baseDefinitions).apply(body).data) {
+    PropertiesCollection(Builder(baseConfigurations).apply(body).data) {
 
     constructor(body: Builder.() -> Unit = {}) : this(emptyList(), body)
-    constructor(vararg baseDefinitions: ScriptDefinition, body: Builder.() -> Unit = {}) : this(baseDefinitions.asIterable(), body)
+    constructor(
+        vararg baseConfigurations: ScriptCompilationConfiguration, body: Builder.() -> Unit = {}
+    ) : this(baseConfigurations.asIterable(), body)
 
-    class Builder internal constructor(baseDefinitions: Iterable<ScriptDefinition>) :
+    class Builder internal constructor(baseConfigurations: Iterable<ScriptCompilationConfiguration>) :
-        ScriptDefinitionKeys,
+        ScriptCompilationConfigurationKeys,
-        PropertiesCollection.Builder(baseDefinitions)
+        PropertiesCollection.Builder(baseConfigurations)
 
-    // inherited from script definition for using as a keys anchor
+    // inherited from script compilationConfiguration for using as a keys anchor
-    companion object : ScriptDefinitionKeys
+    companion object : ScriptCompilationConfigurationKeys
 
-    object Default : ScriptDefinition()
+    object Default : ScriptCompilationConfiguration()
 }
 
-val ScriptDefinitionKeys.displayName by PropertiesCollection.key<String>("Kotlin script") // Name of the script type
+val ScriptCompilationConfigurationKeys.displayName by PropertiesCollection.key<String>("Kotlin script") // Name of the script type
 
-val ScriptDefinitionKeys.fileExtension by PropertiesCollection.key<String>("kts") // file extension
+val ScriptCompilationConfigurationKeys.fileExtension by PropertiesCollection.key<String>("kts") // file extension
 
-val ScriptDefinitionKeys.baseClass by PropertiesCollection.key<KotlinType>() // script base class
+val ScriptCompilationConfigurationKeys.baseClass by PropertiesCollection.key<KotlinType>() // script base class
 
-val ScriptDefinitionKeys.scriptBodyTarget by PropertiesCollection.key<ScriptBodyTarget>(ScriptBodyTarget.Constructor)
+val ScriptCompilationConfigurationKeys.scriptBodyTarget by PropertiesCollection.key<ScriptBodyTarget>(ScriptBodyTarget.Constructor)
 
-val ScriptDefinitionKeys.implicitReceivers by PropertiesCollection.key<List<KotlinType>>() // in the order from outer to inner scope
+val ScriptCompilationConfigurationKeys.implicitReceivers by PropertiesCollection.key<List<KotlinType>>() // in the order from outer to inner scope
 
-val ScriptDefinitionKeys.providedProperties by PropertiesCollection.key<Map<String, KotlinType>>() // external variables
+val ScriptCompilationConfigurationKeys.providedProperties by PropertiesCollection.key<Map<String, KotlinType>>() // external variables
 
-val ScriptDefinitionKeys.defaultImports by PropertiesCollection.key<List<String>>()
+val ScriptCompilationConfigurationKeys.defaultImports by PropertiesCollection.key<List<String>>()
 
-val ScriptDefinitionKeys.dependencies by PropertiesCollection.key<List<ScriptDependency>>()
+val ScriptCompilationConfigurationKeys.dependencies by PropertiesCollection.key<List<ScriptDependency>>()
 
-val ScriptDefinitionKeys.copyAnnotationsFrom by PropertiesCollection.key<List<KotlinType>>()
+val ScriptCompilationConfigurationKeys.copyAnnotationsFrom by PropertiesCollection.key<List<KotlinType>>()
 
-val ScriptDefinitionKeys.compilerOptions by PropertiesCollection.key<List<String>>() // Q: CommonCompilerOptions instead?
+val ScriptCompilationConfigurationKeys.compilerOptions by PropertiesCollection.key<List<String>>() // Q: CommonCompilerOptions instead?
 
-val ScriptDefinitionKeys.refineConfigurationBeforeParsing by PropertiesCollection.key<RefineConfigurationBeforeParsingData>()
+val ScriptCompilationConfigurationKeys.refineConfigurationBeforeParsing by PropertiesCollection.key<RefineConfigurationBeforeParsingData>()
 
-val ScriptDefinitionKeys.refineConfigurationOnAnnotations by PropertiesCollection.key<RefineConfigurationOnAnnotationsData>()
+val ScriptCompilationConfigurationKeys.refineConfigurationOnAnnotations by PropertiesCollection.key<RefineConfigurationOnAnnotationsData>()
 
-val ScriptDefinitionKeys.refineConfigurationOnSections by PropertiesCollection.key<RefineConfigurationOnSectionsData>()
+val ScriptCompilationConfigurationKeys.refineConfigurationOnSections by PropertiesCollection.key<RefineConfigurationOnSectionsData>()
 
-val ScriptDefinitionKeys.sourceFragments by PropertiesCollection.key<List<ScriptSourceNamedFragment>>()
+val ScriptCompilationConfigurationKeys.sourceFragments by PropertiesCollection.key<List<ScriptSourceNamedFragment>>()
 
 // DSL:
 
-val ScriptDefinition.Builder.refineConfiguration get() = RefineConfigurationBuilder()
+val ScriptCompilationConfiguration.Builder.refineConfiguration get() = RefineConfigurationBuilder()
 
 
 class RefineConfigurationBuilder : PropertiesCollection.Builder() {
 
     fun beforeParsing(handler: RefineScriptCompilationConfigurationHandler) {
-        set(ScriptDefinition.refineConfigurationBeforeParsing, RefineConfigurationBeforeParsingData(handler))
+        set(ScriptCompilationConfiguration.refineConfigurationBeforeParsing, RefineConfigurationBeforeParsingData(handler))
     }
 
     fun onAnnotations(annotations: List<KotlinType>, handler: RefineScriptCompilationConfigurationHandler) {
-        set(ScriptDefinition.refineConfigurationOnAnnotations, RefineConfigurationOnAnnotationsData(annotations, handler))
+        set(ScriptCompilationConfiguration.refineConfigurationOnAnnotations, RefineConfigurationOnAnnotationsData(annotations, handler))
     }
 
     fun onAnnotations(vararg annotations: KotlinType, handler: RefineScriptCompilationConfigurationHandler) {
@@ -88,7 +90,7 @@ class RefineConfigurationBuilder : PropertiesCollection.Builder() {
     }
 
     fun onSections(sections: List<String>, handler: RefineScriptCompilationConfigurationHandler) {
-        set(ScriptDefinition.refineConfigurationOnSections, RefineConfigurationOnSectionsData(sections, handler))
+        set(ScriptCompilationConfiguration.refineConfigurationOnSections, RefineConfigurationOnSectionsData(sections, handler))
     }
 
     fun onSections(vararg sections: String, handler: RefineScriptCompilationConfigurationHandler) {

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

@@ -20,7 +20,7 @@ class ScriptEvaluationEnvironment(baseEvaluationEnvironments: Iterable<ScriptEva
     ) : this(baseEvaluationEnvironments.asIterable(), body)
 
     class Builder internal constructor(baseEvaluationEnvironments: Iterable<ScriptEvaluationEnvironment>) :
-        ScriptDefinitionKeys,
+        ScriptCompilationConfigurationKeys,
         PropertiesCollection.Builder(baseEvaluationEnvironments)
 
     companion object : ScriptEvaluationEnvironmentKeys

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

@@ -1,9 +1,9 @@
 /*
- * Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
  * that can be found in the license/LICENSE.txt file.
  */
 
-package kotlin.script.experimental.definitions
+package kotlin.script.experimental.configuration
 
 import kotlin.reflect.KClass
 import kotlin.script.experimental.annotations.KotlinScript
@@ -14,14 +14,14 @@ import kotlin.script.experimental.api.*
 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"
+    "Illegal argument compilationConfiguration of the KotlinScript annotation: expecting an object or default-constructed class derived from ScriptCompilationConfiguration"
 
-fun createScriptDefinitionFromAnnotatedBaseClass(
+fun createScriptCompilationConfigurationFromAnnotatedBaseClass(
     baseClassType: KotlinType,
     environment: ScriptingEnvironment,
-    contextClass: KClass<*> = ScriptDefinition::class,
+    contextClass: KClass<*> = ScriptCompilationConfiguration::class,
-    body: ScriptDefinition.Builder.() -> Unit = {}
+    body: ScriptCompilationConfiguration.Builder.() -> Unit = {}
-): ScriptDefinition {
+): ScriptCompilationConfiguration {
 
     val getScriptingClass = environment[ScriptingEnvironment.getScriptingClass]
         ?: throw IllegalArgumentException("${ERROR_MSG_PREFIX}Expecting 'getScriptingClass' parameter in the scripting environment")
@@ -37,21 +37,21 @@ fun createScriptDefinitionFromAnnotatedBaseClass(
     val mainAnnotation = baseClass.findAnnotation<KotlinScript>()
         ?: throw IllegalArgumentException("${ERROR_MSG_PREFIX}Expecting KotlinScript annotation on the $baseClass")
 
-    fun scriptingPropsInstance(kclass: KClass<out ScriptDefinition>): ScriptDefinition = try {
+    fun scriptingPropsInstance(kclass: KClass<out ScriptCompilationConfiguration>): ScriptCompilationConfiguration = try {
         kclass.objectInstance ?: kclass.createInstance()
     } catch (e: Throwable) {
         throw IllegalArgumentException(ILLEGAL_CONFIG_ANN_ARG, e)
     }
 
-    return ScriptDefinition {
+    return ScriptCompilationConfiguration {
         baseClass(loadedBaseClassType)
         fileExtension(baseClass.findAnnotation<KotlinScriptFileExtension>()?.extension ?: mainAnnotation.extension)
         displayName(mainAnnotation.name)
 
-        include(scriptingPropsInstance(mainAnnotation.definition))
+        include(scriptingPropsInstance(mainAnnotation.compilationConfiguration))
 
         baseClass.java.annotations.filterIsInstance(KotlinScriptProperties::class.java).forEach { ann ->
-            include(scriptingPropsInstance(ann.definition))
+            include(scriptingPropsInstance(ann.compilationConfiguration))
         }
         body()
     }

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

@@ -30,11 +30,11 @@ abstract class BasicScriptingHost(
 
     open fun eval(
         script: ScriptSource,
-        scriptDefinition: ScriptDefinition,
+        scriptCompilationConfiguration: ScriptCompilationConfiguration,
         environment: ScriptEvaluationEnvironment?
     ): ResultWithDiagnostics<EvaluationResult> =
         runInCoroutineContext {
-            compiler(script, scriptDefinition).onSuccess {
+            compiler(script, scriptCompilationConfiguration).onSuccess {
                 evaluator(it, environment)
             }
         }

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

@@ -16,9 +16,9 @@ fun ScriptSource.getScriptText(): String = when {
     else -> throw RuntimeException("unable to get text from null script")
 }
 
-fun getMergedScriptText(script: ScriptSource, configuration: ScriptDefinition?): String {
+fun getMergedScriptText(script: ScriptSource, configuration: ScriptCompilationConfiguration?): String {
     val originalScriptText = script.getScriptText()
-    val sourceFragments = configuration?.get(ScriptDefinition.sourceFragments)
+    val sourceFragments = configuration?.get(ScriptCompilationConfiguration.sourceFragments)
     return if (sourceFragments == null || sourceFragments.isEmpty()) {
         originalScriptText
     } else {

libraries/scripting/common/src/kotlin/script/experimental/repl/replCompilation.kt

@@ -12,7 +12,7 @@ interface ReplSnippetChecker {
     suspend operator fun invoke(
         snippet: ReplSnippetSource,
         state: ReplStageState<*>,
-        scriptDefinition: ScriptDefinition
+        compilationConfiguration: ScriptCompilationConfiguration
     ): ResultWithDiagnostics<Unit>
 }
 
@@ -21,7 +21,7 @@ interface ReplSnippetCompiler {
     suspend operator fun invoke(
         snippet: ReplSnippetSource,
         state: ReplStageState<*>,
-        scriptDefinition: ScriptDefinition
+        compilationConfiguration: ScriptCompilationConfiguration
     ): ResultWithDiagnostics<CompiledReplSnippet<*>>
 }
 

libraries/scripting/common/src/kotlin/script/experimental/repl/replHost.kt

@@ -9,7 +9,7 @@ import kotlinx.coroutines.experimental.CoroutineScope
 import kotlinx.coroutines.experimental.runBlocking
 import kotlin.script.experimental.api.EvaluationResult
 import kotlin.script.experimental.api.ResultWithDiagnostics
-import kotlin.script.experimental.api.ScriptDefinition
+import kotlin.script.experimental.api.ScriptCompilationConfiguration
 import kotlin.script.experimental.util.PropertiesCollection
 
 interface ReplCommandProcessor {
@@ -51,7 +51,7 @@ abstract class ReplHost(
     abstract fun eval(
         snippet: ReplSnippetSource,
         state: ReplStageState<*>,
-        scriptDefinition: ScriptDefinition,
+        scriptCompilationConfiguration: ScriptCompilationConfiguration,
         replEvaluationEnvironment: ReplEvaluationEnvironment
     ): ResultWithDiagnostics<EvaluationResult>
 }

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

@@ -6,10 +6,10 @@
 package kotlin.script.experimental.jvmhost
 
 import kotlin.script.experimental.api.KotlinType
-import kotlin.script.experimental.api.ScriptDefinition
+import kotlin.script.experimental.api.ScriptCompilationConfiguration
 import kotlin.script.experimental.api.ScriptEvaluator
 import kotlin.script.experimental.api.ScriptingEnvironment
-import kotlin.script.experimental.definitions.createScriptDefinitionFromAnnotatedBaseClass
+import kotlin.script.experimental.configuration.createScriptCompilationConfigurationFromAnnotatedBaseClass
 import kotlin.script.experimental.host.BasicScriptingHost
 import kotlin.script.experimental.jvm.defaultJvmScriptingEnvironment
 
@@ -20,7 +20,12 @@ open class BasicJvmScriptingHost(
 ) : BasicScriptingHost(compiler, evaluator)
 
 
-inline fun <reified T : Any> createBasicScriptDefinitionFromAnnotatedBaseClass(
+inline fun <reified T : Any> createBasicScriptCompilationConfigurationFromAnnotatedBaseClass(
     hostEnvironment: ScriptingEnvironment = defaultJvmScriptingEnvironment,
-    noinline body: ScriptDefinition.Builder.() -> Unit = {}
+    noinline body: ScriptCompilationConfiguration.Builder.() -> Unit = {}
-): ScriptDefinition = createScriptDefinitionFromAnnotatedBaseClass(KotlinType(T::class), hostEnvironment, ScriptDefinition::class, body)
+): ScriptCompilationConfiguration = createScriptCompilationConfigurationFromAnnotatedBaseClass(
+    KotlinType(T::class),
+    hostEnvironment,
+    ScriptCompilationConfiguration::class,
+    body
+)

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

@@ -50,7 +50,7 @@ import kotlin.script.experimental.util.getFirstFromChainOrNull
 import kotlin.script.experimental.util.getOrError
 
 class KJvmCompiledScript<out ScriptBase : Any>(
-    override val definition: ScriptDefinition,
+    override val compilationConfiguration: ScriptCompilationConfiguration,
     private val generationState: GenerationState,
     private val scriptClassFQName: String
 ) : CompiledScript<ScriptBase> {
@@ -58,7 +58,7 @@ class KJvmCompiledScript<out ScriptBase : Any>(
     override suspend fun instantiate(scriptEvaluationEnvironment: ScriptEvaluationEnvironment?): ResultWithDiagnostics<ScriptBase> = try {
         val baseClassLoader = scriptEvaluationEnvironment?.get(JvmScriptEvaluationEnvironment.baseClassLoader)
             ?: Thread.currentThread().contextClassLoader
-        val dependencies = definition[ScriptDefinition.dependencies]
+        val dependencies = compilationConfiguration[ScriptCompilationConfiguration.dependencies]
             ?.flatMap { (it as? JvmDependency)?.classpath?.map { it.toURI().toURL() } ?: emptyList() }
         // TODO: previous dependencies and classloaders should be taken into account here
         val classLoaderWithDeps =
@@ -78,7 +78,7 @@ class KJvmCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJvmCompiler
 
     override fun compile(
         script: ScriptSource,
-        scriptDefinition: ScriptDefinition
+        scriptCompilationConfiguration: ScriptCompilationConfiguration
     ): ResultWithDiagnostics<CompiledScript<*>> {
         val messageCollector = ScriptDiagnosticsMessageCollector()
 
@@ -89,12 +89,12 @@ class KJvmCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJvmCompiler
             setIdeaIoUseFallback()
 
             var environment: KotlinCoreEnvironment? = null
-            var updatedDefinition = scriptDefinition
+            var updatedConfiguration = scriptCompilationConfiguration
 
             fun updateClasspath(classpath: List<File>) {
                 environment!!.updateClasspath(classpath.map(::JvmClasspathRoot))
                 if (classpath.isNotEmpty()) {
-                    updatedDefinition = ScriptDefinition(updatedDefinition) {
+                    updatedConfiguration = ScriptCompilationConfiguration(updatedConfiguration) {
                         dependencies.append(JvmDependency(classpath))
                     }
                 }
@@ -104,18 +104,18 @@ class KJvmCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJvmCompiler
             val kotlinCompilerConfiguration = org.jetbrains.kotlin.config.CompilerConfiguration().apply {
                 add(
                     JVMConfigurationKeys.SCRIPT_DEFINITIONS,
-                    BridgeScriptDefinition(scriptDefinition, hostEnvironment, ::updateClasspath)
+                    BridgeScriptDefinition(scriptCompilationConfiguration, hostEnvironment, ::updateClasspath)
                 )
                 put<MessageCollector>(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
                 put(JVMConfigurationKeys.RETAIN_OUTPUT_IN_MEMORY, true)
 
                 var isModularJava = false
-                getFirstFromChainOrNull(ScriptDefinition.jvm.javaHome, updatedDefinition, hostEnvironment)?.let {
+                getFirstFromChainOrNull(ScriptCompilationConfiguration.jvm.javaHome, updatedConfiguration, hostEnvironment)?.let {
                     put(JVMConfigurationKeys.JDK_HOME, it)
                     isModularJava = CoreJrtFileSystem.isModularJdk(it)
                 }
 
-                updatedDefinition[ScriptDefinition.dependencies]?.let { dependencies ->
+                updatedConfiguration[ScriptCompilationConfiguration.dependencies]?.let { dependencies ->
                     addJvmClasspathRoots(
                         dependencies.flatMap {
                             (it as JvmDependency).classpath
@@ -147,7 +147,7 @@ class KJvmCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJvmCompiler
             val analyzerWithCompilerReport = AnalyzerWithCompilerReport(messageCollector, environment.configuration.languageVersionSettings)
 
             val psiFileFactory: PsiFileFactoryImpl = PsiFileFactory.getInstance(environment.project) as PsiFileFactoryImpl
-            val scriptText = getMergedScriptText(script, updatedDefinition)
+            val scriptText = getMergedScriptText(script, updatedConfiguration)
             val scriptFileName = "script" // TODO: extract from file/url if available
             val virtualFile = LightVirtualFile(
                 "$scriptFileName${KotlinParserDefinition.STD_SCRIPT_EXT}",
@@ -192,7 +192,7 @@ class KJvmCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJvmCompiler
                 org.jetbrains.kotlin.codegen.CompilationErrorHandler.THROW_EXCEPTION
             )
 
-            val res = KJvmCompiledScript<Any>(updatedDefinition, generationState, scriptFileName.capitalize())
+            val res = KJvmCompiledScript<Any>(updatedConfiguration, generationState, scriptFileName.capitalize())
 
             return ResultWithDiagnostics.Success(res, messageCollector.diagnostics)
         } catch (ex: Throwable) {
@@ -237,22 +237,22 @@ class ScriptDiagnosticsMessageCollector : MessageCollector {
 // A bridge to the current scripting
 
 internal class BridgeScriptDefinition(
-    scriptDefinition: ScriptDefinition,
+    scriptCompilationConfiguration: ScriptCompilationConfiguration,
     hostEnvironment: ScriptingEnvironment,
     updateClasspath: (List<File>) -> Unit
 ) : KotlinScriptDefinition(
     hostEnvironment.getScriptingClass(
-        scriptDefinition.getOrError(ScriptDefinition.baseClass),
+        scriptCompilationConfiguration.getOrError(ScriptCompilationConfiguration.baseClass),
         BridgeScriptDefinition::class
     )
 ) {
     override val acceptedAnnotations = run {
         val cl = this::class.java.classLoader
-        scriptDefinition[ScriptDefinition.refineConfigurationOnAnnotations]?.annotations
+        scriptCompilationConfiguration[ScriptCompilationConfiguration.refineConfigurationOnAnnotations]?.annotations
             ?.map { (cl.loadClass(it.typeName) as Class<out Annotation>).kotlin }
             ?: emptyList()
     }
 
     override val dependencyResolver: DependenciesResolver =
-        BridgeDependenciesResolver(scriptDefinition, updateClasspath)
+        BridgeDependenciesResolver(scriptCompilationConfiguration, updateClasspath)
 }

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

@@ -13,16 +13,16 @@ import kotlin.script.experimental.jvmhost.impl.KJvmCompilerImpl
 import kotlin.script.experimental.jvmhost.impl.withDefaults
 
 interface CompiledJvmScriptsCache {
-    fun get(script: ScriptSource, scriptDefinition: ScriptDefinition): CompiledScript<*>?
+    fun get(script: ScriptSource, scriptCompilationConfiguration: ScriptCompilationConfiguration): CompiledScript<*>?
-    fun store(compiledScript: CompiledScript<*>, scriptDefinition: ScriptDefinition)
+    fun store(compiledScript: CompiledScript<*>, scriptCompilationConfiguration: ScriptCompilationConfiguration)
 
     object NoCache : CompiledJvmScriptsCache {
         override fun get(
-            script: ScriptSource, scriptDefinition: ScriptDefinition
+            script: ScriptSource, scriptCompilationConfiguration: ScriptCompilationConfiguration
         ): CompiledScript<*>? = null
 
         override fun store(
-            compiledScript: CompiledScript<*>, scriptDefinition: ScriptDefinition
+            compiledScript: CompiledScript<*>, scriptCompilationConfiguration: ScriptCompilationConfiguration
         ) {
         }
     }
@@ -36,16 +36,16 @@ open class JvmScriptCompiler(
 
     override suspend operator fun invoke(
         script: ScriptSource,
-        scriptDefinition: ScriptDefinition
+        scriptCompilationConfiguration: ScriptCompilationConfiguration
     ): ResultWithDiagnostics<CompiledScript<*>> {
-        val refineConfigurationFn = scriptDefinition[ScriptDefinition.refineConfigurationBeforeParsing]
+        val refineConfigurationFn = scriptCompilationConfiguration[ScriptCompilationConfiguration.refineConfigurationBeforeParsing]
         val refinedConfiguration =
-            refineConfigurationFn?.handler?.invoke(ScriptDataFacade(script, scriptDefinition))?.let {
+            refineConfigurationFn?.handler?.invoke(ScriptDataFacade(script, scriptCompilationConfiguration))?.let {
                 when (it) {
                     is ResultWithDiagnostics.Failure -> return it
                     is ResultWithDiagnostics.Success -> it.value
                 }
-            } ?: scriptDefinition
+            } ?: scriptCompilationConfiguration
         val cached = cache.get(script, refinedConfiguration)
 
         if (cached != null) return cached.asSuccess()
@@ -61,7 +61,7 @@ open class JvmScriptCompiler(
 interface KJvmCompilerProxy {
     fun compile(
         script: ScriptSource,
-        scriptDefinition: ScriptDefinition
+        scriptCompilationConfiguration: ScriptCompilationConfiguration
     ): ResultWithDiagnostics<CompiledScript<*>>
 }
 

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

@@ -20,7 +20,7 @@ import kotlin.script.experimental.jvm.compat.mapToLegacyScriptReportPosition
 import kotlin.script.experimental.jvm.compat.mapToLegacyScriptReportSeverity
 
 class BridgeDependenciesResolver(
-    val scriptDefinition: ScriptDefinition,
+    val scriptCompilationConfiguration: ScriptCompilationConfiguration,
     val onClasspathUpdated: (List<File>) -> Unit = {}
 ) : AsyncDependenciesResolver {
 
@@ -39,12 +39,12 @@ class BridgeDependenciesResolver(
                 )
             )
 
-            val refineFn = scriptDefinition[ScriptDefinition.refineConfigurationOnAnnotations]?.handler
+            val refineFn = scriptCompilationConfiguration[ScriptCompilationConfiguration.refineConfigurationOnAnnotations]?.handler
             val refinedConfiguration =
                 if (refineFn == null) null
                 else {
                     val res = refineFn(
-                        ScriptDataFacade(scriptContents.toScriptSource(), scriptDefinition, processedScriptData)
+                        ScriptDataFacade(scriptContents.toScriptSource(), scriptCompilationConfiguration, processedScriptData)
                     )
                     when (res) {
                         is ResultWithDiagnostics.Failure ->
@@ -56,11 +56,11 @@ class BridgeDependenciesResolver(
                     }
                 }
 
-            val newClasspath = refinedConfiguration?.get(ScriptDefinition.dependencies)
+            val newClasspath = refinedConfiguration?.get(ScriptCompilationConfiguration.dependencies)
                 ?.flatMap { (it as JvmDependency).classpath } ?: emptyList()
             if (newClasspath.isNotEmpty()) {
                 val oldClasspath =
-                    scriptDefinition[ScriptDefinition.dependencies]
+                    scriptCompilationConfiguration[ScriptCompilationConfiguration.dependencies]
                         ?.flatMap { (it as JvmDependency).classpath } ?: emptyList()
                 if (newClasspath != oldClasspath) {
                     onClasspathUpdated(newClasspath)
@@ -69,7 +69,7 @@ class BridgeDependenciesResolver(
             DependenciesResolver.ResolveResult.Success(
                 ScriptDependencies(
                     classpath = newClasspath, // TODO: maybe it should return only increment from the initial config
-                    imports = scriptDefinition[ScriptDefinition.defaultImports]?.toList() ?: emptyList()
+                    imports = scriptCompilationConfiguration[ScriptCompilationConfiguration.defaultImports]?.toList() ?: emptyList()
                 ),
                 diagnostics
             )

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

@@ -15,31 +15,31 @@ data class JvmDependency(val classpath: List<File>) : ScriptDependency {
     constructor(vararg classpathEntries: File) : this(classpathEntries.asList())
 }
 
-interface JvmScriptDefinitionKeys
+interface JvmScriptCompilationConfigurationKeys
 
-open class JvmScriptDefinitionBuilder : PropertiesCollection.Builder(), JvmScriptDefinitionKeys {
+open class JvmScriptCompilationConfigurationBuilder : PropertiesCollection.Builder(), JvmScriptCompilationConfigurationKeys {
-    companion object : PropertiesCollection.Builder.BuilderExtension<JvmScriptDefinitionBuilder>, JvmScriptDefinitionKeys {
+    companion object : PropertiesCollection.Builder.BuilderExtension<JvmScriptCompilationConfigurationBuilder>, JvmScriptCompilationConfigurationKeys {
-        override fun get() = JvmScriptDefinitionBuilder()
+        override fun get() = JvmScriptCompilationConfigurationBuilder()
     }
 }
 
-fun JvmScriptDefinitionBuilder.dependenciesFromCurrentContext(vararg libraries: String, wholeClasspath: Boolean = false) {
+fun JvmScriptCompilationConfigurationBuilder.dependenciesFromCurrentContext(vararg libraries: String, wholeClasspath: Boolean = false) {
     dependenciesFromClassloader(*libraries, wholeClasspath = wholeClasspath)
 }
 
-fun JvmScriptDefinitionBuilder.dependenciesFromClassloader(
+fun JvmScriptCompilationConfigurationBuilder.dependenciesFromClassloader(
     vararg libraries: String,
     classLoader: ClassLoader = Thread.currentThread().contextClassLoader,
     wholeClasspath: Boolean = false
 ) {
-    ScriptDefinition.dependencies.append(
+    ScriptCompilationConfiguration.dependencies.append(
         JvmDependency(scriptCompilationClasspathFromContext(*libraries, classLoader = classLoader, wholeClasspath = wholeClasspath))
     )
 }
 
-val JvmScriptDefinitionKeys.javaHome by PropertiesCollection.keyCopy(ScriptingEnvironment.jvm.javaHome)
+val JvmScriptCompilationConfigurationKeys.javaHome by PropertiesCollection.keyCopy(ScriptingEnvironment.jvm.javaHome)
 
 @Suppress("unused")
-val ScriptDefinitionKeys.jvm
+val ScriptCompilationConfigurationKeys.jvm
-    get() = JvmScriptDefinitionBuilder
+    get() = JvmScriptCompilationConfigurationBuilder
 

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

@@ -23,20 +23,20 @@ import kotlin.script.experimental.util.getOrError
 // 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) {
 
-    protected abstract val scriptDefinition: ScriptDefinition
+    protected abstract val scriptCompilationConfiguration: ScriptCompilationConfiguration
 
     protected abstract val hostEnvironment: ScriptingEnvironment
 
     abstract val scriptFileExtensionWithDot: String
 
     open val baseClass: KClass<*> by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        getScriptingClass(scriptDefinition.getOrError(ScriptDefinition.baseClass))
+        getScriptingClass(scriptCompilationConfiguration.getOrError(ScriptCompilationConfiguration.baseClass))
     }
 
     override val template: KClass<*> get() = baseClass
 
     override val name: String
-        get() = scriptDefinition[ScriptDefinition.displayName] ?: "Kotlin Script"
+        get() = scriptCompilationConfiguration[ScriptCompilationConfiguration.displayName] ?: "Kotlin Script"
 
     override val fileType: LanguageFileType = KotlinFileType.INSTANCE
 
@@ -52,28 +52,28 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
         get() = emptyList()
 
     override val dependencyResolver: DependenciesResolver by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        BridgeDependenciesResolver(scriptDefinition)
+        BridgeDependenciesResolver(scriptCompilationConfiguration)
     }
 
     override val acceptedAnnotations: List<KClass<out Annotation>> by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        scriptDefinition[ScriptDefinition.refineConfigurationOnAnnotations]?.annotations
+        scriptCompilationConfiguration[ScriptCompilationConfiguration.refineConfigurationOnAnnotations]?.annotations
             .orEmpty()
             .map { getScriptingClass(it) as KClass<out Annotation> }
     }
 
     override val implicitReceivers: List<KType> by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        scriptDefinition[ScriptDefinition.implicitReceivers]
+        scriptCompilationConfiguration[ScriptCompilationConfiguration.implicitReceivers]
             .orEmpty()
             .map { getScriptingClass(it).starProjectedType }
     }
 
     override val environmentVariables: List<Pair<String, KType>> by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        scriptDefinition[ScriptDefinition.providedProperties]
+        scriptCompilationConfiguration[ScriptCompilationConfiguration.providedProperties]
             ?.map { (k, v) -> k to getScriptingClass(v).starProjectedType }.orEmpty()
     }
 
     override val additionalCompilerArguments: List<String>
-        get() = scriptDefinition[ScriptDefinition.compilerOptions]
+        get() = scriptCompilationConfiguration[ScriptCompilationConfiguration.compilerOptions]
             .orEmpty()
 
     override val scriptExpectedLocations: List<ScriptExpectedLocation> =
@@ -97,12 +97,12 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
 
 
 class KotlinScriptDefinitionAdapterFromNewAPI(
-    override val scriptDefinition: ScriptDefinition,
+    override val scriptCompilationConfiguration: ScriptCompilationConfiguration,
     override val hostEnvironment: ScriptingEnvironment
 ) : KotlinScriptDefinitionAdapterFromNewAPIBase() {
 
-    override val name: String get() = scriptDefinition[ScriptDefinition.displayName] ?: super.name
+    override val name: String get() = scriptCompilationConfiguration[ScriptCompilationConfiguration.displayName] ?: super.name
 
     override val scriptFileExtensionWithDot =
-        "." + (scriptDefinition[ScriptDefinition.fileExtension] ?: "kts")
+        "." + (scriptCompilationConfiguration[ScriptCompilationConfiguration.fileExtension] ?: "kts")
 }

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

@@ -16,7 +16,7 @@ import java.io.File
 import kotlin.script.experimental.annotations.KotlinScript
 import kotlin.script.experimental.annotations.KotlinScriptFileExtension
 import kotlin.script.experimental.api.*
-import kotlin.script.experimental.definitions.createScriptDefinitionFromAnnotatedBaseClass
+import kotlin.script.experimental.configuration.createScriptCompilationConfigurationFromAnnotatedBaseClass
 import kotlin.script.experimental.jvm.JvmDependency
 import kotlin.script.experimental.jvm.defaultJvmScriptingEnvironment
 
@@ -41,13 +41,13 @@ class LazyScriptDefinitionFromDiscoveredClass internal constructor(
         }
     }
 
-    override val scriptDefinition: ScriptDefinition by lazy(LazyThreadSafetyMode.PUBLICATION) {
+    override val scriptCompilationConfiguration: ScriptCompilationConfiguration by lazy(LazyThreadSafetyMode.PUBLICATION) {
         messageCollector.report(
             CompilerMessageSeverity.LOGGING,
             "Configure scripting: loading script definition class $className using classpath $classpath\n.  ${Thread.currentThread().stackTrace}"
         )
         try {
-            createScriptDefinitionFromAnnotatedBaseClass(
+            createScriptCompilationConfigurationFromAnnotatedBaseClass(
                 KotlinType(className),
                 hostEnvironment,
                 LazyScriptDefinitionFromDiscoveredClass::class
@@ -70,8 +70,8 @@ class LazyScriptDefinitionFromDiscoveredClass internal constructor(
                     ?: annotationsFromAsm.find { it.name == KotlinScript::class.simpleName }?.args
                 )?.find { it.name == "extension" }?.value
         val ext = extFromAnn
-            ?: scriptDefinition.let {
+            ?: scriptCompilationConfiguration.let {
-                it[ScriptDefinition.fileExtension] ?: "kts"
+                it[ScriptCompilationConfiguration.fileExtension] ?: "kts"
             }
         ".$ext"
     }
@@ -82,4 +82,4 @@ class LazyScriptDefinitionFromDiscoveredClass internal constructor(
     }
 }
 
-val InvalidScriptDefinition = ScriptDefinition()
+val InvalidScriptDefinition = ScriptCompilationConfiguration()

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

@@ -18,7 +18,7 @@ import java.util.jar.JarFile
 import kotlin.coroutines.experimental.buildSequence
 import kotlin.script.experimental.annotations.KotlinScript
 import kotlin.script.experimental.api.KotlinType
-import kotlin.script.experimental.definitions.createScriptDefinitionFromAnnotatedBaseClass
+import kotlin.script.experimental.configuration.createScriptCompilationConfigurationFromAnnotatedBaseClass
 import kotlin.script.experimental.jvm.defaultJvmScriptingEnvironment
 import kotlin.script.templates.ScriptTemplateDefinition
 
@@ -274,7 +274,7 @@ private fun loadScriptDefinition(
             if (cls.annotations.firstIsInstanceOrNull<KotlinScript>() != null) {
                 val environment = defaultJvmScriptingEnvironment
                 KotlinScriptDefinitionAdapterFromNewAPI(
-                    createScriptDefinitionFromAnnotatedBaseClass(
+                    createScriptCompilationConfigurationFromAnnotatedBaseClass(
                         KotlinType(cls.kotlin),
                         environment,
                         KotlinScriptDefinition::class