azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace dedicated configurator with definition properties + refine fun

Browse Source
This commit is contained in:
Ilya Chernikov
2018-07-15 19:42:42 +02:00
parent a54675abe7
commit e61ba1fd70
15 changed files with 76 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libraries/examples/scripting/jvm-maven-deps/host/src/org/jetbrains/kotlin/script/examples/jvm/resolve/maven/host/host.kt
+2 -3
View File
@@ -6,7 +6,6 @@
package org.jetbrains.kotlin.script.examples.jvm.resolve.maven.host
import org.jetbrains.kotlin.script.examples.jvm.resolve.maven.MyScriptWithMavenDeps
import org.jetbrains.kotlin.script.examples.jvm.resolve.maven.myJvmConfigParams
import java.io.File
import kotlin.script.experimental.api.*
import kotlin.script.experimental.definitions.ScriptDefinitionFromAnnotatedBaseClass
@@ -16,7 +15,7 @@ import kotlin.script.experimental.jvm.JvmBasicScriptingHost
import kotlin.script.experimental.jvm.JvmGetScriptingClass
import kotlin.script.experimental.jvm.JvmScriptCompiler
import kotlin.script.experimental.jvmhost.impl.KJVMCompilerImpl
import kotlin.script.experimental.misc.*
import kotlin.script.experimental.misc.invoke
fun evalFile(scriptFile: File): ResultWithDiagnostics<EvaluationResult> {
val scriptCompiler = JvmScriptCompiler(KJVMCompilerImpl(), DummyCompiledJvmScriptCache())
@@ -30,7 +29,7 @@ fun evalFile(scriptFile: File): ResultWithDiagnostics<EvaluationResult> {
val host = JvmBasicScriptingHost(scriptCompiler, scriptDefinition.evaluator)
return host.eval(
scriptFile.toScriptSource(), scriptDefinition, ScriptCompileConfiguration(myJvmConfigParams), ScriptEvaluationEnvironment()
scriptFile.toScriptSource(), scriptDefinition, ScriptCompileConfiguration(), ScriptEvaluationEnvironment()
)
}
libraries/examples/scripting/jvm-maven-deps/script/src/org/jetbrains/kotlin/script/examples/jvm/resolve/maven/scriptDef.kt
+25 -23
View File
@@ -13,51 +13,53 @@ 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.KotlinScriptCompilationConfigurator
import kotlin.script.experimental.annotations.KotlinScriptDefaultCompilationConfiguration
import kotlin.script.experimental.annotations.KotlinScriptEvaluator
import kotlin.script.experimental.annotations.KotlinScriptFileExtension
import kotlin.script.experimental.api.*
import kotlin.script.experimental.jvm.*
import kotlin.script.experimental.jvm.runners.BasicJvmScriptEvaluator
import kotlin.script.experimental.misc.*
import kotlin.script.experimental.util.TypedKey
@KotlinScript
@KotlinScriptFileExtension("scriptwithdeps.kts")
@KotlinScriptCompilationConfigurator(MyConfigurator::class)
@KotlinScriptDefaultCompilationConfiguration(MyConfiguration::class)
@KotlinScriptEvaluator(BasicJvmScriptEvaluator::class)
abstract class MyScriptWithMavenDeps {
// abstract fun body(vararg args: String): Int
}
val myJvmConfigParams = jvmJavaHomeParams + with(ScriptCompileConfigurationProperties) {
listOf(
baseClass<MyScriptWithMavenDeps>(),
defaultImports(DependsOn::class.qualifiedName!!, Repository::class.qualifiedName!!),
dependencies(
JvmDependency(
scriptCompilationClasspathFromContext(
"scripting-jvm-maven-deps", // script library jar name
"kotlin-script-util" // DependsOn annotation is taken from script-util
object MyConfiguration : ArrayList<Pair<TypedKey<*>, Any?>>(
jvmJavaHomeParams + with(ScriptCompileConfigurationProperties) {
listOf(
baseClass<MyScriptWithMavenDeps>(),
defaultImports(DependsOn::class.qualifiedName!!, Repository::class.qualifiedName!!),
dependencies(
JvmDependency(
scriptCompilationClasspathFromContext(
"scripting-jvm-maven-deps", // script library jar name
"kotlin-script-util" // DependsOn annotation is taken from script-util
)
)
)
),
refineConfigurationOnAnnotations(DependsOn::class, Repository::class)
)
}
),
refineConfiguration(MyConfigurator()),
refineConfigurationOnAnnotations(DependsOn::class, Repository::class)
)
}
)
class MyConfigurator(val environment: ScriptingEnvironment) : ScriptCompilationConfigurator {
class MyConfigurator : RefineScriptCompilationConfiguration {
private val resolver = FilesAndMavenResolver()
override val defaultConfiguration = ScriptCompileConfiguration(environment, myJvmConfigParams)
override suspend fun refineConfiguration(
override suspend operator fun invoke(
scriptSource: ScriptSource,
configuration: ScriptCompileConfiguration,
processedScriptData: ProcessedScriptData
): ResultWithDiagnostics<ScriptCompileConfiguration> {
val annotations = processedScriptData.getOrNull(ProcessedScriptDataProperties.foundAnnotations)?.takeIf { it.isNotEmpty() }
?: return configuration.asSuccess()
?: return configuration.asSuccess()
val scriptContents = object : ScriptContents {
override val annotations: Iterable<Annotation> = annotations
override val file: File? = null
@@ -69,9 +71,9 @@ class MyConfigurator(val environment: ScriptingEnvironment) : ScriptCompilationC
}
return try {
val newDepsFromResolver = resolver.resolve(scriptContents, emptyMap(), ::report, null).get()
?: return configuration.asSuccess(diagnostics)
?: return configuration.asSuccess(diagnostics)
val resolvedClasspath = newDepsFromResolver.classpath.toList().takeIf { it.isNotEmpty() }
?: return configuration.asSuccess(diagnostics)
?: return configuration.asSuccess(diagnostics)
val newDependency = JvmDependency(resolvedClasspath)
val updatedDeps =
configuration.getOrNull(ScriptCompileConfigurationProperties.dependencies)?.plus(newDependency) ?: listOf(newDependency)
libraries/scripting/common/src/kotlin/script/experimental/annotations/scriptAnnotations.kt
-7
View File
@@ -13,7 +13,6 @@
package kotlin.script.experimental.annotations
import kotlin.reflect.KClass
import kotlin.script.experimental.api.ScriptCompilationConfigurator
import kotlin.script.experimental.api.ScriptDefinition
import kotlin.script.experimental.api.ScriptEvaluator
import kotlin.script.experimental.definitions.ScriptDefinitionFromAnnotatedBaseClass
@@ -36,12 +35,6 @@ annotation class KotlinScriptFileExtension(
val extension: String
)
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class KotlinScriptCompilationConfigurator(
val compilationConfigurator: KClass<out ScriptCompilationConfigurator>
)
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class KotlinScriptEvaluator(
libraries/scripting/common/src/kotlin/script/experimental/api/scriptConfiguration.kt
+3 -11
View File
@@ -14,18 +14,10 @@ typealias ScriptCompileConfiguration = ChainedPropertyBag
typealias ProcessedScriptData = ChainedPropertyBag
interface ScriptCompilationConfigurator {
// constructor(properties: ScriptDefinitionPropertiesBag) // the constructor is expected from implementations
val defaultConfiguration: ScriptCompileConfiguration
suspend fun refineConfiguration(
interface RefineScriptCompilationConfiguration {
suspend operator fun invoke(
scriptSource: ScriptSource,
configuration: ScriptCompileConfiguration,
processedScriptData: ProcessedScriptData = ProcessedScriptData()
): ResultWithDiagnostics<ScriptCompileConfiguration> =
configuration.cloneWithNewParent(defaultConfiguration).asSuccess()
): ResultWithDiagnostics<ScriptCompileConfiguration>
}
libraries/scripting/common/src/kotlin/script/experimental/api/scriptConfigurationProperties.kt
+2
View File
@@ -35,6 +35,8 @@ object ScriptCompileConfigurationProperties {
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>>()
libraries/scripting/common/src/kotlin/script/experimental/api/scriptDefinition.kt
-2
View File
@@ -19,8 +19,6 @@ interface ScriptDefinition {
val properties: ScriptDefinitionPropertiesBag
val compilationConfigurator: ScriptCompilationConfigurator?
val evaluator: ScriptEvaluator<*>?
}
libraries/scripting/common/src/kotlin/script/experimental/api/scriptingEnvironment.kt
+1 -1
View File
@@ -31,7 +31,7 @@ interface GetScriptingClass {
fun ScriptingEnvironment.getScriptingClass(type: KotlinType, contextClass: KClass<*>): KClass<*> {
val getClass = getOrNull(ScriptingEnvironmentProperties.getScriptingClass)
?: throw IllegalArgumentException("Expecting 'getScriptingClass' property in the scripting environment: unable to load scripting class $type")
?: throw IllegalArgumentException("Expecting 'getScriptingClass' property in the scripting environment: unable to load scripting class $type")
return getClass(type, contextClass, this)
}
libraries/scripting/common/src/kotlin/script/experimental/basic/basicScript.kt
-26
View File
@@ -5,33 +5,7 @@
package kotlin.script.experimental.basic
import kotlin.reflect.full.createInstance
import kotlin.script.experimental.annotations.KotlinScriptDefaultCompilationConfiguration
import kotlin.script.experimental.api.*
import kotlin.script.experimental.util.TypedKey
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 AnnotationsBasedCompilationConfigurator(val properties: ScriptDefinitionPropertiesBag) : ScriptCompilationConfigurator {
override val defaultConfiguration by lazy(LazyThreadSafetyMode.PUBLICATION) {
val baseClass = properties.getScriptBaseClass(this)
val cfg = baseClass.annotations.filterIsInstance(KotlinScriptDefaultCompilationConfiguration::class.java).flatMap { 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")
}
params as List<Pair<TypedKey<*>, Any?>>
}
ScriptCompileConfiguration(properties, cfg)
}
}
class DummyEvaluator<ScriptBase : Any>(val environment: ScriptingEnvironment) : ScriptEvaluator<ScriptBase> {
override suspend fun eval(
libraries/scripting/common/src/kotlin/script/experimental/definitions/definitionFromAnnotation.kt
+17 -7
View File
@@ -6,17 +6,20 @@
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.*
import kotlin.script.experimental.api.*
import kotlin.script.experimental.basic.AnnotationsBasedCompilationConfigurator
import kotlin.script.experimental.basic.DummyEvaluator
import kotlin.script.experimental.util.TypedKey
import kotlin.script.experimental.util.chainPropertyBags
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
@@ -40,21 +43,28 @@ open class ScriptDefinitionFromAnnotatedBaseClass(
override val properties = run {
val baseProperties = chainPropertyBags(explicitDefinition?.properties, environment)
val propertiesData = arrayListOf<Pair<TypedKey<*>, Any>>(ScriptDefinitionProperties.baseClass to baseClassType)
val propertiesData = arrayListOf<Pair<TypedKey<*>, Any?>>(ScriptDefinitionProperties.baseClass to baseClassType)
baseClass.findAnnotation<KotlinScriptFileExtension>()?.let {
propertiesData += ScriptDefinitionProperties.fileExtension to it.extension
}
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")
propertiesData.add(param as Pair<TypedKey<*>, Any?>)
}
}
ScriptingEnvironment(baseProperties, propertiesData)
}
override val compilationConfigurator =
baseClass.findAnnotation<KotlinScriptCompilationConfigurator>()?.compilationConfigurator?.instantiateScriptHandler()
?: explicitDefinition?.compilationConfigurator
?: AnnotationsBasedCompilationConfigurator::class.instantiateScriptHandler()
override val evaluator =
baseClass.findAnnotation<KotlinScriptEvaluator>()?.evaluator?.instantiateScriptHandler()
?: explicitDefinition?.evaluator
libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJVMCompilerImpl.kt
+1 -5
View File
@@ -85,11 +85,7 @@ class KJVMCompilerImpl : KJVMCompilerProxy {
try {
setIdeaIoUseFallback()
val scriptCompileConfiguration = chainPropertyBags(
additionalConfiguration,
scriptDefinition.compilationConfigurator?.defaultConfiguration,
scriptDefinition.properties
)
val scriptCompileConfiguration = chainPropertyBags(additionalConfiguration, scriptDefinition.properties)
var environment: KotlinCoreEnvironment? = null
var updatedScriptCompileConfiguration = scriptCompileConfiguration
libraries/scripting/jvm/src/kotlin/script/experimental/jvm/impl/BridgeDependenciesResolver.kt
+12 -13
View File
@@ -37,21 +37,20 @@ class BridgeDependenciesResolver(
val processedScriptData =
ProcessedScriptData(ProcessedScriptDataProperties.foundAnnotations to scriptContents.annotations)
val refinedConfiguration = scriptDefinition.compilationConfigurator?.let { scriptConfigurator ->
val res = scriptConfigurator.refineConfiguration(
scriptContents.toScriptSource(),
calculatedBaseScriptCompilerConfiguration,
processedScriptData
)
when (res) {
is ResultWithDiagnostics.Failure ->
return@resolveAsync DependenciesResolver.ResolveResult.Failure(res.reports.mapScriptReportsToDiagnostics())
is ResultWithDiagnostics.Success -> {
diagnostics.addAll(res.reports.mapScriptReportsToDiagnostics())
res.value
val refineFn = scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.refineConfiguration)
val refinedConfiguration =
if (refineFn == null) calculatedBaseScriptCompilerConfiguration
else {
val res = refineFn(scriptContents.toScriptSource(), calculatedBaseScriptCompilerConfiguration, processedScriptData)
when (res) {
is ResultWithDiagnostics.Failure ->
return@resolveAsync DependenciesResolver.ResolveResult.Failure(res.reports.mapScriptReportsToDiagnostics())
is ResultWithDiagnostics.Success -> {
diagnostics.addAll(res.reports.mapScriptReportsToDiagnostics())
res.value
}
}
}
} ?: calculatedBaseScriptCompilerConfiguration
val newClasspath = refinedConfiguration.getOrNull(ScriptCompileConfigurationProperties.dependencies)
?.flatMap { (it as JvmDependency).classpath } ?: emptyList()
libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptCompilation.kt
+5 -5
View File
@@ -8,6 +8,7 @@
package kotlin.script.experimental.jvm
import kotlin.script.experimental.api.*
import kotlin.script.experimental.util.chainPropertyBags
open class JvmScriptCompiler(
val compilerProxy: KJVMCompilerProxy,
@@ -19,15 +20,14 @@ open class JvmScriptCompiler(
scriptDefinition: ScriptDefinition,
additionalConfiguration: ScriptCompileConfiguration?
): ResultWithDiagnostics<CompiledScript<*>> {
val baseConfiguration = additionalConfiguration?.cloneWithNewParent(scriptDefinition.compilationConfigurator?.defaultConfiguration)
?: scriptDefinition.compilationConfigurator?.defaultConfiguration
?: ScriptCompileConfiguration()
val baseConfiguration = chainPropertyBags(additionalConfiguration, scriptDefinition.properties)
val refineConfigurationFn = baseConfiguration.getOrNull(ScriptCompileConfigurationProperties.refineConfiguration)
val refinedConfiguration =
if (baseConfiguration.getOrNull(ScriptCompileConfigurationProperties.refineBeforeParsing) == true) {
if (scriptDefinition.compilationConfigurator == null) {
if (refineConfigurationFn == null) {
return ResultWithDiagnostics.Failure("Non-null configurator expected".asErrorDiagnostics())
}
scriptDefinition.compilationConfigurator!!.refineConfiguration(script, baseConfiguration).let {
refineConfigurationFn(script, baseConfiguration).let {
when (it) {
is ResultWithDiagnostics.Failure -> return it
is ResultWithDiagnostics.Success -> it.value
libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptConfiguration.kt
-5
View File
@@ -5,13 +5,8 @@
package kotlin.script.experimental.jvm
import kotlinx.coroutines.experimental.runBlocking
import kotlin.script.experimental.api.*
import java.io.File
val jvmJavaHomeParams = with(JvmScriptCompileConfigurationProperties) {
listOf(javaHomeDir to File(System.getProperty("java.home")))
}
val ScriptCompilationConfigurator?.defaultConfiguration: ScriptCompileConfiguration
get() = this?.let { runBlocking { defaultConfiguration } } ?: ScriptCompileConfiguration()
plugins/scripting/scripting-cli/src/org/jetbrains/kotlin/scripting/compiler/plugin/KotlinScriptDefinitionAdapterFromNewAPI.kt
+8 -13
View File
@@ -18,7 +18,6 @@ import kotlin.script.experimental.api.*
import kotlin.script.experimental.dependencies.DependenciesResolver
import kotlin.script.experimental.jvm.impl.BridgeDependenciesResolver
import kotlin.script.experimental.location.ScriptExpectedLocation
import kotlin.script.experimental.util.chainPropertyBags
// temporary trick with passing Any as a template and overwriting it below, TODO: fix after introducing new script definitions hierarchy
abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinition(Any::class) {
@@ -27,12 +26,8 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
abstract val scriptFileExtensionWithDot: String
protected val baseCompilationConfiguration by lazy(LazyThreadSafetyMode.PUBLICATION) {
chainPropertyBags(scriptDefinition.compilationConfigurator?.defaultConfiguration, scriptDefinition.properties)
}
open val baseClass: KClass<*> by lazy(LazyThreadSafetyMode.PUBLICATION) {
getScriptingClass(baseCompilationConfiguration[ScriptDefinitionProperties.baseClass])
getScriptingClass(scriptDefinition.properties[ScriptDefinitionProperties.baseClass])
}
override val template: KClass<*> get() = baseClass
@@ -54,28 +49,28 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
get() = emptyList()
override val dependencyResolver: DependenciesResolver by lazy(LazyThreadSafetyMode.PUBLICATION) {
BridgeDependenciesResolver(scriptDefinition, baseCompilationConfiguration)
BridgeDependenciesResolver(scriptDefinition, scriptDefinition.properties)
}
override val acceptedAnnotations: List<KClass<out Annotation>> by lazy(LazyThreadSafetyMode.PUBLICATION) {
baseCompilationConfiguration.getOrNull(ScriptCompileConfigurationProperties.refineConfigurationOnAnnotations)
scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.refineConfigurationOnAnnotations)
.orEmpty()
.map { getScriptingClass(it) as KClass<out Annotation> }
}
override val implicitReceivers: List<KType> by lazy(LazyThreadSafetyMode.PUBLICATION) {
baseCompilationConfiguration.getOrNull(ScriptCompileConfigurationProperties.scriptImplicitReceivers)
scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.scriptImplicitReceivers)
.orEmpty()
.map { getScriptingClass(it).starProjectedType }
}
override val environmentVariables: List<Pair<String, KType>> by lazy(LazyThreadSafetyMode.PUBLICATION) {
baseCompilationConfiguration.getOrNull(ScriptCompileConfigurationProperties.contextVariables)
scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.contextVariables)
?.map { (k, v) -> k to getScriptingClass(v).starProjectedType }.orEmpty()
}
override val additionalCompilerArguments: List<String>
get() = baseCompilationConfiguration.getOrNull(ScriptCompileConfigurationProperties.compilerOptions)
get() = scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.compilerOptions)
.orEmpty()
override val scriptExpectedLocations: List<ScriptExpectedLocation> =
@@ -85,11 +80,11 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
)
override val targetClassAnnotations: List<Annotation>
get() = baseCompilationConfiguration.getOrNull(ScriptCompileConfigurationProperties.generatedClassAnnotations)
get() = scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.generatedClassAnnotations)
.orEmpty()
override val targetMethodAnnotations: List<Annotation>
get() = baseCompilationConfiguration.getOrNull(ScriptCompileConfigurationProperties.generatedMethodAnnotations)
get() = scriptDefinition.properties.getOrNull(ScriptCompileConfigurationProperties.generatedMethodAnnotations)
.orEmpty()
private val scriptingClassGetter by lazy(LazyThreadSafetyMode.PUBLICATION) {
plugins/scripting/scripting-cli/src/org/jetbrains/kotlin/scripting/compiler/plugin/LazyScriptDefinitionFromDiscoveredClass.kt
-3
View File
@@ -75,9 +75,6 @@ class LazyScriptDefinitionFromDiscoveredClass internal constructor(
object InvalidScriptDefinition : ScriptDefinition {
override val properties: ScriptDefinitionPropertiesBag = ScriptDefinitionPropertiesBag()
override val compilationConfigurator: ScriptCompilationConfigurator = object : ScriptCompilationConfigurator {
override val defaultConfiguration: ScriptCompileConfiguration = ScriptDefinitionPropertiesBag()
}
override val evaluator: ScriptEvaluator<*>? = null
}