Refactor host configuration handling and script definition creation

so it is possible now to create custom host configuration with template and all configurations are handled consistenly. Also introduce and use new ScriptDefinition class wrapping compilation and evaluation configurations, that could be consistenly created from a template.
2020-05-13 21:44:39 +02:00
parent 255ad47406
commit 4b032a14af
12 changed files with 246 additions and 159 deletions
@@ -10,6 +10,7 @@ package kotlin.script.experimental.annotations
 import kotlin.reflect.KClass
 import kotlin.script.experimental.api.ScriptCompilationConfiguration
 import kotlin.script.experimental.api.ScriptEvaluationConfiguration
+import kotlin.script.experimental.host.ScriptingHostConfiguration

 /**
 * The annotation for declaring a script definition (template)
@@ -52,6 +53,7 @@ annotation class KotlinScript(
    val fileExtension: String = "kts",
    val filePathPattern: String = "",
    val compilationConfiguration: KClass<out ScriptCompilationConfiguration> = ScriptCompilationConfiguration.Default::class,
-    val evaluationConfiguration: KClass<out ScriptEvaluationConfiguration> = ScriptEvaluationConfiguration.Default::class
+    val evaluationConfiguration: KClass<out ScriptEvaluationConfiguration> = ScriptEvaluationConfiguration.Default::class,
+    val hostConfiguration: KClass<out ScriptingHostConfiguration> = ScriptingHostConfiguration::class
 )

@@ -10,18 +10,44 @@ import kotlin.script.experimental.annotations.KotlinScript
 import kotlin.script.experimental.api.*
 import kotlin.script.experimental.util.PropertiesCollection

-private const val ERROR_MSG_PREFIX = "Unable to construct script definition: "
+/**
+ * Script definition combines configuration data for script compilation and evaluation
+ */
+data class ScriptDefinition(
+    val compilationConfiguration: ScriptCompilationConfiguration,
+    val evaluationConfiguration: ScriptEvaluationConfiguration
+)

