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

Rename ScriptDefinition to ScriptCompileConfiguration

Browse Source
This commit is contained in:
Ilya Chernikov
2018-08-20 19:33:28 +03:00
parent 98c0a3bdaa
commit bd8f2a81e9
23 changed files with 146 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/tests/org/jetbrains/kotlin/codegen/AbstractCustomScriptCodegenTest.kt
+5 -5
View File
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.utils.PathUtil.KOTLIN_SCRIPTING_JVM_JAR
import org.junit.Assert
import java.io.File
import kotlin.script.experimental.annotations.KotlinScript
import kotlin.script.experimental.api.ScriptDefinition
import kotlin.script.experimental.api.ScriptCompilationConfiguration
import kotlin.script.experimental.api.implicitReceivers
import kotlin.script.experimental.api.providedProperties
@@ -121,20 +121,20 @@ abstract class AbstractCustomScriptCodegenTest : CodegenTestCase() {
}
}
object TestScriptWithReceiversConfiguration : ScriptDefinition(
object TestScriptWithReceiversConfiguration : ScriptCompilationConfiguration(
{
implicitReceivers<String>()
})
@Suppress("unused")
@KotlinScript(definition = TestScriptWithReceiversConfiguration::class)
@KotlinScript(compilationConfiguration = TestScriptWithReceiversConfiguration::class)
abstract class TestScriptWithReceivers
object TestScriptWithSimpleEnvVarsConfiguration : ScriptDefinition(
object TestScriptWithSimpleEnvVarsConfiguration : ScriptCompilationConfiguration(
{
providedProperties("stringVar1" to String::class)
})
@Suppress("unused")
@KotlinScript(definition = TestScriptWithSimpleEnvVarsConfiguration::class)
@KotlinScript(compilationConfiguration = TestScriptWithSimpleEnvVarsConfiguration::class)
abstract class TestScriptWithSimpleEnvVars
idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptDefinitionsManager.kt
+6 -2
View File
@@ -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.configurationDependencies
import kotlin.script.experimental.definitions.createScriptDefinitionFromAnnotatedBaseClass
import kotlin.script.experimental.configuration.createScriptCompilationConfigurationFromAnnotatedBaseClass
import kotlin.script.experimental.dependencies.DependenciesResolver
import kotlin.script.experimental.dependencies.ScriptDependencies
import kotlin.script.experimental.dependencies.asSuccess
@@ -213,7 +213,11 @@ fun loadDefinitionsFromTemplates(
configurationDependencies(JvmDependency(classpath))
}
KotlinScriptDefinitionAdapterFromNewAPI(
createScriptDefinitionFromAnnotatedBaseClass(KotlinType(template), hostEnvironment, KotlinScriptDefinition::class),
createScriptCompilationConfigurationFromAnnotatedBaseClass(
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
+3 -3
View File
@@ -11,13 +11,13 @@ import kotlin.script.experimental.api.EvaluationResult
import kotlin.script.experimental.api.ResultWithDiagnostics
import kotlin.script.experimental.host.toScriptSource
import kotlin.script.experimental.jvmhost.BasicJvmScriptingHost
import kotlin.script.experimental.jvmhost.createBasicScriptDefinitionFromAnnotatedBaseClass
import kotlin.script.experimental.jvmhost.createBasicScriptCompilationConfigurationFromAnnotatedBaseClass
fun evalFile(scriptFile: File): ResultWithDiagnostics<EvaluationResult> {
val scriptDefinition = createBasicScriptDefinitionFromAnnotatedBaseClass<MyScriptWithMavenDeps>()
val compilationConfiguration = createBasicScriptCompilationConfigurationFromAnnotatedBaseClass<MyScriptWithMavenDeps>()
return BasicJvmScriptingHost().eval(scriptFile.toScriptSource(), scriptDefinition, null)
return BasicJvmScriptingHost().eval(scriptFile.toScriptSource(), compilationConfiguration, null)
}
fun main(vararg args: String) {
libraries/examples/scripting/jvm-maven-deps/script/src/org/jetbrains/kotlin/script/examples/jvm/resolve/maven/scriptDef.kt
+4 -4
View File
@@ -21,13 +21,13 @@ import kotlin.script.experimental.jvm.jvm
@KotlinScript(
extension = "scriptwithdeps.kts",
definition = MyScriptDefinition::class
compilationConfiguration = MyScriptCompilationConfiguration::class
)
abstract class MyScriptWithMavenDeps {
// abstract fun body(vararg args: String): Int
}
object MyScriptDefinition : ScriptDefinition(
object MyScriptCompilationConfiguration : ScriptCompilationConfiguration(
{
defaultImports<DependsOn>()
defaultImports(Repository::class)
@@ -49,7 +49,7 @@ object MyScriptDefinition : ScriptDefinition(
private val resolver = FilesAndMavenResolver()
fun myConfigureOnAnnotations(script: ScriptDataFacade): ResultWithDiagnostics<ScriptDefinition?> {
fun myConfigureOnAnnotations(script: ScriptDataFacade): ResultWithDiagnostics<ScriptCompilationConfiguration?> {
val annotations = script.collectedData?.get(ScriptCollectedData.foundAnnotations)?.takeIf { it.isNotEmpty() }
?: return null.asSuccess()
val scriptContents = object : ScriptContents {
@@ -66,7 +66,7 @@ fun myConfigureOnAnnotations(script: ScriptDataFacade): ResultWithDiagnostics<Sc
?: return null.asSuccess(diagnostics)
val resolvedClasspath = newDepsFromResolver.classpath.toList().takeIf { it.isNotEmpty() }
?: return null.asSuccess(diagnostics)
ScriptDefinition(script.definition) {
ScriptCompilationConfiguration(script.compilationConfiguration) {
dependencies.append(JvmDependency(resolvedClasspath))
}.asSuccess(diagnostics)
} catch (e: Throwable) {
libraries/examples/scripting/jvm-simple-script/host/src/org/jetbrains/kotlin/script/examples/jvm/simple/host/host.kt
+3 -3
View File
@@ -13,10 +13,10 @@ import kotlin.script.experimental.host.toScriptSource
import kotlin.script.experimental.jvm.dependenciesFromCurrentContext
import kotlin.script.experimental.jvm.jvm
import kotlin.script.experimental.jvmhost.BasicJvmScriptingHost
import kotlin.script.experimental.jvmhost.createBasicScriptDefinitionFromAnnotatedBaseClass
import kotlin.script.experimental.jvmhost.createBasicScriptCompilationConfigurationFromAnnotatedBaseClass
fun evalFile(scriptFile: File): ResultWithDiagnostics<EvaluationResult> {
val scriptDefinition = createBasicScriptDefinitionFromAnnotatedBaseClass<MyScript> {
val compilationConfiguration = createBasicScriptCompilationConfigurationFromAnnotatedBaseClass<MyScript> {
jvm {
dependenciesFromCurrentContext(
"scripting-jvm-simple-script" /* script library jar name */
@@ -24,7 +24,7 @@ fun evalFile(scriptFile: File): ResultWithDiagnostics<EvaluationResult> {
}
}
return BasicJvmScriptingHost().eval(scriptFile.toScriptSource(), scriptDefinition, null)
return BasicJvmScriptingHost().eval(scriptFile.toScriptSource(), compilationConfiguration, null)
}
fun main(vararg args: String) {
libraries/scripting/common/src/kotlin/script/experimental/annotations/scriptAnnotations.kt
+3 -3
View File
@@ -13,14 +13,14 @@
package kotlin.script.experimental.annotations
import kotlin.reflect.KClass
import kotlin.script.experimental.api.ScriptDefinition
import kotlin.script.experimental.api.ScriptCompilationConfiguration
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class KotlinScript(
val name: String = "Kotlin script",
val extension: String = "kts",
val definition: KClass<out ScriptDefinition> = ScriptDefinition.Default::class // object or class filled in 0-ary constructor
val compilationConfiguration: KClass<out ScriptCompilationConfiguration> = ScriptCompilationConfiguration.Default::class // object or class filled in 0-ary constructor
)
@Target(AnnotationTarget.CLASS)
@@ -32,5 +32,5 @@ annotation class KotlinScriptFileExtension(
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class KotlinScriptProperties(
val definition: KClass<out ScriptDefinition> // object or class filled in 0-ary constructor
val compilationConfiguration: KClass<out ScriptCompilationConfiguration> // object or class filled in 0-ary constructor
)
libraries/scripting/common/src/kotlin/script/experimental/api/scriptCompilation.kt
+2 -2
View File
@@ -9,14 +9,14 @@ interface ScriptCompiler {
suspend operator fun invoke(
script: ScriptSource,
scriptDefinition: ScriptDefinition
scriptCompilationConfiguration: ScriptCompilationConfiguration
): ResultWithDiagnostics<CompiledScript<*>>
}
interface CompiledScript<out ScriptBase : Any> {
val definition: ScriptDefinition
val compilationConfiguration: ScriptCompilationConfiguration
suspend fun instantiate(scriptEvaluationEnvironment: ScriptEvaluationEnvironment?): ResultWithDiagnostics<ScriptBase>
}
libraries/scripting/common/src/kotlin/script/experimental/api/scriptConfiguration.kt
+2 -2
View File
@@ -23,11 +23,11 @@ val ScriptCollectedDataKeys.foundFragments by PropertiesCollection.key<List<Scri
class ScriptDataFacade(
val source: ScriptSource,
val definition: ScriptDefinition,
val compilationConfiguration: ScriptCompilationConfiguration,
val collectedData: ScriptCollectedData? = null
)
typealias RefineScriptCompilationConfigurationHandler = (ScriptDataFacade) -> ResultWithDiagnostics<ScriptDefinition?>
typealias RefineScriptCompilationConfigurationHandler = (ScriptDataFacade) -> ResultWithDiagnostics<ScriptCompilationConfiguration?>
// to make it "hasheable" for cashing
class RefineConfigurationBeforeParsingData(
libraries/scripting/common/src/kotlin/script/experimental/api/scriptDefinition.kt
+30 -28
View File
@@ -10,65 +10,67 @@ package kotlin.script.experimental.api
import kotlin.reflect.KClass
import kotlin.script.experimental.util.PropertiesCollection
interface ScriptDefinitionKeys
interface ScriptCompilationConfigurationKeys
open class ScriptDefinition(baseDefinitions: Iterable<ScriptDefinition>, body: Builder.() -> Unit) :
PropertiesCollection(Builder(baseDefinitions).apply(body).data) {
open class ScriptCompilationConfiguration(baseConfigurations: Iterable<ScriptCompilationConfiguration>, body: Builder.() -> Unit) :
PropertiesCollection(Builder(baseConfigurations).apply(body).data) {
constructor(body: Builder.() -> Unit = {}) : this(emptyList(), body)
constructor(vararg baseDefinitions: ScriptDefinition, body: Builder.() -> Unit = {}) : this(baseDefinitions.asIterable(), body)
constructor(
vararg baseConfigurations: ScriptCompilationConfiguration, body: Builder.() -> Unit = {}
) : this(baseConfigurations.asIterable(), body)
class Builder internal constructor(baseDefinitions: Iterable<ScriptDefinition>) :
ScriptDefinitionKeys,
PropertiesCollection.Builder(baseDefinitions)
class Builder internal constructor(baseConfigurations: Iterable<ScriptCompilationConfiguration>) :
ScriptCompilationConfigurationKeys,
PropertiesCollection.Builder(baseConfigurations)
// inherited from script definition for using as a keys anchor
companion object : ScriptDefinitionKeys
// inherited from script compilationConfiguration for using as a keys anchor
companion object : ScriptCompilationConfigurationKeys
object Default : ScriptDefinition()
object Default : ScriptCompilationConfiguration()
}
val ScriptDefinitionKeys.displayName by PropertiesCollection.key<String>("Kotlin script") // Name of the script type
val ScriptCompilationConfigurationKeys.displayName by PropertiesCollection.key<String>("Kotlin script") // Name of the script type
val ScriptDefinitionKeys.fileExtension by PropertiesCollection.key<String>("kts") // file extension
val ScriptCompilationConfigurationKeys.fileExtension by PropertiesCollection.key<String>("kts") // file extension
val ScriptDefinitionKeys.baseClass by PropertiesCollection.key<KotlinType>() // script base class
val ScriptCompilationConfigurationKeys.baseClass by PropertiesCollection.key<KotlinType>() // script base class
val ScriptDefinitionKeys.scriptBodyTarget by PropertiesCollection.key<ScriptBodyTarget>(ScriptBodyTarget.Constructor)
val ScriptCompilationConfigurationKeys.scriptBodyTarget by PropertiesCollection.key<ScriptBodyTarget>(ScriptBodyTarget.Constructor)
val ScriptDefinitionKeys.implicitReceivers by PropertiesCollection.key<List<KotlinType>>() // in the order from outer to inner scope
val ScriptCompilationConfigurationKeys.implicitReceivers by PropertiesCollection.key<List<KotlinType>>() // in the order from outer to inner scope
val ScriptDefinitionKeys.providedProperties by PropertiesCollection.key<Map<String, KotlinType>>() // external variables
val ScriptCompilationConfigurationKeys.providedProperties by PropertiesCollection.key<Map<String, KotlinType>>() // external variables
val ScriptDefinitionKeys.defaultImports by PropertiesCollection.key<List<String>>()
val ScriptCompilationConfigurationKeys.defaultImports by PropertiesCollection.key<List<String>>()
val ScriptDefinitionKeys.dependencies by PropertiesCollection.key<List<ScriptDependency>>()
val ScriptCompilationConfigurationKeys.dependencies by PropertiesCollection.key<List<ScriptDependency>>()
val ScriptDefinitionKeys.copyAnnotationsFrom by PropertiesCollection.key<List<KotlinType>>()
val ScriptCompilationConfigurationKeys.copyAnnotationsFrom by PropertiesCollection.key<List<KotlinType>>()
val ScriptDefinitionKeys.compilerOptions by PropertiesCollection.key<List<String>>() // Q: CommonCompilerOptions instead?
val ScriptCompilationConfigurationKeys.compilerOptions by PropertiesCollection.key<List<String>>() // Q: CommonCompilerOptions instead?
val ScriptDefinitionKeys.refineConfigurationBeforeParsing by PropertiesCollection.key<RefineConfigurationBeforeParsingData>()
val ScriptCompilationConfigurationKeys.refineConfigurationBeforeParsing by PropertiesCollection.key<RefineConfigurationBeforeParsingData>()
val ScriptDefinitionKeys.refineConfigurationOnAnnotations by PropertiesCollection.key<RefineConfigurationOnAnnotationsData>()
val ScriptCompilationConfigurationKeys.refineConfigurationOnAnnotations by PropertiesCollection.key<RefineConfigurationOnAnnotationsData>()
val ScriptDefinitionKeys.refineConfigurationOnSections by PropertiesCollection.key<RefineConfigurationOnSectionsData>()
val ScriptCompilationConfigurationKeys.refineConfigurationOnSections by PropertiesCollection.key<RefineConfigurationOnSectionsData>()
val ScriptDefinitionKeys.sourceFragments by PropertiesCollection.key<List<ScriptSourceNamedFragment>>()
val ScriptCompilationConfigurationKeys.sourceFragments by PropertiesCollection.key<List<ScriptSourceNamedFragment>>()
// DSL:
val ScriptDefinition.Builder.refineConfiguration get() = RefineConfigurationBuilder()
val ScriptCompilationConfiguration.Builder.refineConfiguration get() = RefineConfigurationBuilder()
class RefineConfigurationBuilder : PropertiesCollection.Builder() {
fun beforeParsing(handler: RefineScriptCompilationConfigurationHandler) {
set(ScriptDefinition.refineConfigurationBeforeParsing, RefineConfigurationBeforeParsingData(handler))
set(ScriptCompilationConfiguration.refineConfigurationBeforeParsing, RefineConfigurationBeforeParsingData(handler))
}
fun onAnnotations(annotations: List<KotlinType>, handler: RefineScriptCompilationConfigurationHandler) {
set(ScriptDefinition.refineConfigurationOnAnnotations, RefineConfigurationOnAnnotationsData(annotations, handler))
set(ScriptCompilationConfiguration.refineConfigurationOnAnnotations, RefineConfigurationOnAnnotationsData(annotations, handler))
}
fun onAnnotations(vararg annotations: KotlinType, handler: RefineScriptCompilationConfigurationHandler) {
@@ -88,7 +90,7 @@ class RefineConfigurationBuilder : PropertiesCollection.Builder() {
}
fun onSections(sections: List<String>, handler: RefineScriptCompilationConfigurationHandler) {
set(ScriptDefinition.refineConfigurationOnSections, RefineConfigurationOnSectionsData(sections, handler))
set(ScriptCompilationConfiguration.refineConfigurationOnSections, RefineConfigurationOnSectionsData(sections, handler))
}
fun onSections(vararg sections: String, handler: RefineScriptCompilationConfigurationHandler) {
libraries/scripting/common/src/kotlin/script/experimental/api/scriptEvaluation.kt
+1 -1
View File
@@ -20,7 +20,7 @@ class ScriptEvaluationEnvironment(baseEvaluationEnvironments: Iterable<ScriptEva
) : this(baseEvaluationEnvironments.asIterable(), body)
class Builder internal constructor(baseEvaluationEnvironments: Iterable<ScriptEvaluationEnvironment>) :
ScriptDefinitionKeys,
ScriptCompilationConfigurationKeys,
PropertiesCollection.Builder(baseEvaluationEnvironments)
companion object : ScriptEvaluationEnvironmentKeys
libraries/scripting/common/src/kotlin/script/experimental/definitions/definitionFromAnnotation.kt → libraries/scripting/common/src/kotlin/script/experimental/configuration/definitionFromAnnotation.kt
+11 -11
View File
@@ -1,9 +1,9 @@
/*
* Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
* Copyright 2010-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.
*/
package kotlin.script.experimental.definitions
package kotlin.script.experimental.configuration
import kotlin.reflect.KClass
import kotlin.script.experimental.annotations.KotlinScript
@@ -14,14 +14,14 @@ import kotlin.script.experimental.api.*
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"
"Illegal argument compilationConfiguration of the KotlinScript annotation: expecting an object or default-constructed class derived from ScriptCompilationConfiguration"
fun createScriptDefinitionFromAnnotatedBaseClass(
fun createScriptCompilationConfigurationFromAnnotatedBaseClass(
baseClassType: KotlinType,
environment: ScriptingEnvironment,
contextClass: KClass<*> = ScriptDefinition::class,
body: ScriptDefinition.Builder.() -> Unit = {}
): ScriptDefinition {
contextClass: KClass<*> = ScriptCompilationConfiguration::class,
body: ScriptCompilationConfiguration.Builder.() -> Unit = {}
): ScriptCompilationConfiguration {
val getScriptingClass = environment[ScriptingEnvironment.getScriptingClass]
?: throw IllegalArgumentException("${ERROR_MSG_PREFIX}Expecting 'getScriptingClass' parameter in the scripting environment")
@@ -37,21 +37,21 @@ fun createScriptDefinitionFromAnnotatedBaseClass(
val mainAnnotation = baseClass.findAnnotation<KotlinScript>()
?: throw IllegalArgumentException("${ERROR_MSG_PREFIX}Expecting KotlinScript annotation on the $baseClass")
fun scriptingPropsInstance(kclass: KClass<out ScriptDefinition>): ScriptDefinition = try {
fun scriptingPropsInstance(kclass: KClass<out ScriptCompilationConfiguration>): ScriptCompilationConfiguration = try {
kclass.objectInstance ?: kclass.createInstance()
} catch (e: Throwable) {
throw IllegalArgumentException(ILLEGAL_CONFIG_ANN_ARG, e)
}
return ScriptDefinition {
return ScriptCompilationConfiguration {
baseClass(loadedBaseClassType)
fileExtension(baseClass.findAnnotation<KotlinScriptFileExtension>()?.extension ?: mainAnnotation.extension)
displayName(mainAnnotation.name)
include(scriptingPropsInstance(mainAnnotation.definition))
include(scriptingPropsInstance(mainAnnotation.compilationConfiguration))
baseClass.java.annotations.filterIsInstance(KotlinScriptProperties::class.java).forEach { ann ->
include(scriptingPropsInstance(ann.definition))
include(scriptingPropsInstance(ann.compilationConfiguration))
}
body()
}
libraries/scripting/common/src/kotlin/script/experimental/host/BasicScriptingHost.kt
+2 -2
View File
@@ -30,11 +30,11 @@ abstract class BasicScriptingHost(
open fun eval(
script: ScriptSource,
scriptDefinition: ScriptDefinition,
scriptCompilationConfiguration: ScriptCompilationConfiguration,
environment: ScriptEvaluationEnvironment?
): ResultWithDiagnostics<EvaluationResult> =
runInCoroutineContext {
compiler(script, scriptDefinition).onSuccess {
compiler(script, scriptCompilationConfiguration).onSuccess {
evaluator(it, environment)
}
}
libraries/scripting/common/src/kotlin/script/experimental/host/scriptHostUtil.kt
+2 -2
View File
@@ -16,9 +16,9 @@ fun ScriptSource.getScriptText(): String = when {
else -> throw RuntimeException("unable to get text from null script")
}
fun getMergedScriptText(script: ScriptSource, configuration: ScriptDefinition?): String {
fun getMergedScriptText(script: ScriptSource, configuration: ScriptCompilationConfiguration?): String {
val originalScriptText = script.getScriptText()
val sourceFragments = configuration?.get(ScriptDefinition.sourceFragments)
val sourceFragments = configuration?.get(ScriptCompilationConfiguration.sourceFragments)
return if (sourceFragments == null || sourceFragments.isEmpty()) {
originalScriptText
} else {
libraries/scripting/common/src/kotlin/script/experimental/repl/replCompilation.kt
+2 -2
View File
@@ -12,7 +12,7 @@ interface ReplSnippetChecker {
suspend operator fun invoke(
snippet: ReplSnippetSource,
state: ReplStageState<*>,
scriptDefinition: ScriptDefinition
compilationConfiguration: ScriptCompilationConfiguration
): ResultWithDiagnostics<Unit>
}
@@ -21,7 +21,7 @@ interface ReplSnippetCompiler {
suspend operator fun invoke(
snippet: ReplSnippetSource,
state: ReplStageState<*>,
scriptDefinition: ScriptDefinition
compilationConfiguration: ScriptCompilationConfiguration
): ResultWithDiagnostics<CompiledReplSnippet<*>>
}
libraries/scripting/common/src/kotlin/script/experimental/repl/replHost.kt
+2 -2
View File
@@ -9,7 +9,7 @@ import kotlinx.coroutines.experimental.CoroutineScope
import kotlinx.coroutines.experimental.runBlocking
import kotlin.script.experimental.api.EvaluationResult
import kotlin.script.experimental.api.ResultWithDiagnostics
import kotlin.script.experimental.api.ScriptDefinition
import kotlin.script.experimental.api.ScriptCompilationConfiguration
import kotlin.script.experimental.util.PropertiesCollection
interface ReplCommandProcessor {
@@ -51,7 +51,7 @@ abstract class ReplHost(
abstract fun eval(
snippet: ReplSnippetSource,
state: ReplStageState<*>,
scriptDefinition: ScriptDefinition,
scriptCompilationConfiguration: ScriptCompilationConfiguration,
replEvaluationEnvironment: ReplEvaluationEnvironment
): ResultWithDiagnostics<EvaluationResult>
}
libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/BasicJvmScriptingHost.kt
+10 -5
View File
@@ -6,10 +6,10 @@
package kotlin.script.experimental.jvmhost
import kotlin.script.experimental.api.KotlinType
import kotlin.script.experimental.api.ScriptDefinition
import kotlin.script.experimental.api.ScriptCompilationConfiguration
import kotlin.script.experimental.api.ScriptEvaluator
import kotlin.script.experimental.api.ScriptingEnvironment
import kotlin.script.experimental.definitions.createScriptDefinitionFromAnnotatedBaseClass
import kotlin.script.experimental.configuration.createScriptCompilationConfigurationFromAnnotatedBaseClass
import kotlin.script.experimental.host.BasicScriptingHost
import kotlin.script.experimental.jvm.defaultJvmScriptingEnvironment
@@ -20,7 +20,12 @@ open class BasicJvmScriptingHost(
) : BasicScriptingHost(compiler, evaluator)
inline fun <reified T : Any> createBasicScriptDefinitionFromAnnotatedBaseClass(
inline fun <reified T : Any> createBasicScriptCompilationConfigurationFromAnnotatedBaseClass(
hostEnvironment: ScriptingEnvironment = defaultJvmScriptingEnvironment,
noinline body: ScriptDefinition.Builder.() -> Unit = {}
): ScriptDefinition = createScriptDefinitionFromAnnotatedBaseClass(KotlinType(T::class), hostEnvironment, ScriptDefinition::class, body)
noinline body: ScriptCompilationConfiguration.Builder.() -> Unit = {}
): ScriptCompilationConfiguration = createScriptCompilationConfigurationFromAnnotatedBaseClass(
KotlinType(T::class),
hostEnvironment,
ScriptCompilationConfiguration::class,
body
)
libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJVMCompilerImpl.kt
+14 -14
View File
@@ -50,7 +50,7 @@ import kotlin.script.experimental.util.getFirstFromChainOrNull
import kotlin.script.experimental.util.getOrError
class KJvmCompiledScript<out ScriptBase : Any>(
override val definition: ScriptDefinition,
override val compilationConfiguration: ScriptCompilationConfiguration,
private val generationState: GenerationState,
private val scriptClassFQName: String
) : CompiledScript<ScriptBase> {
@@ -58,7 +58,7 @@ class KJvmCompiledScript<out ScriptBase : Any>(
override suspend fun instantiate(scriptEvaluationEnvironment: ScriptEvaluationEnvironment?): ResultWithDiagnostics<ScriptBase> = try {
val baseClassLoader = scriptEvaluationEnvironment?.get(JvmScriptEvaluationEnvironment.baseClassLoader)
?: Thread.currentThread().contextClassLoader
val dependencies = definition[ScriptDefinition.dependencies]
val dependencies = compilationConfiguration[ScriptCompilationConfiguration.dependencies]
?.flatMap { (it as? JvmDependency)?.classpath?.map { it.toURI().toURL() } ?: emptyList() }
// TODO: previous dependencies and classloaders should be taken into account here
val classLoaderWithDeps =
@@ -78,7 +78,7 @@ class KJvmCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJvmCompiler
override fun compile(
script: ScriptSource,
scriptDefinition: ScriptDefinition
scriptCompilationConfiguration: ScriptCompilationConfiguration
): ResultWithDiagnostics<CompiledScript<*>> {
val messageCollector = ScriptDiagnosticsMessageCollector()
@@ -89,12 +89,12 @@ class KJvmCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJvmCompiler
setIdeaIoUseFallback()
var environment: KotlinCoreEnvironment? = null
var updatedDefinition = scriptDefinition
var updatedConfiguration = scriptCompilationConfiguration
fun updateClasspath(classpath: List<File>) {
environment!!.updateClasspath(classpath.map(::JvmClasspathRoot))
if (classpath.isNotEmpty()) {
updatedDefinition = ScriptDefinition(updatedDefinition) {
updatedConfiguration = ScriptCompilationConfiguration(updatedConfiguration) {
dependencies.append(JvmDependency(classpath))
}
}
@@ -104,18 +104,18 @@ class KJvmCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJvmCompiler
val kotlinCompilerConfiguration = org.jetbrains.kotlin.config.CompilerConfiguration().apply {
add(
JVMConfigurationKeys.SCRIPT_DEFINITIONS,
BridgeScriptDefinition(scriptDefinition, hostEnvironment, ::updateClasspath)
BridgeScriptDefinition(scriptCompilationConfiguration, hostEnvironment, ::updateClasspath)
)
put<MessageCollector>(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
put(JVMConfigurationKeys.RETAIN_OUTPUT_IN_MEMORY, true)
var isModularJava = false
getFirstFromChainOrNull(ScriptDefinition.jvm.javaHome, updatedDefinition, hostEnvironment)?.let {
getFirstFromChainOrNull(ScriptCompilationConfiguration.jvm.javaHome, updatedConfiguration, hostEnvironment)?.let {
put(JVMConfigurationKeys.JDK_HOME, it)
isModularJava = CoreJrtFileSystem.isModularJdk(it)
}
updatedDefinition[ScriptDefinition.dependencies]?.let { dependencies ->
updatedConfiguration[ScriptCompilationConfiguration.dependencies]?.let { dependencies ->
addJvmClasspathRoots(
dependencies.flatMap {
(it as JvmDependency).classpath
@@ -147,7 +147,7 @@ class KJvmCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJvmCompiler
val analyzerWithCompilerReport = AnalyzerWithCompilerReport(messageCollector, environment.configuration.languageVersionSettings)
val psiFileFactory: PsiFileFactoryImpl = PsiFileFactory.getInstance(environment.project) as PsiFileFactoryImpl
val scriptText = getMergedScriptText(script, updatedDefinition)
val scriptText = getMergedScriptText(script, updatedConfiguration)
val scriptFileName = "script" // TODO: extract from file/url if available
val virtualFile = LightVirtualFile(
"$scriptFileName${KotlinParserDefinition.STD_SCRIPT_EXT}",
@@ -192,7 +192,7 @@ class KJvmCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJvmCompiler
org.jetbrains.kotlin.codegen.CompilationErrorHandler.THROW_EXCEPTION
)
val res = KJvmCompiledScript<Any>(updatedDefinition, generationState, scriptFileName.capitalize())
val res = KJvmCompiledScript<Any>(updatedConfiguration, generationState, scriptFileName.capitalize())
return ResultWithDiagnostics.Success(res, messageCollector.diagnostics)
} catch (ex: Throwable) {
@@ -237,22 +237,22 @@ class ScriptDiagnosticsMessageCollector : MessageCollector {
// A bridge to the current scripting
internal class BridgeScriptDefinition(
scriptDefinition: ScriptDefinition,
scriptCompilationConfiguration: ScriptCompilationConfiguration,
hostEnvironment: ScriptingEnvironment,
updateClasspath: (List<File>) -> Unit
) : KotlinScriptDefinition(
hostEnvironment.getScriptingClass(
scriptDefinition.getOrError(ScriptDefinition.baseClass),
scriptCompilationConfiguration.getOrError(ScriptCompilationConfiguration.baseClass),
BridgeScriptDefinition::class
)
) {
override val acceptedAnnotations = run {
val cl = this::class.java.classLoader
scriptDefinition[ScriptDefinition.refineConfigurationOnAnnotations]?.annotations
scriptCompilationConfiguration[ScriptCompilationConfiguration.refineConfigurationOnAnnotations]?.annotations
?.map { (cl.loadClass(it.typeName) as Class<out Annotation>).kotlin }
?: emptyList()
}
override val dependencyResolver: DependenciesResolver =
BridgeDependenciesResolver(scriptDefinition, updateClasspath)
BridgeDependenciesResolver(scriptCompilationConfiguration, updateClasspath)
}
libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/jvmScriptCompilation.kt
+9 -9
View File
@@ -13,16 +13,16 @@ import kotlin.script.experimental.jvmhost.impl.KJvmCompilerImpl
import kotlin.script.experimental.jvmhost.impl.withDefaults
interface CompiledJvmScriptsCache {
fun get(script: ScriptSource, scriptDefinition: ScriptDefinition): CompiledScript<*>?
fun store(compiledScript: CompiledScript<*>, scriptDefinition: ScriptDefinition)
fun get(script: ScriptSource, scriptCompilationConfiguration: ScriptCompilationConfiguration): CompiledScript<*>?
fun store(compiledScript: CompiledScript<*>, scriptCompilationConfiguration: ScriptCompilationConfiguration)
object NoCache : CompiledJvmScriptsCache {
override fun get(
script: ScriptSource, scriptDefinition: ScriptDefinition
script: ScriptSource, scriptCompilationConfiguration: ScriptCompilationConfiguration
): CompiledScript<*>? = null
override fun store(
compiledScript: CompiledScript<*>, scriptDefinition: ScriptDefinition
compiledScript: CompiledScript<*>, scriptCompilationConfiguration: ScriptCompilationConfiguration
) {
}
}
@@ -36,16 +36,16 @@ open class JvmScriptCompiler(
override suspend operator fun invoke(
script: ScriptSource,
scriptDefinition: ScriptDefinition
scriptCompilationConfiguration: ScriptCompilationConfiguration
): ResultWithDiagnostics<CompiledScript<*>> {
val refineConfigurationFn = scriptDefinition[ScriptDefinition.refineConfigurationBeforeParsing]
val refineConfigurationFn = scriptCompilationConfiguration[ScriptCompilationConfiguration.refineConfigurationBeforeParsing]
val refinedConfiguration =
refineConfigurationFn?.handler?.invoke(ScriptDataFacade(script, scriptDefinition))?.let {
refineConfigurationFn?.handler?.invoke(ScriptDataFacade(script, scriptCompilationConfiguration))?.let {
when (it) {
is ResultWithDiagnostics.Failure -> return it
is ResultWithDiagnostics.Success -> it.value
}
} ?: scriptDefinition
} ?: scriptCompilationConfiguration
val cached = cache.get(script, refinedConfiguration)
if (cached != null) return cached.asSuccess()
@@ -61,7 +61,7 @@ open class JvmScriptCompiler(
interface KJvmCompilerProxy {
fun compile(
script: ScriptSource,
scriptDefinition: ScriptDefinition
scriptCompilationConfiguration: ScriptCompilationConfiguration
): ResultWithDiagnostics<CompiledScript<*>>
}
libraries/scripting/jvm/src/kotlin/script/experimental/jvm/impl/BridgeDependenciesResolver.kt
+6 -6
View File
@@ -20,7 +20,7 @@ import kotlin.script.experimental.jvm.compat.mapToLegacyScriptReportPosition
import kotlin.script.experimental.jvm.compat.mapToLegacyScriptReportSeverity
class BridgeDependenciesResolver(
val scriptDefinition: ScriptDefinition,
val scriptCompilationConfiguration: ScriptCompilationConfiguration,
val onClasspathUpdated: (List<File>) -> Unit = {}
) : AsyncDependenciesResolver {
@@ -39,12 +39,12 @@ class BridgeDependenciesResolver(
)
)
val refineFn = scriptDefinition[ScriptDefinition.refineConfigurationOnAnnotations]?.handler
val refineFn = scriptCompilationConfiguration[ScriptCompilationConfiguration.refineConfigurationOnAnnotations]?.handler
val refinedConfiguration =
if (refineFn == null) null
else {
val res = refineFn(
ScriptDataFacade(scriptContents.toScriptSource(), scriptDefinition, processedScriptData)
ScriptDataFacade(scriptContents.toScriptSource(), scriptCompilationConfiguration, processedScriptData)
)
when (res) {
is ResultWithDiagnostics.Failure ->
@@ -56,11 +56,11 @@ class BridgeDependenciesResolver(
}
}
val newClasspath = refinedConfiguration?.get(ScriptDefinition.dependencies)
val newClasspath = refinedConfiguration?.get(ScriptCompilationConfiguration.dependencies)
?.flatMap { (it as JvmDependency).classpath } ?: emptyList()
if (newClasspath.isNotEmpty()) {
val oldClasspath =
scriptDefinition[ScriptDefinition.dependencies]
scriptCompilationConfiguration[ScriptCompilationConfiguration.dependencies]
?.flatMap { (it as JvmDependency).classpath } ?: emptyList()
if (newClasspath != oldClasspath) {
onClasspathUpdated(newClasspath)
@@ -69,7 +69,7 @@ class BridgeDependenciesResolver(
DependenciesResolver.ResolveResult.Success(
ScriptDependencies(
classpath = newClasspath, // TODO: maybe it should return only increment from the initial config
imports = scriptDefinition[ScriptDefinition.defaultImports]?.toList() ?: emptyList()
imports = scriptCompilationConfiguration[ScriptCompilationConfiguration.defaultImports]?.toList() ?: emptyList()
),
diagnostics
)
libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptDefinition.kt → libraries/scripting/jvm/src/kotlin/script/experimental/jvm/jvmScriptCompilation.kt
+10 -10
View File
@@ -15,31 +15,31 @@ data class JvmDependency(val classpath: List<File>) : ScriptDependency {
constructor(vararg classpathEntries: File) : this(classpathEntries.asList())
}
interface JvmScriptDefinitionKeys
interface JvmScriptCompilationConfigurationKeys
open class JvmScriptDefinitionBuilder : PropertiesCollection.Builder(), JvmScriptDefinitionKeys {
companion object : PropertiesCollection.Builder.BuilderExtension<JvmScriptDefinitionBuilder>, JvmScriptDefinitionKeys {
override fun get() = JvmScriptDefinitionBuilder()
open class JvmScriptCompilationConfigurationBuilder : PropertiesCollection.Builder(), JvmScriptCompilationConfigurationKeys {
companion object : PropertiesCollection.Builder.BuilderExtension<JvmScriptCompilationConfigurationBuilder>, JvmScriptCompilationConfigurationKeys {
override fun get() = JvmScriptCompilationConfigurationBuilder()
}
}
fun JvmScriptDefinitionBuilder.dependenciesFromCurrentContext(vararg libraries: String, wholeClasspath: Boolean = false) {
fun JvmScriptCompilationConfigurationBuilder.dependenciesFromCurrentContext(vararg libraries: String, wholeClasspath: Boolean = false) {
dependenciesFromClassloader(*libraries, wholeClasspath = wholeClasspath)
}
fun JvmScriptDefinitionBuilder.dependenciesFromClassloader(
fun JvmScriptCompilationConfigurationBuilder.dependenciesFromClassloader(
vararg libraries: String,
classLoader: ClassLoader = Thread.currentThread().contextClassLoader,
wholeClasspath: Boolean = false
) {
ScriptDefinition.dependencies.append(
ScriptCompilationConfiguration.dependencies.append(
JvmDependency(scriptCompilationClasspathFromContext(*libraries, classLoader = classLoader, wholeClasspath = wholeClasspath))
)
}
val JvmScriptDefinitionKeys.javaHome by PropertiesCollection.keyCopy(ScriptingEnvironment.jvm.javaHome)
val JvmScriptCompilationConfigurationKeys.javaHome by PropertiesCollection.keyCopy(ScriptingEnvironment.jvm.javaHome)
@Suppress("unused")
val ScriptDefinitionKeys.jvm
get() = JvmScriptDefinitionBuilder
val ScriptCompilationConfigurationKeys.jvm
get() = JvmScriptCompilationConfigurationBuilder
plugins/scripting/scripting-cli/src/org/jetbrains/kotlin/scripting/compiler/plugin/KotlinScriptDefinitionAdapterFromNewAPI.kt
+11 -11
View File
@@ -23,20 +23,20 @@ import kotlin.script.experimental.util.getOrError
// 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) {
protected abstract val scriptDefinition: ScriptDefinition
protected abstract val scriptCompilationConfiguration: ScriptCompilationConfiguration
protected abstract val hostEnvironment: ScriptingEnvironment
abstract val scriptFileExtensionWithDot: String
open val baseClass: KClass<*> by lazy(LazyThreadSafetyMode.PUBLICATION) {
getScriptingClass(scriptDefinition.getOrError(ScriptDefinition.baseClass))
getScriptingClass(scriptCompilationConfiguration.getOrError(ScriptCompilationConfiguration.baseClass))
}
override val template: KClass<*> get() = baseClass
override val name: String
get() = scriptDefinition[ScriptDefinition.displayName] ?: "Kotlin Script"
get() = scriptCompilationConfiguration[ScriptCompilationConfiguration.displayName] ?: "Kotlin Script"
override val fileType: LanguageFileType = KotlinFileType.INSTANCE
@@ -52,28 +52,28 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
get() = emptyList()
override val dependencyResolver: DependenciesResolver by lazy(LazyThreadSafetyMode.PUBLICATION) {
BridgeDependenciesResolver(scriptDefinition)
BridgeDependenciesResolver(scriptCompilationConfiguration)
}
override val acceptedAnnotations: List<KClass<out Annotation>> by lazy(LazyThreadSafetyMode.PUBLICATION) {
scriptDefinition[ScriptDefinition.refineConfigurationOnAnnotations]?.annotations
scriptCompilationConfiguration[ScriptCompilationConfiguration.refineConfigurationOnAnnotations]?.annotations
.orEmpty()
.map { getScriptingClass(it) as KClass<out Annotation> }
}
override val implicitReceivers: List<KType> by lazy(LazyThreadSafetyMode.PUBLICATION) {
scriptDefinition[ScriptDefinition.implicitReceivers]
scriptCompilationConfiguration[ScriptCompilationConfiguration.implicitReceivers]
.orEmpty()
.map { getScriptingClass(it).starProjectedType }
}
override val environmentVariables: List<Pair<String, KType>> by lazy(LazyThreadSafetyMode.PUBLICATION) {
scriptDefinition[ScriptDefinition.providedProperties]
scriptCompilationConfiguration[ScriptCompilationConfiguration.providedProperties]
?.map { (k, v) -> k to getScriptingClass(v).starProjectedType }.orEmpty()
}
override val additionalCompilerArguments: List<String>
get() = scriptDefinition[ScriptDefinition.compilerOptions]
get() = scriptCompilationConfiguration[ScriptCompilationConfiguration.compilerOptions]
.orEmpty()
override val scriptExpectedLocations: List<ScriptExpectedLocation> =
@@ -97,12 +97,12 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
class KotlinScriptDefinitionAdapterFromNewAPI(
override val scriptDefinition: ScriptDefinition,
override val scriptCompilationConfiguration: ScriptCompilationConfiguration,
override val hostEnvironment: ScriptingEnvironment
) : KotlinScriptDefinitionAdapterFromNewAPIBase() {
override val name: String get() = scriptDefinition[ScriptDefinition.displayName] ?: super.name
override val name: String get() = scriptCompilationConfiguration[ScriptCompilationConfiguration.displayName] ?: super.name
override val scriptFileExtensionWithDot =
"." + (scriptDefinition[ScriptDefinition.fileExtension] ?: "kts")
"." + (scriptCompilationConfiguration[ScriptCompilationConfiguration.fileExtension] ?: "kts")
}
plugins/scripting/scripting-cli/src/org/jetbrains/kotlin/scripting/compiler/plugin/LazyScriptDefinitionFromDiscoveredClass.kt
+6 -6
View File
@@ -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.createScriptDefinitionFromAnnotatedBaseClass
import kotlin.script.experimental.configuration.createScriptCompilationConfigurationFromAnnotatedBaseClass
import kotlin.script.experimental.jvm.JvmDependency
import kotlin.script.experimental.jvm.defaultJvmScriptingEnvironment
@@ -41,13 +41,13 @@ class LazyScriptDefinitionFromDiscoveredClass internal constructor(
}
}
override val scriptDefinition: ScriptDefinition by lazy(LazyThreadSafetyMode.PUBLICATION) {
override val scriptCompilationConfiguration: ScriptCompilationConfiguration by lazy(LazyThreadSafetyMode.PUBLICATION) {
messageCollector.report(
CompilerMessageSeverity.LOGGING,
"Configure scripting: loading script definition class $className using classpath $classpath\n. ${Thread.currentThread().stackTrace}"
)
try {
createScriptDefinitionFromAnnotatedBaseClass(
createScriptCompilationConfigurationFromAnnotatedBaseClass(
KotlinType(className),
hostEnvironment,
LazyScriptDefinitionFromDiscoveredClass::class
@@ -70,8 +70,8 @@ class LazyScriptDefinitionFromDiscoveredClass internal constructor(
?: annotationsFromAsm.find { it.name == KotlinScript::class.simpleName }?.args
)?.find { it.name == "extension" }?.value
val ext = extFromAnn
?: scriptDefinition.let {
it[ScriptDefinition.fileExtension] ?: "kts"
?: scriptCompilationConfiguration.let {
it[ScriptCompilationConfiguration.fileExtension] ?: "kts"
}
".$ext"
}
@@ -82,4 +82,4 @@ class LazyScriptDefinitionFromDiscoveredClass internal constructor(
}
}
val InvalidScriptDefinition = ScriptDefinition()
val InvalidScriptDefinition = ScriptCompilationConfiguration()
plugins/scripting/scripting-cli/src/org/jetbrains/kotlin/scripting/compiler/plugin/ScriptiDefinitionsFromClasspathDiscoverySource.kt
+2 -2
View File
@@ -18,7 +18,7 @@ import java.util.jar.JarFile
import kotlin.coroutines.experimental.buildSequence
import kotlin.script.experimental.annotations.KotlinScript
import kotlin.script.experimental.api.KotlinType
import kotlin.script.experimental.definitions.createScriptDefinitionFromAnnotatedBaseClass
import kotlin.script.experimental.configuration.createScriptCompilationConfigurationFromAnnotatedBaseClass
import kotlin.script.experimental.jvm.defaultJvmScriptingEnvironment
import kotlin.script.templates.ScriptTemplateDefinition
@@ -274,7 +274,7 @@ private fun loadScriptDefinition(
if (cls.annotations.firstIsInstanceOrNull<KotlinScript>() != null) {
val environment = defaultJvmScriptingEnvironment
KotlinScriptDefinitionAdapterFromNewAPI(
createScriptDefinitionFromAnnotatedBaseClass(
createScriptCompilationConfigurationFromAnnotatedBaseClass(
KotlinType(cls.kotlin),
environment,
KotlinScriptDefinition::class