Fixes after refactoring the API

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

@@ -40,6 +40,8 @@ import kotlin.concurrent.read
 import kotlin.concurrent.write
 import kotlin.script.dependencies.Environment
 import kotlin.script.dependencies.ScriptContents
+import kotlin.script.experimental.api.ScriptingEnvironment
+import kotlin.script.experimental.api.ScriptingEnvironmentParams
 import kotlin.script.experimental.definitions.ScriptDefinitionFromAnnotatedBaseClass
 import kotlin.script.experimental.dependencies.DependenciesResolver
 import kotlin.script.experimental.dependencies.ScriptDependencies
@@ -162,7 +164,9 @@ fun loadDefinitionsFromTemplates(
                     )
                 }
                 template.annotations.firstIsInstanceOrNull<kotlin.script.experimental.annotations.KotlinScript>() != null -> {
-                    KotlinScriptDefinitionAdapterFromNewAPI(ScriptDefinitionFromAnnotatedBaseClass(template))
+                    KotlinScriptDefinitionAdapterFromNewAPI(
+                        ScriptDefinitionFromAnnotatedBaseClass(ScriptingEnvironment(ScriptingEnvironmentParams.baseClass to template))
+                    )
                 }
                 else -> {
                     LOG.error("[kts] cannot find a valid script definition annotation on the class $template")

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

@@ -8,10 +8,7 @@ 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.myJvmConfig
 import java.io.File
-import kotlin.script.experimental.api.EvaluationResult
+import kotlin.script.experimental.api.*
-import kotlin.script.experimental.api.ResultWithDiagnostics
-import kotlin.script.experimental.api.ScriptEvaluationEnvironment
-import kotlin.script.experimental.api.toConfigEntry
 import kotlin.script.experimental.definitions.ScriptDefinitionFromAnnotatedBaseClass
 import kotlin.script.experimental.host.toScriptSource
 import kotlin.script.experimental.jvm.DummyCompiledJvmScriptCache
@@ -21,12 +18,14 @@ import kotlin.script.experimental.jvmhost.impl.KJVMCompilerImpl
 
 fun evalFile(scriptFile: File): ResultWithDiagnostics<EvaluationResult> {
     val scriptCompiler = JvmScriptCompiler(KJVMCompilerImpl(), DummyCompiledJvmScriptCache())
-    val scriptDefinition = ScriptDefinitionFromAnnotatedBaseClass(MyScriptWithMavenDeps::class)
+    val scriptDefinition = ScriptDefinitionFromAnnotatedBaseClass(
+        ScriptingEnvironment(ScriptingEnvironmentParams.baseClass to MyScriptWithMavenDeps::class)
+    )
 
     val host = JvmBasicScriptingHost(
-        scriptDefinition.configurator,
+        scriptDefinition.compilationConfigurator,
         scriptCompiler,
-        scriptDefinition.runner
+        scriptDefinition.evaluator
     )
 
     return host.eval(myJvmConfig { add(scriptFile.toScriptSource().toConfigEntry()) }, ScriptEvaluationEnvironment())

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

@@ -10,20 +10,18 @@ import org.jetbrains.kotlin.script.util.FilesAndMavenResolver
 import org.jetbrains.kotlin.script.util.Repository
 import org.jetbrains.kotlin.script.util.scriptCompilationClasspathFromContext
 import java.io.File
-import kotlin.reflect.KClass
 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.KotlinScriptEvaluator
 import kotlin.script.experimental.api.*
-import kotlin.script.experimental.basic.DefaultScriptSelector
 import kotlin.script.experimental.jvm.*
-import kotlin.script.experimental.jvm.runners.BasicJvmScriptRunner
+import kotlin.script.experimental.jvm.runners.BasicJvmScriptEvaluator
 
-@KotlinScript(
+@KotlinScript
-    DefaultScriptSelector::class,
+@KotlinScriptCompilationConfigurator(MyConfigurator::class)
-    MyConfigurator::class,
+@KotlinScriptEvaluator(BasicJvmScriptEvaluator::class)
-    BasicJvmScriptRunner::class
-)
 abstract class MyScriptWithMavenDeps {
 //    abstract fun body(vararg args: String): Int
 }
@@ -44,12 +42,16 @@ inline fun myJvmConfig(
     body()
 }
 
-class MyConfigurator(val baseClass: KClass<Any>? = null) : ScriptConfigurator {
+class MyConfigurator(val environment: ScriptingEnvironment) : ScriptCompilationConfigurator {
 
     private val resolver = FilesAndMavenResolver()
 
-    override suspend fun baseConfiguration(scriptSource: ScriptSource?): ResultWithDiagnostics<ScriptCompileConfiguration> =
+    override val defaultConfiguration = myJvmConfig {
-        myJvmConfig { add(scriptSource.toConfigEntry()) }.asSuccess()
+        add(ScriptCompileConfigurationParams.baseClass to environment[ScriptingEnvironmentParams.baseClass])
+    }
+
+    override suspend fun baseConfiguration(scriptSource: ScriptSource): ResultWithDiagnostics<ScriptCompileConfiguration> =
+        myJvmConfig(defaultConfiguration) { add(scriptSource.toConfigEntry()) }.asSuccess()
 
     override suspend fun refineConfiguration(
         configuration: ScriptCompileConfiguration,

libraries/examples/scripting/jvm-simple-script/host/src/org/jetbrains/kotlin/script/examples/jvm/simple/host/host.kt

@@ -25,12 +25,14 @@ inline fun myJvmConfig(
 
 fun evalFile(scriptFile: File): ResultWithDiagnostics<EvaluationResult> {
     val scriptCompiler = JvmScriptCompiler(KJVMCompilerImpl(), DummyCompiledJvmScriptCache())
-    val scriptDefinition = ScriptDefinitionFromAnnotatedBaseClass(MyScript::class)
+    val scriptDefinition = ScriptDefinitionFromAnnotatedBaseClass(
+        ScriptingEnvironment(ScriptingEnvironmentParams.baseClass to MyScript::class)
+    )
 
     val host = JvmBasicScriptingHost(
-        scriptDefinition.configurator,
+        scriptDefinition.compilationConfigurator,
         scriptCompiler,
-        scriptDefinition.runner
+        scriptDefinition.evaluator
     )
 
     return host.eval(myJvmConfig { add(scriptFile.toScriptSource().toConfigEntry()) }, ScriptEvaluationEnvironment())

libraries/examples/scripting/jvm-simple-script/script/src/org/jetbrains/kotlin/script/examples/jvm/simple/scriptDef.kt

@@ -6,11 +6,11 @@
 package org.jetbrains.kotlin.script.examples.jvm.simple
 
 import kotlin.script.experimental.annotations.KotlinScript
-import kotlin.script.experimental.basic.DefaultScriptSelector
+import kotlin.script.experimental.annotations.KotlinScriptEvaluator
-import kotlin.script.experimental.basic.PassThroughConfigurator
+import kotlin.script.experimental.jvm.runners.BasicJvmScriptEvaluator
-import kotlin.script.experimental.jvm.runners.BasicJvmScriptRunner
 
-@KotlinScript(DefaultScriptSelector::class, PassThroughConfigurator::class, BasicJvmScriptRunner::class)
+@KotlinScript
+@KotlinScriptEvaluator(BasicJvmScriptEvaluator::class)
 abstract class MyScript {
 //    abstract fun body(vararg args: String): Int
 }

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

@@ -70,7 +70,7 @@ class KJVMCompilerImpl : KJVMCompilerProxy {
 
     override fun compile(
         scriptCompilerConfiguration: ScriptCompileConfiguration,
-        configurator: ScriptConfigurator?
+        configurator: ScriptCompilationConfigurator?
     ): ResultWithDiagnostics<CompiledScript<*>> {
         val messageCollector = ScriptDiagnosticsMessageCollector()
 
@@ -238,7 +238,7 @@ class ScriptDiagnosticsMessageCollector : MessageCollector {
 
 internal class BridgeScriptDefinition(
     scriptCompilerConfiguration: ScriptCompileConfiguration,
-    scriptConfigurator: ScriptConfigurator?,
+    scriptConfigurator: ScriptCompilationConfigurator?,
     updateClasspath: (List<File>) -> Unit
 ) : KotlinScriptDefinition(scriptCompilerConfiguration[ScriptCompileConfigurationParams.scriptSignature].scriptBase as KClass<out Any>) {
     override val acceptedAnnotations =

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

@@ -21,7 +21,7 @@ import kotlin.script.experimental.jvm.mapToLegacyScriptReportPosition
 import kotlin.script.experimental.jvm.mapToLegacyScriptReportSeverity
 
 class BridgeDependenciesResolver(
-    val scriptConfigurator: ScriptConfigurator?,
+    val scriptConfigurator: ScriptCompilationConfigurator?,
     val baseScriptCompilerConfiguration: ScriptCompileConfiguration = scriptConfigurator.defaultConfiguration,
     val onClasspathUpdated: (List<File>) -> Unit = {}
 ) : AsyncDependenciesResolver {

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

@@ -14,7 +14,7 @@ open class JvmScriptCompiler(
     val cache: CompiledJvmScriptsCache
 ) : ScriptCompiler {
 
-    override suspend fun compile(configuration: ScriptCompileConfiguration, configurator: ScriptConfigurator?): ResultWithDiagnostics<CompiledScript<*>> {
+    override suspend fun compile(configuration: ScriptCompileConfiguration, configurator: ScriptCompilationConfigurator?): ResultWithDiagnostics<CompiledScript<*>> {
         val refinedConfiguration = configurator?.refineConfiguration(configuration)?.let {
             when (it) {
                 is ResultWithDiagnostics.Failure -> return it
@@ -42,7 +42,7 @@ interface CompiledJvmScriptsCache {
 interface KJVMCompilerProxy {
     fun compile(
         scriptCompilerConfiguration: ScriptCompileConfiguration,
-        configurator: ScriptConfigurator?
+        configurator: ScriptCompilationConfigurator?
     ): ResultWithDiagnostics<CompiledScript<*>>
 }
 

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

@@ -19,5 +19,5 @@ inline fun jvmConfigWithJavaHome(
         body()
     }
 
-val ScriptConfigurator?.defaultConfiguration: ScriptCompileConfiguration
+val ScriptCompilationConfigurator?.defaultConfiguration: ScriptCompileConfiguration
-    get() = this?.let { runBlocking { baseConfiguration(null) } }?.resultOrNull() ?: ScriptCompileConfiguration()
+    get() = this?.let { runBlocking { defaultConfiguration } } ?: ScriptCompileConfiguration()

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

@@ -11,10 +11,10 @@ import kotlin.script.experimental.api.*
 import kotlin.script.experimental.host.BasicScriptingHost
 
 open class JvmBasicScriptingHost<ScriptBase : Any>(
-    configurationExtractor: ScriptConfigurator,
+    configurationExtractor: ScriptCompilationConfigurator,
     compiler: JvmScriptCompiler,
-    runner: ScriptRunner<ScriptBase>
+    evaluator: ScriptEvaluator<ScriptBase>
-) : BasicScriptingHost<ScriptBase>(configurationExtractor, compiler, runner)
+) : BasicScriptingHost<ScriptBase>(configurationExtractor, compiler, evaluator)
 
 class JvmScriptEvaluationEnvironmentParams : ScriptEvaluationEnvironmentParams() {
     companion object {

libraries/scripting/jvm/src/kotlin/script/experimental/jvm/runners/BasicJvmScriptEvaluator.kt

@@ -5,12 +5,11 @@
 
 package kotlin.script.experimental.jvm.runners
 
-import kotlin.reflect.KClass
 import kotlin.script.experimental.api.*
 
-open class BasicJvmScriptRunner<ScriptBase : Any>(val baseClass: KClass<ScriptBase>? = null) : ScriptRunner<ScriptBase> {
+open class BasicJvmScriptEvaluator<ScriptBase : Any>(val environment: ScriptingEnvironment) : ScriptEvaluator<ScriptBase> {
 
-    override suspend fun run(
+    override suspend fun eval(
         compiledScript: CompiledScript<ScriptBase>,
         scriptEvaluationEnvironment: ScriptEvaluationEnvironment
     ): ResultWithDiagnostics<EvaluationResult> =

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

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.scripting.compiler.plugin
 
 import com.intellij.openapi.fileTypes.LanguageFileType
-import kotlinx.coroutines.experimental.runBlocking
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.NameUtils
@@ -16,13 +15,14 @@ import kotlin.reflect.KClass
 import kotlin.reflect.KType
 import kotlin.script.experimental.api.ScriptCompileConfigurationParams
 import kotlin.script.experimental.api.ScriptDefinition
-import kotlin.script.experimental.api.resultOrNull
+import kotlin.script.experimental.api.ScriptDefinitionProperties
 import kotlin.script.experimental.dependencies.DependenciesResolver
 import kotlin.script.experimental.jvm.impl.BridgeDependenciesResolver
 
-class KotlinScriptDefinitionAdapterFromNewAPI(val scriptDefinition: ScriptDefinition) : KotlinScriptDefinition(scriptDefinition.baseClass) {
+class KotlinScriptDefinitionAdapterFromNewAPI(val scriptDefinition: ScriptDefinition) :
+    KotlinScriptDefinition(scriptDefinition.compilationConfigurator.defaultConfiguration[ScriptCompileConfigurationParams.baseClass]) {
 
-    override val name: String get() = scriptDefinition.selector.name
+    override val name: String get() = scriptDefinition.properties[ScriptDefinitionProperties.name]
 
     // TODO: consider creating separate type (subtype? for kotlin scripts)
     override val fileType: LanguageFileType = KotlinFileType.INSTANCE
@@ -30,29 +30,28 @@ class KotlinScriptDefinitionAdapterFromNewAPI(val scriptDefinition: ScriptDefini
     override val annotationsForSamWithReceivers: List<String>
         get() = emptyList()
 
+    private val scriptFileExtensionWithDot =
+        "." + (scriptDefinition.properties.getOrNull(ScriptDefinitionProperties.fileExtension) ?: "kts")
+
     override fun isScript(fileName: String): Boolean =
-        fileName.endsWith("." + scriptDefinition.selector.fileExtension)
+        fileName.endsWith(scriptFileExtensionWithDot)
 
     override fun getScriptName(script: KtScript): Name {
         val fileBasedName = NameUtils.getScriptNameForFile(script.containingKtFile.name)
-        return Name.identifier(scriptDefinition.selector.makeScriptName(fileBasedName.identifier))
+        return Name.identifier(fileBasedName.identifier.removeSuffix(scriptFileExtensionWithDot))
     }
 
     override val dependencyResolver: DependenciesResolver by lazy {
-        BridgeDependenciesResolver(scriptDefinition.configurator)
+        BridgeDependenciesResolver(scriptDefinition.compilationConfigurator)
     }
 
     override val acceptedAnnotations: List<KClass<out Annotation>> by lazy {
-        runBlocking {
+        scriptDefinition.compilationConfigurator.defaultConfiguration.getOrNull(ScriptCompileConfigurationParams.updateConfigurationOnAnnotations)?.toList()
-            scriptDefinition.configurator.baseConfiguration(null)
+                ?: emptyList()
-        }.resultOrNull()?.getOrNull(ScriptCompileConfigurationParams.updateConfigurationOnAnnotations)?.toList()
-        ?: emptyList()
     }
 
     override val implicitReceivers: List<KType> by lazy {
-        runBlocking {
+        scriptDefinition.compilationConfigurator.defaultConfiguration.getOrNull(ScriptCompileConfigurationParams.scriptSignature)?.providedDeclarations?.implicitReceivers
-            scriptDefinition.configurator.baseConfiguration(null)
-        }.resultOrNull()?.getOrNull(ScriptCompileConfigurationParams.scriptSignature)?.providedDeclarations?.implicitReceivers
                 ?: emptyList()
     }
 }

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

@@ -20,6 +20,8 @@ import java.io.File
 import java.io.IOException
 import java.net.URLClassLoader
 import java.util.jar.JarFile
+import kotlin.script.experimental.api.ScriptingEnvironment
+import kotlin.script.experimental.api.ScriptingEnvironmentParams
 import kotlin.script.experimental.definitions.ScriptDefinitionFromAnnotatedBaseClass
 
 class ScriptingCompilerConfigurationExtension(val project: MockProject) : CompilerConfigurationExtension {
@@ -124,7 +126,9 @@ fun configureScriptDefinitions(
                 val cls = classloader.loadClass(template)
                 val def =
                     if (cls.annotations.firstIsInstanceOrNull<kotlin.script.experimental.annotations.KotlinScript>() != null) {
-                        KotlinScriptDefinitionAdapterFromNewAPI(ScriptDefinitionFromAnnotatedBaseClass(cls.kotlin))
+                        KotlinScriptDefinitionAdapterFromNewAPI(
+                            ScriptDefinitionFromAnnotatedBaseClass(ScriptingEnvironment(ScriptingEnvironmentParams.baseClass to cls.kotlin))
+                        )
                     } else {
                         KotlinScriptDefinitionFromAnnotatedTemplate(cls.kotlin, scriptResolverEnv)
                     }