Make script definition a property bag directly

2018-07-15 22:56:02 +02:00
parent 8953bba47c
commit 904917c194
12 changed files with 66 additions and 103 deletions
@@ -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
                    )
                }
@@ -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
    )
@@ -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
    )
@@ -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(
@@ -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 {

@@ -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)
 }

@@ -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
    )
 ) {
@@ -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 {
@@ -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) {
@@ -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")
 }
@@ -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 {
-                    it.getOrNull(ScriptDefinitionProperties.fileExtension) ?: "kts"
-                }
+            ?: scriptDefinition.let {
+                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 {
-    override val properties: ScriptDefinitionPropertiesBag = ScriptDefinitionPropertiesBag()
-}
-
+object InvalidScriptDefinition : ScriptDefinition()
@@ -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
                )