Make script definition a property bag directly

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
-
-interface ScriptDefinition {
-
-    // constructor(environment: ScriptingEnvironment) // the constructor is expected from implementations
-
-    val properties: ScriptDefinitionPropertiesBag
-}
+typealias ScriptDefinition = ChainedPropertyBag
 
 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(
-    protected val baseClassType: KotlinType,
-    val environment: ScriptingEnvironment
-) : ScriptDefinition {
+fun createScriptDefinitionFromAnnotatedBaseClass(
+    baseClassType: KotlinType,
+    environment: ScriptingEnvironment,
+    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? =
-        baseClass.findAnnotation<KotlinScriptDefinition>()?.definition.takeIf { it != this::class }?.let { it.instantiateScriptHandler() }
-
-    override val properties = run {
-        val baseProperties = explicitDefinition?.properties
-        val propertiesData = hashMapOf<TypedKey<*>, Any?>(ScriptDefinitionProperties.baseClass to baseClassType)
-        baseClass.findAnnotation<KotlinScriptFileExtension>()?.let {
-            propertiesData[ScriptDefinitionProperties.fileExtension] = it.extension
+    val propertiesData = hashMapOf<TypedKey<*>, Any?>(ScriptDefinitionProperties.baseClass to baseClassType)
+    baseClass.findAnnotation<KotlinScriptFileExtension>()?.let {
+        propertiesData[ScriptDefinitionProperties.fileExtension] = it.extension
+    }
+    propertiesData += ScriptDefinitionProperties.name to mainAnnotation.name
+    baseClass.annotations.filterIsInstance(KotlinScriptDefaultCompilationConfiguration::class.java).forEach { ann ->
+        val params = try {
+            ann.compilationConfiguration.objectInstance ?: ann.compilationConfiguration.createInstance()
+        } catch (e: Throwable) {
+            throw IllegalArgumentException(ILLEGAL_CONFIG_ANN_ARG, e)
         }
-        if (baseProperties?.getOrNull(ScriptDefinitionProperties.name) == null) {
-            propertiesData += ScriptDefinitionProperties.name to mainAnnotation.name
-        }
-        baseClass.annotations.filterIsInstance(KotlinScriptDefaultCompilationConfiguration::class.java).forEach { ann ->
-            val params = try {
-                ann.compilationConfiguration.objectInstance ?: ann.compilationConfiguration.createInstance()
-            } catch (e: Throwable) {
-                throw IllegalArgumentException(ILLEGAL_CONFIG_ANN_ARG, e)
-            }
-            params.forEach { param ->
-                if (param !is Pair<*, *> || param.first !is TypedKey<*>)
-                    throw IllegalArgumentException("$ILLEGAL_CONFIG_ANN_ARG: invalid parameter $param")
-                (param as Pair<TypedKey<*>, Any?>).let { (k, v) ->
-                    propertiesData[k] = v
-                }
+        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)
 }