Make script definition a property bag directly

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

@@ -38,8 +38,8 @@ import org.jetbrains.kotlin.idea.caches.project.getScriptRelatedModuleInfo
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil.isInContent
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.script.*
-import org.jetbrains.kotlin.scripting.compiler.plugin.KotlinScriptDefinitionAdapterFromNewAPI
 import org.jetbrains.kotlin.scripting.compiler.plugin.KotlinScriptDefinitionAdapterFromNewAPIBase
+import org.jetbrains.kotlin.scripting.compiler.plugin.KotlinScriptDefinitionAdapterFromNewAPI
 import org.jetbrains.kotlin.utils.PathUtil
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import org.jetbrains.kotlin.utils.addToStdlib.flattenTo
@@ -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.ScriptingEnvironmentProperties
-import kotlin.script.experimental.definitions.ScriptDefinitionFromAnnotatedBaseClass
+import kotlin.script.experimental.definitions.createScriptDefinitionFromAnnotatedBaseClass
 import kotlin.script.experimental.dependencies.DependenciesResolver
 import kotlin.script.experimental.dependencies.ScriptDependencies
 import kotlin.script.experimental.dependencies.asSuccess
@@ -213,7 +213,7 @@ fun loadDefinitionsFromTemplates(
                         ScriptingEnvironmentProperties.getScriptingClass to JvmGetScriptingClass()
                     )
                     KotlinScriptDefinitionAdapterFromNewAPI(
-                        ScriptDefinitionFromAnnotatedBaseClass(KotlinType(template), hostEnvironment),
+                        createScriptDefinitionFromAnnotatedBaseClass(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

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.script.examples.jvm.resolve.maven.host
 import org.jetbrains.kotlin.script.examples.jvm.resolve.maven.MyScriptWithMavenDeps
 import java.io.File
 import kotlin.script.experimental.api.*
-import kotlin.script.experimental.definitions.ScriptDefinitionFromAnnotatedBaseClass
+import kotlin.script.experimental.definitions.createScriptDefinitionFromAnnotatedBaseClass
 import kotlin.script.experimental.host.toScriptSource
 import kotlin.script.experimental.jvm.DummyCompiledJvmScriptCache
 import kotlin.script.experimental.jvm.JvmBasicScriptingHost
@@ -23,7 +23,7 @@ fun evalFile(scriptFile: File): ResultWithDiagnostics<EvaluationResult> {
         ScriptingEnvironmentProperties.getScriptingClass(JvmGetScriptingClass())
     )
     val scriptCompiler = JvmScriptCompiler(KJVMCompilerImpl(environment), DummyCompiledJvmScriptCache())
-    val scriptDefinition = ScriptDefinitionFromAnnotatedBaseClass(
+    val scriptDefinition = createScriptDefinitionFromAnnotatedBaseClass(
         KotlinType(MyScriptWithMavenDeps::class),
         environment
     )

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

@@ -6,15 +6,15 @@
 package org.jetbrains.kotlin.script.examples.jvm.simple.host
 
 import org.jetbrains.kotlin.script.examples.jvm.simple.MyScript
-import org.jetbrains.kotlin.script.util.*
+import org.jetbrains.kotlin.script.util.scriptCompilationClasspathFromContext
 import java.io.File
 import kotlin.script.experimental.api.*
-import kotlin.script.experimental.definitions.ScriptDefinitionFromAnnotatedBaseClass
+import kotlin.script.experimental.definitions.createScriptDefinitionFromAnnotatedBaseClass
 import kotlin.script.experimental.host.toScriptSource
 import kotlin.script.experimental.jvm.*
 import kotlin.script.experimental.jvm.runners.BasicJvmScriptEvaluator
 import kotlin.script.experimental.jvmhost.impl.KJVMCompilerImpl
-import kotlin.script.experimental.misc.*
+import kotlin.script.experimental.misc.invoke
 
 val myJvmConfigParams = jvmJavaHomeParams + with(ScriptCompileConfigurationProperties) {
     listOf(
@@ -27,7 +27,7 @@ fun evalFile(scriptFile: File): ResultWithDiagnostics<EvaluationResult> {
         ScriptingEnvironmentProperties.getScriptingClass(JvmGetScriptingClass())
     )
     val scriptCompiler = JvmScriptCompiler(KJVMCompilerImpl(environment), DummyCompiledJvmScriptCache())
-    val scriptDefinition = ScriptDefinitionFromAnnotatedBaseClass(
+    val scriptDefinition = createScriptDefinitionFromAnnotatedBaseClass(
         KotlinType(MyScript::class),
         environment
     )

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

@@ -13,8 +13,6 @@
 package kotlin.script.experimental.annotations
 
 import kotlin.reflect.KClass
-import kotlin.script.experimental.api.ScriptDefinition
-import kotlin.script.experimental.definitions.ScriptDefinitionFromAnnotatedBaseClass
 
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
@@ -22,12 +20,6 @@ annotation class KotlinScript(
     val name: String = "Kotlin script"
 )
 
-@Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-annotation class KotlinScriptDefinition(
-    val definition: KClass<out ScriptDefinition> = ScriptDefinitionFromAnnotatedBaseClass::class
-)
-
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
 annotation class KotlinScriptFileExtension(

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

@@ -7,18 +7,10 @@
 
 package kotlin.script.experimental.api
 
-import kotlin.reflect.KClass
 import kotlin.script.experimental.util.ChainedPropertyBag
 import kotlin.script.experimental.util.typedKey
 
-typealias ScriptDefinitionPropertiesBag = ChainedPropertyBag
+typealias ScriptDefinition = ChainedPropertyBag
-
-interface ScriptDefinition {
-
-    // constructor(environment: ScriptingEnvironment) // the constructor is expected from implementations
-
-    val properties: ScriptDefinitionPropertiesBag
-}
 
 object ScriptDefinitionProperties {
 

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

@@ -8,10 +8,8 @@ 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.KotlinScript
 import kotlin.script.experimental.annotations.KotlinScriptDefaultCompilationConfiguration
-import kotlin.script.experimental.annotations.KotlinScriptDefinition
 import kotlin.script.experimental.annotations.KotlinScriptFileExtension
 import kotlin.script.experimental.api.*
 import kotlin.script.experimental.util.TypedKey
@@ -21,65 +19,44 @@ 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(
+fun createScriptDefinitionFromAnnotatedBaseClass(
-    protected val baseClassType: KotlinType,
+    baseClassType: KotlinType,
-    val environment: ScriptingEnvironment
+    environment: ScriptingEnvironment,
-) : ScriptDefinition {
+    contextClass: KClass<*> = ScriptDefinition::class
+): ScriptDefinition {
 
-    private val getScriptingClass = environment.getOrNull(ScriptingEnvironmentProperties.getScriptingClass)
+    val getScriptingClass = environment.getOrNull(ScriptingEnvironmentProperties.getScriptingClass)
         ?: throw IllegalArgumentException("${ERROR_MSG_PREFIX}Expecting 'getScriptingClass' parameter in the scripting environment")
 
-    private val baseClass: KClass<*> =
+    val baseClass: KClass<*> =
         try {
-            getScriptingClass(baseClassType, this::class, environment)
+            getScriptingClass(baseClassType, contextClass, environment)
         } catch (e: Throwable) {
             throw IllegalArgumentException("${ERROR_MSG_PREFIX}Unable to load base class $baseClassType", e)
         }
 
-    private val mainAnnotation = baseClass.findAnnotation<KotlinScript>()
+    val mainAnnotation = baseClass.findAnnotation<KotlinScript>()
         ?: throw IllegalArgumentException("${ERROR_MSG_PREFIX}Expecting KotlinScript annotation on the $baseClass")
 
-    private val explicitDefinition: ScriptDefinition? =
+    val propertiesData = hashMapOf<TypedKey<*>, Any?>(ScriptDefinitionProperties.baseClass to baseClassType)
-        baseClass.findAnnotation<KotlinScriptDefinition>()?.definition.takeIf { it != this::class }?.let { it.instantiateScriptHandler() }
+    baseClass.findAnnotation<KotlinScriptFileExtension>()?.let {
-
+        propertiesData[ScriptDefinitionProperties.fileExtension] = it.extension
-    override val properties = run {
+    }
-        val baseProperties = explicitDefinition?.properties
+    propertiesData += ScriptDefinitionProperties.name to mainAnnotation.name
-        val propertiesData = hashMapOf<TypedKey<*>, Any?>(ScriptDefinitionProperties.baseClass to baseClassType)
+    baseClass.annotations.filterIsInstance(KotlinScriptDefaultCompilationConfiguration::class.java).forEach { ann ->
-        baseClass.findAnnotation<KotlinScriptFileExtension>()?.let {
+        val params = try {
-            propertiesData[ScriptDefinitionProperties.fileExtension] = it.extension
+            ann.compilationConfiguration.objectInstance ?: ann.compilationConfiguration.createInstance()
+        } catch (e: Throwable) {
+            throw IllegalArgumentException(ILLEGAL_CONFIG_ANN_ARG, e)
         }
-        if (baseProperties?.getOrNull(ScriptDefinitionProperties.name) == null) {
+        params.forEach { param ->
-            propertiesData += ScriptDefinitionProperties.name to mainAnnotation.name
+            if (param !is Pair<*, *> || param.first !is TypedKey<*>)
-        }
+                throw IllegalArgumentException("$ILLEGAL_CONFIG_ANN_ARG: invalid parameter $param")
-        baseClass.annotations.filterIsInstance(KotlinScriptDefaultCompilationConfiguration::class.java).forEach { ann ->
+            (param as Pair<TypedKey<*>, Any?>).let { (k, v) ->
-            val params = try {
+                propertiesData[k] = v
-                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")
-                (param as Pair<TypedKey<*>, Any?>).let { (k, v) ->
-                    propertiesData[k] = v
-                }
             }
         }
-        ScriptingEnvironment.createOptimized(baseProperties, propertiesData)
-    }
-
-    private fun <T : Any> KClass<T>.instantiateScriptHandler(): T {
-        val klass: KClass<T> = try {
-            getScriptingClass(KotlinType(this), this@ScriptDefinitionFromAnnotatedBaseClass::class, environment) as KClass<T>
-        } catch (e: Throwable) {
-            throw IllegalArgumentException("${ERROR_MSG_PREFIX}Unable to load handler $this: $e", e)
-        }
-        try {
-            // TODO: fix call after deciding on constructor parameters
-            return klass.objectInstance ?: klass.primaryConstructor!!.call(properties)
-        } catch (e: Throwable) {
-            throw IllegalArgumentException("${ERROR_MSG_PREFIX}Unable to instantiate handler $this: $e", e)
-        }
     }
+    return ScriptingEnvironment.createOptimized(null, propertiesData)
 }
 

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

@@ -85,7 +85,7 @@ class KJVMCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJVMCompiler
         try {
             setIdeaIoUseFallback()
 
-            val scriptCompileConfiguration = chainPropertyBags(additionalConfiguration, scriptDefinition.properties)
+            val scriptCompileConfiguration = chainPropertyBags(additionalConfiguration, scriptDefinition)
             var environment: KotlinCoreEnvironment? = null
             var updatedScriptCompileConfiguration = scriptCompileConfiguration
 
@@ -243,7 +243,7 @@ internal class BridgeScriptDefinition(
     updateClasspath: (List<File>) -> Unit
 ) : KotlinScriptDefinition(
     hostEnvironment.getScriptingClass(
-        scriptDefinition.properties[ScriptDefinitionProperties.baseClass],
+        scriptDefinition[ScriptDefinitionProperties.baseClass],
         BridgeScriptDefinition::class
     )
 ) {

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

@@ -37,7 +37,7 @@ class BridgeDependenciesResolver(
             val processedScriptData =
                 ProcessedScriptData(ProcessedScriptDataProperties.foundAnnotations to scriptContents.annotations)
 
-            val refineFn = scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.refineConfiguration)
+            val refineFn = scriptDefinition.getOrNull(ScriptCompileConfigurationProperties.refineConfiguration)
             val refinedConfiguration =
                 if (refineFn == null) calculatedBaseScriptCompilerConfiguration
                 else {

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

@@ -20,7 +20,7 @@ open class JvmScriptCompiler(
         scriptDefinition: ScriptDefinition,
         additionalConfiguration: ScriptCompileConfiguration?
     ): ResultWithDiagnostics<CompiledScript<*>> {
-        val baseConfiguration = chainPropertyBags(additionalConfiguration, scriptDefinition.properties)
+        val baseConfiguration = chainPropertyBags(additionalConfiguration, scriptDefinition)
         val refineConfigurationFn = baseConfiguration.getOrNull(ScriptCompileConfigurationProperties.refineConfiguration)
         val refinedConfiguration =
             if (baseConfiguration.getOrNull(ScriptCompileConfigurationProperties.refineBeforeParsing) == true) {

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

@@ -29,13 +29,13 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
     abstract val scriptFileExtensionWithDot: String
 
     open val baseClass: KClass<*> by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        getScriptingClass(scriptDefinition.properties[ScriptDefinitionProperties.baseClass])
+        getScriptingClass(scriptDefinition[ScriptDefinitionProperties.baseClass])
     }
 
     override val template: KClass<*> get() = baseClass
 
     override val name: String
-        get() = scriptDefinition.properties.getOrNull(ScriptDefinitionProperties.name) ?: "Kotlin Script"
+        get() = scriptDefinition.getOrNull(ScriptDefinitionProperties.name) ?: "Kotlin Script"
 
     override val fileType: LanguageFileType = KotlinFileType.INSTANCE
 
@@ -51,28 +51,28 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
         get() = emptyList()
 
     override val dependencyResolver: DependenciesResolver by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        BridgeDependenciesResolver(scriptDefinition, scriptDefinition.properties)
+        BridgeDependenciesResolver(scriptDefinition, scriptDefinition)
     }
 
     override val acceptedAnnotations: List<KClass<out Annotation>> by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.refineConfigurationOnAnnotations)
+        scriptDefinition.getOrNull(ScriptCompileConfigurationProperties.refineConfigurationOnAnnotations)
             .orEmpty()
             .map { getScriptingClass(it) as KClass<out Annotation> }
     }
 
     override val implicitReceivers: List<KType> by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.scriptImplicitReceivers)
+        scriptDefinition.getOrNull(ScriptCompileConfigurationProperties.scriptImplicitReceivers)
             .orEmpty()
             .map { getScriptingClass(it).starProjectedType }
     }
 
     override val environmentVariables: List<Pair<String, KType>> by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.contextVariables)
+        scriptDefinition.getOrNull(ScriptCompileConfigurationProperties.contextVariables)
             ?.map { (k, v) -> k to getScriptingClass(v).starProjectedType }.orEmpty()
     }
 
     override val additionalCompilerArguments: List<String>
-        get() = scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.compilerOptions)
+        get() = scriptDefinition.getOrNull(ScriptCompileConfigurationProperties.compilerOptions)
             .orEmpty()
 
     override val scriptExpectedLocations: List<ScriptExpectedLocation> =
@@ -82,11 +82,11 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
         )
 
     override val targetClassAnnotations: List<Annotation>
-        get() = scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.generatedClassAnnotations)
+        get() = scriptDefinition.getOrNull(ScriptCompileConfigurationProperties.generatedClassAnnotations)
             .orEmpty()
 
     override val targetMethodAnnotations: List<Annotation>
-        get() = scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.generatedMethodAnnotations)
+        get() = scriptDefinition.getOrNull(ScriptCompileConfigurationProperties.generatedMethodAnnotations)
             .orEmpty()
 
     private val scriptingClassGetter by lazy(LazyThreadSafetyMode.PUBLICATION) {
@@ -98,7 +98,7 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
         scriptingClassGetter(
             type,
             KotlinScriptDefinition::class, // Assuming that the KotlinScriptDefinition class is loaded in the proper classloader
-            scriptDefinition.properties
+            scriptDefinition
         )
 }
 
@@ -108,8 +108,8 @@ class KotlinScriptDefinitionAdapterFromNewAPI(
     override val hostEnvironment: ScriptingEnvironment
 ) : KotlinScriptDefinitionAdapterFromNewAPIBase() {
 
-    override val name: String get() = scriptDefinition.properties.getOrNull(ScriptDefinitionProperties.name) ?: super.name
+    override val name: String get() = scriptDefinition.getOrNull(ScriptDefinitionProperties.name) ?: super.name
 
     override val scriptFileExtensionWithDot =
-        "." + (scriptDefinition.properties.getOrNull(ScriptDefinitionProperties.fileExtension) ?: "kts")
+        "." + (scriptDefinition.getOrNull(ScriptDefinitionProperties.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.ScriptDefinitionFromAnnotatedBaseClass
+import kotlin.script.experimental.definitions.createScriptDefinitionFromAnnotatedBaseClass
 import kotlin.script.experimental.jvm.JvmDependency
 import kotlin.script.experimental.jvm.JvmGetScriptingClass
 
@@ -47,7 +47,11 @@ class LazyScriptDefinitionFromDiscoveredClass internal constructor(
             "Configure scripting: loading script definition class $className using classpath $classpath\n.  ${Thread.currentThread().stackTrace}"
         )
         try {
-            ScriptDefinitionFromAnnotatedBaseClass(KotlinType(className), hostEnvironment)
+            createScriptDefinitionFromAnnotatedBaseClass(
+                KotlinType(className),
+                hostEnvironment,
+                LazyScriptDefinitionFromDiscoveredClass::class
+            )
         } catch (ex: ClassNotFoundException) {
             messageCollector.report(CompilerMessageSeverity.ERROR, "Cannot find script definition class $className")
             InvalidScriptDefinition
@@ -62,19 +66,16 @@ class LazyScriptDefinitionFromDiscoveredClass internal constructor(
 
     override val scriptFileExtensionWithDot: String by lazy(LazyThreadSafetyMode.PUBLICATION) {
         val ext = annotationsFromAsm.find { it.name == KotlinScriptFileExtension::class.simpleName!! }?.args?.first()
-                ?: scriptDefinition.properties.let {
+            ?: scriptDefinition.let {
-                    it.getOrNull(ScriptDefinitionProperties.fileExtension) ?: "kts"
+                it.getOrNull(ScriptDefinitionProperties.fileExtension) ?: "kts"
-                }
+            }
         ".$ext"
     }
 
     override val name: String by lazy(LazyThreadSafetyMode.PUBLICATION) {
         annotationsFromAsm.find { it.name == KotlinScript::class.simpleName!! }?.args?.first()
-                ?: super.name
+            ?: super.name
     }
 }
 
-object InvalidScriptDefinition : ScriptDefinition {
+object InvalidScriptDefinition : ScriptDefinition()
-    override val properties: ScriptDefinitionPropertiesBag = ScriptDefinitionPropertiesBag()
-}
-

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

@@ -20,7 +20,7 @@ import kotlin.script.experimental.annotations.KotlinScript
 import kotlin.script.experimental.api.KotlinType
 import kotlin.script.experimental.api.ScriptingEnvironment
 import kotlin.script.experimental.api.ScriptingEnvironmentProperties
-import kotlin.script.experimental.definitions.ScriptDefinitionFromAnnotatedBaseClass
+import kotlin.script.experimental.definitions.createScriptDefinitionFromAnnotatedBaseClass
 import kotlin.script.experimental.jvm.JvmGetScriptingClass
 import kotlin.script.templates.ScriptTemplateDefinition
 
@@ -278,9 +278,10 @@ private fun loadScriptDefinition(
                     ScriptingEnvironmentProperties.getScriptingClass to JvmGetScriptingClass()
                 )
                 KotlinScriptDefinitionAdapterFromNewAPI(
-                    ScriptDefinitionFromAnnotatedBaseClass(
+                    createScriptDefinitionFromAnnotatedBaseClass(
                         KotlinType(cls.kotlin),
-                        environment
+                        environment,
+                        KotlinScriptDefinition::class
                     ),
                     environment
                 )