Refactor properties

compiler/tests/org/jetbrains/kotlin/codegen/AbstractCustomScriptCodegenTest.kt

@@ -21,9 +21,9 @@ import org.jetbrains.kotlin.utils.PathUtil.KOTLIN_SCRIPTING_MISC_JAR
 import org.junit.Assert
 import java.io.File
 import kotlin.script.experimental.annotations.KotlinScript
-import kotlin.script.experimental.annotations.KotlinScriptDefaultCompilationConfiguration
+import kotlin.script.experimental.annotations.KotlinScriptPropertiesFromList
 import kotlin.script.experimental.api.KotlinType
-import kotlin.script.experimental.api.ScriptCompileConfigurationProperties
+import kotlin.script.experimental.api.ScriptDefinitionProperties
 import kotlin.script.experimental.util.TypedKey
 
 abstract class AbstractCustomScriptCodegenTest : CodegenTestCase() {
@@ -125,22 +125,22 @@ abstract class AbstractCustomScriptCodegenTest : CodegenTestCase() {
 
 object TestScriptWithReceiversConfiguration : ArrayList<Pair<TypedKey<*>, Any?>>(
     listOf(
-        ScriptCompileConfigurationProperties.scriptImplicitReceivers to listOf(KotlinType(String::class))
+        ScriptDefinitionProperties.scriptImplicitReceivers to listOf(KotlinType(String::class))
     )
 )
 
 @Suppress("unused")
 @KotlinScript
-@KotlinScriptDefaultCompilationConfiguration(TestScriptWithReceiversConfiguration::class)
+@KotlinScriptPropertiesFromList(TestScriptWithReceiversConfiguration::class)
 abstract class TestScriptWithReceivers
 
 object TestScriptWithSimpleEnvVarsConfiguration : ArrayList<Pair<TypedKey<*>, Any?>>(
     listOf(
-        ScriptCompileConfigurationProperties.contextVariables to mapOf("stringVar1" to KotlinType(String::class))
+        ScriptDefinitionProperties.contextVariables to mapOf("stringVar1" to KotlinType(String::class))
     )
 )
 
 @Suppress("unused")
 @KotlinScript
-@KotlinScriptDefaultCompilationConfiguration(TestScriptWithSimpleEnvVarsConfiguration::class)
+@KotlinScriptPropertiesFromList(TestScriptWithSimpleEnvVarsConfiguration::class)
 abstract class TestScriptWithSimpleEnvVars

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

@@ -13,8 +13,8 @@ import java.io.File
 import kotlin.script.dependencies.ScriptContents
 import kotlin.script.dependencies.ScriptDependenciesResolver
 import kotlin.script.experimental.annotations.KotlinScript
-import kotlin.script.experimental.annotations.KotlinScriptDefaultCompilationConfiguration
 import kotlin.script.experimental.annotations.KotlinScriptFileExtension
+import kotlin.script.experimental.annotations.KotlinScriptPropertiesFromList
 import kotlin.script.experimental.api.*
 import kotlin.script.experimental.jvm.JvmDependency
 import kotlin.script.experimental.jvm.jvmJavaHomeParams
@@ -25,13 +25,13 @@ import kotlin.script.experimental.util.TypedKey
 
 @KotlinScript
 @KotlinScriptFileExtension("scriptwithdeps.kts")
-@KotlinScriptDefaultCompilationConfiguration(MyConfiguration::class)
+@KotlinScriptPropertiesFromList(MyConfiguration::class)
 abstract class MyScriptWithMavenDeps {
 //    abstract fun body(vararg args: String): Int
 }
 
 object MyConfiguration : ArrayList<Pair<TypedKey<*>, Any?>>(
-    jvmJavaHomeParams + with(ScriptCompileConfigurationProperties) {
+    jvmJavaHomeParams + with(ScriptDefinitionProperties) {
         listOf(
             defaultImports(DependsOn::class.qualifiedName!!, Repository::class.qualifiedName!!),
             dependencies(
@@ -75,8 +75,8 @@ class MyConfigurator : RefineScriptCompilationConfiguration {
                 ?: return configuration.asSuccess(diagnostics)
             val newDependency = JvmDependency(resolvedClasspath)
             val updatedDeps =
-                configuration.getOrNull(ScriptCompileConfigurationProperties.dependencies)?.plus(newDependency) ?: listOf(newDependency)
+                configuration.getOrNull(ScriptDefinitionProperties.dependencies)?.plus(newDependency) ?: listOf(newDependency)
-            ScriptCompileConfiguration(configuration, ScriptCompileConfigurationProperties.dependencies(updatedDeps)).asSuccess(diagnostics)
+            ScriptCompileConfiguration(configuration, ScriptDefinitionProperties.dependencies(updatedDeps)).asSuccess(diagnostics)
         } catch (e: Throwable) {
             ResultWithDiagnostics.Failure(*diagnostics.toTypedArray(), e.asDiagnostics())
         }

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

@@ -16,7 +16,7 @@ import kotlin.script.experimental.jvm.runners.BasicJvmScriptEvaluator
 import kotlin.script.experimental.jvmhost.impl.KJVMCompilerImpl
 import kotlin.script.experimental.misc.invoke
 
-val myJvmConfigParams = jvmJavaHomeParams + with(ScriptCompileConfigurationProperties) {
+val myJvmConfigParams = jvmJavaHomeParams + with(ScriptDefinitionProperties) {
     listOf(
         dependencies(JvmDependency(scriptCompilationClasspathFromContext("scripting-jvm-simple-script" /* script library jar name */)))
     )

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

@@ -28,6 +28,6 @@ annotation class KotlinScriptFileExtension(
 
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
-annotation class KotlinScriptDefaultCompilationConfiguration(
+annotation class KotlinScriptPropertiesFromList(
-    val compilationConfiguration: KClass<out List<*>> // object or class filled in 0-ary constructor
+    val definitionProperties: KClass<out List<*>> // object or class filled in 0-ary constructor
 )

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

@@ -1,17 +0,0 @@
-/*
- * Copyright 2000-2018 JetBrains s.r.o. 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.api
-
-import kotlin.script.experimental.util.typedKey
-
-object ProcessedScriptDataProperties {
-    val foundAnnotations by typedKey<List<Annotation>>()
-
-    val foundFragments by typedKey<List<ScriptSourceNamedFragment>>()
-}
-

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

@@ -8,12 +8,23 @@
 package kotlin.script.experimental.api
 
 import kotlin.script.experimental.util.ChainedPropertyBag
-
+import kotlin.script.experimental.util.typedKey
 
 typealias ScriptCompileConfiguration = ChainedPropertyBag
 
+object ScriptCompileConfigurationProperties {
+
+    val sourceFragments by typedKey<List<ScriptSourceNamedFragment>>()
+}
+
 typealias ProcessedScriptData = ChainedPropertyBag
 
+object ProcessedScriptDataProperties {
+    val foundAnnotations by typedKey<List<Annotation>>()
+
+    val foundFragments by typedKey<List<ScriptSourceNamedFragment>>()
+}
+
 interface RefineScriptCompilationConfiguration {
     suspend operator fun invoke(
         scriptSource: ScriptSource,

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

@@ -1,46 +0,0 @@
-/*
- * Copyright 2000-2018 JetBrains s.r.o. 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.api
-
-import kotlin.script.experimental.util.typedKey
-
-object ScriptCompileConfigurationProperties {
-
-    val sourceFragments by typedKey<List<ScriptSourceNamedFragment>>()
-
-    val baseClass = ScriptDefinitionProperties.baseClass
-
-    val scriptBodyTarget by typedKey<ScriptBodyTarget>()
-
-    val scriptImplicitReceivers by typedKey<List<KotlinType>>() // in the order from outer to inner scope
-
-    val contextVariables by typedKey<Map<String, KotlinType>>() // external variables
-
-    val defaultImports by typedKey<List<String>>()
-
-    val restrictions by typedKey<List<ResolvingRestrictionRule>>()
-
-    val importedScripts by typedKey<List<ScriptSource>>()
-
-    val dependencies by typedKey<List<ScriptDependency>>()
-
-    val generatedClassAnnotations by typedKey<List<Annotation>>()
-
-    val generatedMethodAnnotations by typedKey<List<Annotation>>()
-
-    val compilerOptions by typedKey<List<String>>() // Q: CommonCompilerOptions instead?
-
-    val refineConfiguration by typedKey<RefineScriptCompilationConfiguration>() // dynamic configurator
-
-    val refineBeforeParsing by typedKey<Boolean>() // default: false
-
-    val refineConfigurationOnAnnotations by typedKey<List<KotlinType>>()
-
-    val refineConfigurationOnSections by typedKey<List<String>>()
-}
-

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

@@ -19,5 +19,33 @@ object ScriptDefinitionProperties {
     val fileExtension by typedKey<String>() // default: "kts"
 
     val baseClass by typedKey<KotlinType>() // script base class
+
+    val scriptBodyTarget by typedKey<ScriptBodyTarget>()
+
+    val scriptImplicitReceivers by typedKey<List<KotlinType>>() // in the order from outer to inner scope
+
+    val contextVariables by typedKey<Map<String, KotlinType>>() // external variables
+
+    val defaultImports by typedKey<List<String>>()
+
+    val restrictions by typedKey<List<ResolvingRestrictionRule>>()
+
+    val importedScripts by typedKey<List<ScriptSource>>()
+
+    val dependencies by typedKey<List<ScriptDependency>>()
+
+    val generatedClassAnnotations by typedKey<List<Annotation>>()
+
+    val generatedMethodAnnotations by typedKey<List<Annotation>>()
+
+    val compilerOptions by typedKey<List<String>>() // Q: CommonCompilerOptions instead?
+
+    val refineConfiguration by typedKey<RefineScriptCompilationConfiguration>() // dynamic configurator
+
+    val refineBeforeParsing by typedKey<Boolean>() // default: false
+
+    val refineConfigurationOnAnnotations by typedKey<List<KotlinType>>()
+
+    val refineConfigurationOnSections by typedKey<List<String>>()
 }
 

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

@@ -9,8 +9,8 @@ import kotlin.reflect.KClass
 import kotlin.reflect.full.createInstance
 import kotlin.reflect.full.findAnnotation
 import kotlin.script.experimental.annotations.KotlinScript
-import kotlin.script.experimental.annotations.KotlinScriptDefaultCompilationConfiguration
 import kotlin.script.experimental.annotations.KotlinScriptFileExtension
+import kotlin.script.experimental.annotations.KotlinScriptPropertiesFromList
 import kotlin.script.experimental.api.*
 import kotlin.script.experimental.util.TypedKey
 
@@ -43,9 +43,9 @@ fun createScriptDefinitionFromAnnotatedBaseClass(
         propertiesData[ScriptDefinitionProperties.fileExtension] = it.extension
     }
     propertiesData += ScriptDefinitionProperties.name to mainAnnotation.name
-    baseClass.annotations.filterIsInstance(KotlinScriptDefaultCompilationConfiguration::class.java).forEach { ann ->
+    baseClass.annotations.filterIsInstance(KotlinScriptPropertiesFromList::class.java).forEach { ann ->
         val params = try {
-            ann.compilationConfiguration.objectInstance ?: ann.compilationConfiguration.createInstance()
+            ann.definitionProperties.objectInstance ?: ann.definitionProperties.createInstance()
         } catch (e: Throwable) {
             throw IllegalArgumentException(ILLEGAL_CONFIG_ANN_ARG, e)
         }

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

@@ -54,7 +54,7 @@ class KJVMCompiledScript<out ScriptBase : Any>(
 
     override suspend fun instantiate(scriptEvaluationEnvironment: ScriptEvaluationEnvironment): ResultWithDiagnostics<ScriptBase> = try {
         val baseClassLoader = scriptEvaluationEnvironment.getOrNull(JvmScriptEvaluationEnvironmentProperties.baseClassLoader)
-        val dependencies = configuration.getOrNull(ScriptCompileConfigurationProperties.dependencies)
+        val dependencies = configuration.getOrNull(ScriptDefinitionProperties.dependencies)
             ?.flatMap { (it as? JvmDependency)?.classpath?.map { it.toURI().toURL() } ?: emptyList() }
         // TODO: previous dependencies and classloaders should be taken into account here
         val classLoaderWithDeps =
@@ -91,12 +91,12 @@ class KJVMCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJVMCompiler
 
             fun updateClasspath(classpath: List<File>) {
                 environment!!.updateClasspath(classpath.map(::JvmClasspathRoot))
-                val updatedDeps = updatedScriptCompileConfiguration.getOrNull(ScriptCompileConfigurationProperties.dependencies)?.plus(
+                val updatedDeps = updatedScriptCompileConfiguration.getOrNull(ScriptDefinitionProperties.dependencies)?.plus(
                     JvmDependency(classpath)
                 ) ?: listOf(JvmDependency(classpath))
                 updatedScriptCompileConfiguration = ScriptCompileConfiguration(
                     updatedScriptCompileConfiguration,
-                    ScriptCompileConfigurationProperties.dependencies to updatedDeps
+                    ScriptDefinitionProperties.dependencies to updatedDeps
                 )
             }
 
@@ -115,7 +115,7 @@ class KJVMCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJVMCompiler
                     isModularJava = CoreJrtFileSystem.isModularJdk(it)
                 }
 
-                scriptCompileConfiguration.getOrNull(ScriptCompileConfigurationProperties.dependencies)?.let {
+                scriptCompileConfiguration.getOrNull(ScriptDefinitionProperties.dependencies)?.let {
                     addJvmClasspathRoots(
                         it.flatMap {
                             (it as JvmDependency).classpath
@@ -249,7 +249,7 @@ internal class BridgeScriptDefinition(
 ) {
     override val acceptedAnnotations = run {
         val cl = this::class.java.classLoader
-        calculatedScriptCompilerConfiguration.getOrNull(ScriptCompileConfigurationProperties.refineConfigurationOnAnnotations)
+        calculatedScriptCompilerConfiguration.getOrNull(ScriptDefinitionProperties.refineConfigurationOnAnnotations)
             ?.map { (cl.loadClass(it.typeName) as Class<out Annotation>).kotlin }
             ?: emptyList()
     }

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.getOrNull(ScriptCompileConfigurationProperties.refineConfiguration)
+            val refineFn = scriptDefinition.getOrNull(ScriptDefinitionProperties.refineConfiguration)
             val refinedConfiguration =
                 if (refineFn == null) calculatedBaseScriptCompilerConfiguration
                 else {
@@ -52,10 +52,10 @@ class BridgeDependenciesResolver(
                     }
                 }
 
-            val newClasspath = refinedConfiguration.getOrNull(ScriptCompileConfigurationProperties.dependencies)
+            val newClasspath = refinedConfiguration.getOrNull(ScriptDefinitionProperties.dependencies)
                 ?.flatMap { (it as JvmDependency).classpath } ?: emptyList()
             if (refinedConfiguration != calculatedBaseScriptCompilerConfiguration) {
-                val oldClasspath = calculatedBaseScriptCompilerConfiguration.getOrNull(ScriptCompileConfigurationProperties.dependencies)
+                val oldClasspath = calculatedBaseScriptCompilerConfiguration.getOrNull(ScriptDefinitionProperties.dependencies)
                     ?.flatMap { (it as JvmDependency).classpath } ?: emptyList()
                 if (newClasspath != oldClasspath) {
                     onClasspathUpdated(newClasspath)
@@ -64,7 +64,7 @@ class BridgeDependenciesResolver(
             DependenciesResolver.ResolveResult.Success(
                 ScriptDependencies(
                     classpath = newClasspath, // TODO: maybe it should return only increment from the initial config
-                    imports = refinedConfiguration.getOrNull(ScriptCompileConfigurationProperties.defaultImports)?.toList()
+                    imports = refinedConfiguration.getOrNull(ScriptDefinitionProperties.defaultImports)?.toList()
                             ?: emptyList()
                 ),
                 diagnostics

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

@@ -21,9 +21,9 @@ open class JvmScriptCompiler(
         additionalConfiguration: ScriptCompileConfiguration?
     ): ResultWithDiagnostics<CompiledScript<*>> {
         val baseConfiguration = chainPropertyBags(additionalConfiguration, scriptDefinition)
-        val refineConfigurationFn = baseConfiguration.getOrNull(ScriptCompileConfigurationProperties.refineConfiguration)
+        val refineConfigurationFn = baseConfiguration.getOrNull(ScriptDefinitionProperties.refineConfiguration)
         val refinedConfiguration =
-            if (baseConfiguration.getOrNull(ScriptCompileConfigurationProperties.refineBeforeParsing) == true) {
+            if (baseConfiguration.getOrNull(ScriptDefinitionProperties.refineBeforeParsing) == true) {
                 if (refineConfigurationFn == null) {
                     return ResultWithDiagnostics.Failure("Non-null configurator expected".asErrorDiagnostics())
                 }

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

@@ -55,24 +55,24 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
     }
 
     override val acceptedAnnotations: List<KClass<out Annotation>> by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        scriptDefinition.getOrNull(ScriptCompileConfigurationProperties.refineConfigurationOnAnnotations)
+        scriptDefinition.getOrNull(ScriptDefinitionProperties.refineConfigurationOnAnnotations)
             .orEmpty()
             .map { getScriptingClass(it) as KClass<out Annotation> }
     }
 
     override val implicitReceivers: List<KType> by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        scriptDefinition.getOrNull(ScriptCompileConfigurationProperties.scriptImplicitReceivers)
+        scriptDefinition.getOrNull(ScriptDefinitionProperties.scriptImplicitReceivers)
             .orEmpty()
             .map { getScriptingClass(it).starProjectedType }
     }
 
     override val environmentVariables: List<Pair<String, KType>> by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        scriptDefinition.getOrNull(ScriptCompileConfigurationProperties.contextVariables)
+        scriptDefinition.getOrNull(ScriptDefinitionProperties.contextVariables)
             ?.map { (k, v) -> k to getScriptingClass(v).starProjectedType }.orEmpty()
     }
 
     override val additionalCompilerArguments: List<String>
-        get() = scriptDefinition.getOrNull(ScriptCompileConfigurationProperties.compilerOptions)
+        get() = scriptDefinition.getOrNull(ScriptDefinitionProperties.compilerOptions)
             .orEmpty()
 
     override val scriptExpectedLocations: List<ScriptExpectedLocation> =
@@ -82,11 +82,11 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
         )
 
     override val targetClassAnnotations: List<Annotation>
-        get() = scriptDefinition.getOrNull(ScriptCompileConfigurationProperties.generatedClassAnnotations)
+        get() = scriptDefinition.getOrNull(ScriptDefinitionProperties.generatedClassAnnotations)
             .orEmpty()
 
     override val targetMethodAnnotations: List<Annotation>
-        get() = scriptDefinition.getOrNull(ScriptCompileConfigurationProperties.generatedMethodAnnotations)
+        get() = scriptDefinition.getOrNull(ScriptDefinitionProperties.generatedMethodAnnotations)
             .orEmpty()
 
     private val scriptingClassGetter by lazy(LazyThreadSafetyMode.PUBLICATION) {