-private const val ILLEGAL_CONFIG_ANN_ARG =
-    "Illegal argument compilationConfiguration of the KotlinScript annotation: expecting an object or default-constructed class derived from ScriptCompilationConfiguration"
+/**
+ * Creates script compilation and evaluation configuration from annotated script base class
+ * @param baseClassType the annotated script base class to construct the configuration from
+ * @param baseHostConfiguration base scripting host configuration properties
+ * @param contextClass optional context class to extract classloading strategy from
+ * @param compilation optional configuration function to add more properties to the compilation configuration
+ * @param evaluation optional configuration function to add more properties to the evaluation configuration
+ */
+fun createScriptDefinitionFromTemplate(
+    baseClassType: KotlinType,
+    baseHostConfiguration: ScriptingHostConfiguration,
+    contextClass: KClass<*> = ScriptDefinition::class,
+    compilation: ScriptCompilationConfiguration.Builder.() -> Unit = {},
+    evaluation: ScriptEvaluationConfiguration.Builder.() -> Unit = {}
+): ScriptDefinition {
+    val templateClass: KClass<*> = baseClassType.getTemplateClass(baseHostConfiguration, contextClass)
+    val mainAnnotation = templateClass.kotlinScriptAnnotation

-private const val SCRIPT_RUNTIME_TEMPLATES_PACKAGE = "kotlin.script.templates.standard"
+    val hostConfiguration = constructHostConfiguration(mainAnnotation.hostConfiguration, baseHostConfiguration) {}

-@KotlinScript
-private abstract class DummyScriptTemplate
+    val compilationConfiguration =
+        constructCompilationConfiguration(mainAnnotation, hostConfiguration, templateClass, baseClassType, compilation)
+    val evaluationConfiguration = constructEvaluationConfiguration(mainAnnotation, hostConfiguration, evaluation)
+
+    return ScriptDefinition(compilationConfiguration, evaluationConfiguration)
+}

 /**
 * Creates compilation configuration from annotated script base class
+ * NOTE: it is preferable to use createScriptDefinitionFromTemplate for creating all configurations at once
 * @param baseClassType the annotated script base class to construct the configuration from
 * @param baseHostConfiguration scripting host configuration properties
 * @param contextClass optional context class to extract classloading strategy from
@@ -33,20 +59,17 @@ fun createCompilationConfigurationFromTemplate(
    contextClass: KClass<*> = ScriptCompilationConfiguration::class,
    body: ScriptCompilationConfiguration.Builder.() -> Unit = {}
 ): ScriptCompilationConfiguration {
-
    val templateClass: KClass<*> = baseClassType.getTemplateClass(baseHostConfiguration, contextClass)
+    val mainAnnotation = templateClass.kotlinScriptAnnotation

-    val mainAnnotation: KotlinScript = templateClass.kotlinScriptAnnotation
+    val hostConfiguration = constructHostConfiguration(mainAnnotation.hostConfiguration, baseHostConfiguration) {}

-    return ScriptCompilationConfiguration(scriptConfigInstance(mainAnnotation.compilationConfiguration)) {
-        hostConfiguration.update { it.withDefaultsFrom(baseHostConfiguration) }
-        propertiesFromTemplate(templateClass, baseClassType, mainAnnotation)
-        body()
-    }
+    return constructCompilationConfiguration(mainAnnotation, hostConfiguration, templateClass, baseClassType, body)
 }

 /**
 * Creates evaluation configuration from annotated script base class
+ * NOTE: it is preferable to use createScriptDefinitionFromTemplate for creating all configurations at once
 * @param baseClassType the annotated script base class to construct the configuration from
 * @param baseHostConfiguration scripting host configuration properties
 * @param contextClass optional context class to extract classloading strategy from
@@ -58,17 +81,76 @@ fun createEvaluationConfigurationFromTemplate(
    contextClass: KClass<*> = ScriptEvaluationConfiguration::class,
    body: ScriptEvaluationConfiguration.Builder.() -> Unit = {}
 ): ScriptEvaluationConfiguration {
-
    val templateClass: KClass<*> = baseClassType.getTemplateClass(baseHostConfiguration, contextClass)
-
    val mainAnnotation = templateClass.kotlinScriptAnnotation

-    return ScriptEvaluationConfiguration(scriptConfigInstance(mainAnnotation.evaluationConfiguration)) {
-        hostConfiguration.update { it.withDefaultsFrom(baseHostConfiguration) }
+    val hostConfiguration = constructHostConfiguration(mainAnnotation.hostConfiguration, baseHostConfiguration) {}
+
+    return constructEvaluationConfiguration(mainAnnotation, hostConfiguration, body)
+}
+
+private const val ERROR_MSG_PREFIX = "Unable to construct script definition: "
+
+private const val SCRIPT_RUNTIME_TEMPLATES_PACKAGE = "kotlin.script.templates.standard"
+
+@KotlinScript
+private abstract class DummyScriptTemplate
+
+private fun constructCompilationConfiguration(
+    mainAnnotation: KotlinScript,
+    hostConfiguration: ScriptingHostConfiguration,
+    templateClass: KClass<*>,
+    baseClassType: KotlinType,
+    body: ScriptCompilationConfiguration.Builder.() -> Unit
+): ScriptCompilationConfiguration {
+    val compilationConfigurationInstance = scriptConfigInstance(mainAnnotation.compilationConfiguration)
+        ?: throw IllegalArgumentException("${ERROR_MSG_PREFIX}Illegal argument compilationConfiguration of the KotlinScript annotation: expecting an object or default-constructable class derived from ScriptCompilationConfiguration")
+
+    return ScriptCompilationConfiguration(compilationConfigurationInstance) {
+        // TODO: consider deprecating host configuration updating here, it is better to do it via dedicated annotation parameter
+        this.hostConfiguration.update { it.withDefaultsFrom(hostConfiguration) }
+        propertiesFromTemplate(templateClass, baseClassType, mainAnnotation)
        body()
    }
 }

+private fun constructEvaluationConfiguration(
+    mainAnnotation: KotlinScript,
+    hostConfiguration: ScriptingHostConfiguration,
+    body: ScriptEvaluationConfiguration.Builder.() -> Unit
+): ScriptEvaluationConfiguration {
+    val evaluationConfigurationInstance = scriptConfigInstance(mainAnnotation.evaluationConfiguration)
+        ?: throw IllegalArgumentException("${ERROR_MSG_PREFIX}Illegal argument evaluationConfiguration of the KotlinScript annotation: expecting an object or default-constructable class derived from ScriptEvaluationConfiguration")
+
+    return ScriptEvaluationConfiguration(evaluationConfigurationInstance) {
+        // TODO: consider deprecating host configuration updating here, it is better to do it via dedicated annotation parameter
+        this.hostConfiguration.update { it.withDefaultsFrom(hostConfiguration) }
+        body()
+    }
+}
+
+private fun constructHostConfiguration(
+    hostConfigurationKClass: KClass<out ScriptingHostConfiguration>,
+    baseHostConfiguration: ScriptingHostConfiguration,
+    body: ScriptingHostConfiguration.Builder.() -> Unit
+): ScriptingHostConfiguration {
+    if (hostConfigurationKClass == ScriptingHostConfiguration::class)
+        return ScriptingHostConfiguration(body).withDefaultsFrom(baseHostConfiguration)
+
+    val singleArgConstructor = hostConfigurationKClass.java.constructors.singleOrNull {
+        it.parameters.isNotEmpty() && it.parameters.first().type.isAssignableFrom(ScriptingHostConfiguration::class.java)
+    }
+
+    val hostConfigurationInstance =
+        if (singleArgConstructor != null) singleArgConstructor.newInstance(baseHostConfiguration) as ScriptingHostConfiguration
+        else scriptConfigInstance(hostConfigurationKClass)
+            ?: throw IllegalArgumentException("${ERROR_MSG_PREFIX}Illegal argument hostConfiguration of the KotlinScript annotation: expecting an object or a class derived from ScriptingHostConfiguration constructable without arguments or from a base configuration")
+
+    return hostConfigurationInstance.with {
+        body()
+    }.withDefaultsFrom(baseHostConfiguration)
+}
+
 private fun ScriptCompilationConfiguration.Builder.propertiesFromTemplate(
    templateClass: KClass<*>, baseClassType: KotlinType, mainAnnotation: KotlinScript
 ) {
@@ -83,13 +165,14 @@ private val KClass<*>.kotlinScriptAnnotation: KotlinScript
        ?: when (this@kotlinScriptAnnotation.qualifiedName) {
            // Any is the default template, so use a default annotation
            Any::class.qualifiedName,
-            // transitions to the new scripting API: substituting annotations for standard templates from script-runtime
+                // transitions to the new scripting API: substituting annotations for standard templates from script-runtime
            "$SCRIPT_RUNTIME_TEMPLATES_PACKAGE.SimpleScriptTemplate",
            "$SCRIPT_RUNTIME_TEMPLATES_PACKAGE.ScriptTemplateWithArgs",
-            "$SCRIPT_RUNTIME_TEMPLATES_PACKAGE.ScriptTemplateWithBindings" -> DummyScriptTemplate::class.findAnnotation<KotlinScript>()
+            "$SCRIPT_RUNTIME_TEMPLATES_PACKAGE.ScriptTemplateWithBindings",
+            -> DummyScriptTemplate::class.findAnnotation()
            else -> null
        }
-        ?: throw IllegalArgumentException("${ERROR_MSG_PREFIX}Expecting KotlinScript annotation on the ${this}")
+        ?: throw IllegalArgumentException("${ERROR_MSG_PREFIX}Expecting KotlinScript annotation on the $this")

 private fun KotlinType.getTemplateClass(hostConfiguration: ScriptingHostConfiguration, contextClass: KClass<*>): KClass<*> {
    val getScriptingClass = hostConfiguration[ScriptingHostConfiguration.getScriptingClass]
@@ -98,7 +181,7 @@ private fun KotlinType.getTemplateClass(hostConfiguration: ScriptingHostConfigur
    return try {
        getScriptingClass(this, contextClass, hostConfiguration)
    } catch (e: Throwable) {
-        throw IllegalArgumentException("${ERROR_MSG_PREFIX}Unable to load base class ${this}", e)
+        throw IllegalArgumentException("${ERROR_MSG_PREFIX}Unable to load base class $this", e)
    }
 }

@@ -106,18 +189,9 @@ private inline fun <reified T : Annotation> KClass<*>.findAnnotation(): T? =
    @Suppress("UNCHECKED_CAST")
    this.java.annotations.firstOrNull { it is T } as T?

-private fun <T : Any> KClass<T>.createInstance(): T {
-    // TODO: throw a meaningful exception
-    val noArgsConstructor = java.constructors.singleOrNull { it.parameters.isEmpty() }
-        ?: throw IllegalArgumentException("Class should have a single no-arg constructor: $this")
-
-    @Suppress("UNCHECKED_CAST")
-    return noArgsConstructor.newInstance() as T
-}
-
-private fun <T : PropertiesCollection> scriptConfigInstance(kclass: KClass<out T>): T = try {
-    kclass.objectInstance ?: kclass.createInstance()
-} catch (e: Throwable) {
-    throw IllegalArgumentException("$ILLEGAL_CONFIG_ANN_ARG: ${e.message + if (e.cause != null) " (${e.cause})" else ""}", e)
-}
+private inline fun <reified T : PropertiesCollection> scriptConfigInstance(kclass: KClass<out T>): T? =
+    kclass.objectInstance ?: run {
+        val noArgsConstructor = kclass.java.constructors.singleOrNull { it.parameters.isEmpty() }
+        noArgsConstructor?.let { it.newInstance() as T }
+    }

@@ -17,7 +17,7 @@ interface ScriptingHostConfigurationKeys
 * The container for script evaluation configuration
 * For usages see actual code examples
 */
-class ScriptingHostConfiguration(baseScriptingConfigurations: Iterable<ScriptingHostConfiguration>, body: Builder.() -> Unit) :
+open class ScriptingHostConfiguration(baseScriptingConfigurations: Iterable<ScriptingHostConfiguration>, body: Builder.() -> Unit) :
    PropertiesCollection(Builder(baseScriptingConfigurations).apply(body).data) {

    constructor(body: Builder.() -> Unit = {}) : this(emptyList(), body)
@@ -11,15 +11,14 @@ import java.io.File
 import javax.script.Bindings
 import javax.script.ScriptContext
 import javax.script.ScriptEngine
-import kotlin.script.experimental.api.ScriptCompilationConfiguration
 import kotlin.script.experimental.api.dependencies
+import kotlin.script.experimental.api.with
 import kotlin.script.experimental.jvm.JvmDependencyFromClassLoader
 import kotlin.script.experimental.jvm.JvmScriptCompilationConfigurationBuilder
 import kotlin.script.experimental.jvm.jvm
 import kotlin.script.experimental.jvm.updateClasspath
 import kotlin.script.experimental.jvm.util.scriptCompilationClasspathFromContext
-import kotlin.script.experimental.jvmhost.createJvmCompilationConfigurationFromTemplate
-import kotlin.script.experimental.jvmhost.createJvmEvaluationConfigurationFromTemplate
+import kotlin.script.experimental.jvmhost.createJvmScriptDefinitionFromTemplate
 import kotlin.script.experimental.jvmhost.jsr223.KotlinJsr223ScriptEngineImpl

 /**
@@ -31,13 +30,12 @@ const val KOTLIN_JSR223_RESOLVE_FROM_CLASSLOADER_PROPERTY = "kotlin.jsr223.exper

 class KotlinJsr223DefaultScriptEngineFactory : KotlinJsr223JvmScriptEngineFactoryBase() {

-    private val compilationConfiguration = createJvmCompilationConfigurationFromTemplate<KotlinJsr223DefaultScript>()
-    private val evaluationConfiguration = createJvmEvaluationConfigurationFromTemplate<KotlinJsr223DefaultScript>()
+    private val scriptDefinition = createJvmScriptDefinitionFromTemplate<KotlinJsr223DefaultScript>()
    private var lastClassLoader: ClassLoader? = null
    private var lastClassPath: List<File>? = null

    @Synchronized
-    protected fun JvmScriptCompilationConfigurationBuilder.dependenciesFromCurrentContext() {
+    private fun JvmScriptCompilationConfigurationBuilder.dependenciesFromCurrentContext() {
        val currentClassLoader = Thread.currentThread().contextClassLoader
        val classPath = if (lastClassLoader == null || lastClassLoader != currentClassLoader) {
            scriptCompilationClasspathFromContext(
@@ -55,7 +53,7 @@ class KotlinJsr223DefaultScriptEngineFactory : KotlinJsr223JvmScriptEngineFactor
    override fun getScriptEngine(): ScriptEngine =
        KotlinJsr223ScriptEngineImpl(
            this,
-            ScriptCompilationConfiguration(compilationConfiguration) {
+            scriptDefinition.compilationConfiguration.with {
                jvm {
                    if (System.getProperty(KOTLIN_JSR223_RESOLVE_FROM_CLASSLOADER_PROPERTY) == "true") {
                        dependencies(JvmDependencyFromClassLoader { Thread.currentThread().contextClassLoader })
@@ -64,7 +62,7 @@ class KotlinJsr223DefaultScriptEngineFactory : KotlinJsr223JvmScriptEngineFactor
                    }
                }
            },
-            evaluationConfiguration
+            scriptDefinition.evaluationConfiguration
        ) { ScriptArgsWithTypes(arrayOf(it.getBindings(ScriptContext.ENGINE_SCOPE).orEmpty()), arrayOf(Bindings::class)) }
 }

@@ -54,12 +54,11 @@ class ScriptingHostTest : TestCase() {
        val greeting = "Hello from script!"
        val output = captureOut {
            val basicJvmScriptingHost = BasicJvmScriptingHost()
-            basicJvmScriptingHost.eval(
+            basicJvmScriptingHost.evalWithTemplate<SimpleScript>(
                "println(\"$greeting\")".toScriptSource("name"),
-                createJvmCompilationConfigurationFromTemplate<SimpleScript>(basicJvmScriptingHost.hostConfiguration) {
+                compilation = {
                    updateClasspath(classpathFromClass<SimpleScript>())
-                },
-                createJvmEvaluationConfigurationFromTemplate<SimpleScript>(basicJvmScriptingHost.hostConfiguration)
+                }
            ).throwOnFailure()
        }
        Assert.assertEquals(greeting, output)
@@ -206,15 +205,19 @@ class ScriptingHostTest : TestCase() {
    fun testSimpleImportWithImplicitReceiver() {
        val greeting = listOf("Hello from helloWithVal script!", "Hello from imported helloWithVal script!")
        val script = "println(\"Hello from imported \$helloScriptName script!\")"
-        val compilationConfiguration = createJvmCompilationConfigurationFromTemplate<SimpleScriptTemplate> {
-            makeSimpleConfigurationWithTestImport()
-            implicitReceivers(String::class)
-        }
-        val evaluationConfiguration = createJvmEvaluationConfigurationFromTemplate<SimpleScriptTemplate> {
-            implicitReceivers("abc")
-        }
+        val definition = createJvmScriptDefinitionFromTemplate<SimpleScriptTemplate>(
+            compilation = {
+                makeSimpleConfigurationWithTestImport()
+                implicitReceivers(String::class)
+            },
+            evaluation = {
+                implicitReceivers("abc")
+            }
+        )
        val output = captureOut {
-            BasicJvmScriptingHost().eval(script.toScriptSource(), compilationConfiguration, evaluationConfiguration).throwOnFailure()
+            BasicJvmScriptingHost().eval(
+                script.toScriptSource(), definition.compilationConfiguration, definition.evaluationConfiguration
+            ).throwOnFailure()
        }.lines()
        Assert.assertEquals(greeting, output)
    }
@@ -3,19 +3,18 @@
 * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
 */

+@file:Suppress("unused")
+
 package kotlin.script.experimental.jvmhost

 import kotlin.script.experimental.api.*
-import kotlin.script.experimental.host.ScriptingHostConfiguration
-import kotlin.script.experimental.host.createCompilationConfigurationFromTemplate
-import kotlin.script.experimental.host.BasicScriptingHost
-import kotlin.script.experimental.host.createEvaluationConfigurationFromTemplate
+import kotlin.script.experimental.host.*
 import kotlin.script.experimental.jvm.BasicJvmScriptEvaluator
 import kotlin.script.experimental.jvm.defaultJvmScriptingHostConfiguration

 open class BasicJvmScriptingHost(
-    val hostConfiguration: ScriptingHostConfiguration = defaultJvmScriptingHostConfiguration,
-    compiler: JvmScriptCompiler = JvmScriptCompiler(hostConfiguration),
+    val baseHostConfiguration: ScriptingHostConfiguration? = null,
+    compiler: JvmScriptCompiler = JvmScriptCompiler(baseHostConfiguration.withDefaultsFrom(defaultJvmScriptingHostConfiguration)),
    evaluator: ScriptEvaluator = BasicJvmScriptEvaluator()
 ) : BasicScriptingHost(compiler, evaluator) {

@@ -23,31 +22,43 @@ open class BasicJvmScriptingHost(
        script: SourceCode,
        noinline compilation: ScriptCompilationConfiguration.Builder.() -> Unit = {},
        noinline evaluation: ScriptEvaluationConfiguration.Builder.() -> Unit = {}
-    ): ResultWithDiagnostics<EvaluationResult> =
-        eval(
-            script,
-            createJvmCompilationConfigurationFromTemplate<T>(hostConfiguration, compilation),
-            createJvmEvaluationConfigurationFromTemplate<T>(hostConfiguration, evaluation)
-        )
+    ): ResultWithDiagnostics<EvaluationResult> {
+        val definition =
+            createJvmScriptDefinitionFromTemplate<T>(baseHostConfiguration, compilation, evaluation)
+        return eval(script, definition.compilationConfiguration, definition.evaluationConfiguration)
+    }
 }


 inline fun <reified T : Any> createJvmCompilationConfigurationFromTemplate(
-    hostConfiguration: ScriptingHostConfiguration = defaultJvmScriptingHostConfiguration,
+    baseHostConfiguration: ScriptingHostConfiguration? = null,
    noinline body: ScriptCompilationConfiguration.Builder.() -> Unit = {}
 ): ScriptCompilationConfiguration = createCompilationConfigurationFromTemplate(
    KotlinType(T::class),
-    hostConfiguration,
+    baseHostConfiguration.withDefaultsFrom(defaultJvmScriptingHostConfiguration),
    ScriptCompilationConfiguration::class,
    body
 )

 inline fun <reified T : Any> createJvmEvaluationConfigurationFromTemplate(
-    hostConfiguration: ScriptingHostConfiguration = defaultJvmScriptingHostConfiguration,
+    baseHostConfiguration: ScriptingHostConfiguration? = null,
    noinline body: ScriptEvaluationConfiguration.Builder.() -> Unit = {}
 ): ScriptEvaluationConfiguration = createEvaluationConfigurationFromTemplate(
    KotlinType(T::class),
-    hostConfiguration,
+    baseHostConfiguration.withDefaultsFrom(defaultJvmScriptingHostConfiguration),
    ScriptEvaluationConfiguration::class,
    body
 )
+
+inline fun <reified T : Any> createJvmScriptDefinitionFromTemplate(
+    baseHostConfiguration: ScriptingHostConfiguration? = null,
+    noinline compilation: ScriptCompilationConfiguration.Builder.() -> Unit = {},
+    noinline evaluation: ScriptEvaluationConfiguration.Builder.() -> Unit = {}
+): ScriptDefinition = createScriptDefinitionFromTemplate(
+    KotlinType(T::class),
+    baseHostConfiguration.withDefaultsFrom(defaultJvmScriptingHostConfiguration),
+    ScriptCompilationConfiguration::class,
+    compilation,
+    evaluation
+)
+
@@ -11,25 +11,24 @@ import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.coroutines.startCoroutine
 import kotlin.script.experimental.api.*
 import kotlin.script.experimental.host.createEvaluationConfigurationFromTemplate
+import kotlin.script.experimental.host.withDefaultsFrom
 import kotlin.script.experimental.jvm.impl.createScriptFromClassLoader

@Suppress("unused") // script codegen generates a call to it
 fun runCompiledScript(scriptClass: Class<*>, vararg args: String) {
    val script = createScriptFromClassLoader(scriptClass.name, scriptClass.classLoader)
    val evaluator = BasicJvmScriptEvaluator()
-    val hostConfiguration = script.compilationConfiguration[ScriptCompilationConfiguration.hostConfiguration]
-        ?: defaultJvmScriptingHostConfiguration
-    val baseEvaluationConfiguration =
+    val evaluationConfiguration =
        createEvaluationConfigurationFromTemplate(
            script.compilationConfiguration[ScriptCompilationConfiguration.baseClass]!!,
-            hostConfiguration,
+            script.compilationConfiguration[ScriptCompilationConfiguration.hostConfiguration]
+                .withDefaultsFrom(defaultJvmScriptingHostConfiguration),
            scriptClass.kotlin
-        )
-    val evaluationConfiguration = ScriptEvaluationConfiguration(baseEvaluationConfiguration) {
-        jvm {
-            mainArguments(args)
+        ) {
+            jvm {
+                mainArguments(args)
+            }
        }
-    }
    runScriptSuspend {
        evaluator(script, evaluationConfiguration).onFailure {
            it.reports.forEach(System.err::println)