Scripting: support plugins loading in the stateless REPL
diff --git a/libraries/examples/scripting/jsr223-bta/build.gradle.kts b/libraries/examples/scripting/jsr223-bta/build.gradle.kts index 4985f59b..365eee0 100644 --- a/libraries/examples/scripting/jsr223-bta/build.gradle.kts +++ b/libraries/examples/scripting/jsr223-bta/build.gradle.kts
@@ -27,7 +27,7 @@ testImplementation(project(":kotlin-script-runtime")) // marker class to locate the jar for legacy-template tests // MainKtsConfigurator instantiates a MavenDependenciesResolver in a default constructor // argument, so this is needed even though no test resolves dependencies. - testRuntimeOnly(project(":kotlin-scripting-dependencies-maven")) + testImplementation(project(":kotlin-scripting-dependencies-maven")) } // The Build Tools API implementation plus the compiler it runs on, loaded into an isolated @@ -38,11 +38,19 @@ // The scripting plugin jar, which has to be the regular (non-relocated) embeddable artifact to match // the embeddable compiler above. val scriptingCompilerPluginClasspath = configurations.create("scriptingCompilerPluginClasspath") +val kotlinxSerializationCompilerPluginClasspath = configurations.create("kotlinxSerializationCompilerPluginClasspath") +val allOpenCompilerPluginClasspath = configurations.create("allOpenCompilerPluginClasspath") dependencies { add(btaImplClasspath.name, project(":compiler:build-tools:kotlin-build-tools-impl")) add(btaImplClasspath.name, project(":compiler:build-tools:kotlin-build-tools-compat")) add(scriptingCompilerPluginClasspath.name, project(":kotlin-scripting-compiler-embeddable")) + add(kotlinxSerializationCompilerPluginClasspath.name, project(":kotlinx-serialization-compiler-plugin.embeddable")) { + isTransitive = false + } + add(allOpenCompilerPluginClasspath.name, project(":kotlin-allopen-compiler-plugin.embeddable")) { + isTransitive = false + } } sourceSets { @@ -68,15 +76,25 @@ workingDir = rootDir val btaImplClasspathFiles: FileCollection = btaImplClasspath val scriptingPluginClasspathFiles: FileCollection = scriptingCompilerPluginClasspath + val serializationPluginClasspathFiles: FileCollection = kotlinxSerializationCompilerPluginClasspath inputs.files(btaImplClasspathFiles) .withPropertyName("btaImplClasspath") .withNormalizer(ClasspathNormalizer::class) inputs.files(scriptingPluginClasspathFiles) .withPropertyName("scriptingCompilerPluginClasspath") .withNormalizer(ClasspathNormalizer::class) + inputs.files(serializationPluginClasspathFiles) + .withPropertyName("kotlinxSerializationCompilerPluginClasspath") + .withNormalizer(ClasspathNormalizer::class) + val allOpenPluginClasspathFiles: FileCollection = allOpenCompilerPluginClasspath + inputs.files(allOpenPluginClasspathFiles) + .withPropertyName("allOpenCompilerPluginClasspath") + .withNormalizer(ClasspathNormalizer::class) doFirst { systemProperty("kotlinJsr223BtaImplClasspath", btaImplClasspathFiles.asPath) systemProperty("kotlinJsr223BtaScriptingPluginClasspath", scriptingPluginClasspathFiles.asPath) + systemProperty("kotlin.script.test.kotlinx.serialization.plugin.classpath", serializationPluginClasspathFiles.asPath) + systemProperty("kotlin.script.test.allopen.plugin.classpath", allOpenPluginClasspathFiles.asPath) } } }
diff --git a/libraries/examples/scripting/jsr223-bta/src/org/jetbrains/kotlin/jsr223/bta/BtaReplCompiler.kt b/libraries/examples/scripting/jsr223-bta/src/org/jetbrains/kotlin/jsr223/bta/BtaReplCompiler.kt index a2c2c21..e1cd071 100644 --- a/libraries/examples/scripting/jsr223-bta/src/org/jetbrains/kotlin/jsr223/bta/BtaReplCompiler.kt +++ b/libraries/examples/scripting/jsr223-bta/src/org/jetbrains/kotlin/jsr223/bta/BtaReplCompiler.kt
@@ -5,25 +5,12 @@ package org.jetbrains.kotlin.jsr223.bta -import org.jetbrains.kotlin.buildtools.api.CompilationResult -import org.jetbrains.kotlin.buildtools.api.DelicateBuildToolsApi -import org.jetbrains.kotlin.buildtools.api.DeprecatedCompilerArgument -import org.jetbrains.kotlin.buildtools.api.ExecutionPolicy -import org.jetbrains.kotlin.buildtools.api.KotlinLogger -import org.jetbrains.kotlin.buildtools.api.KotlinToolchains -import org.jetbrains.kotlin.buildtools.api.arguments.CommonCompilerArguments -import org.jetbrains.kotlin.buildtools.api.arguments.CompilerPlugin -import org.jetbrains.kotlin.buildtools.api.arguments.CompilerPluginOption -import org.jetbrains.kotlin.buildtools.api.arguments.ExperimentalCompilerArgument -import org.jetbrains.kotlin.buildtools.api.arguments.JvmCompilerArguments +import org.jetbrains.kotlin.buildtools.api.* +import org.jetbrains.kotlin.buildtools.api.arguments.* import org.jetbrains.kotlin.buildtools.api.jvm.JvmPlatformToolchain.Companion.jvm import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.ScriptNames -import org.jetbrains.kotlin.scripting.compiler.plugin.KOTLIN_SCRIPTING_PLUGIN_ID -import org.jetbrains.kotlin.scripting.compiler.plugin.ReplSnippetConfigurationCodec -import org.jetbrains.kotlin.scripting.compiler.plugin.ScriptTemplateWithClasspath -import org.jetbrains.kotlin.scripting.compiler.plugin.scriptTemplateWithClasspath -import org.jetbrains.kotlin.scripting.compiler.plugin.withRefinedFromSnippetClass +import org.jetbrains.kotlin.scripting.compiler.plugin.* import java.io.File import java.io.IOException import java.nio.file.Files @@ -87,6 +74,7 @@ private val priorOutputDirs = mutableListOf<Path>() private val priorClassIds = mutableListOf<ClassId>() + private var plugins = StatelessReplCompilerPlugins.EMPTY private var scriptTemplateCache: Pair<Any, ScriptTemplateWithClasspath?>? = null @@ -162,23 +150,50 @@ try { val scriptFiles = refinedSnippets.map { sourceDir.resolve(it.name).also { file -> file.writeText(it.snippet.text) } } - logger.clear() - val result = runCompilation(scriptFiles, outputDir, configurationFile, batchConfiguration) + fun compile(output: Path, pluginSet: StatelessReplCompilerPlugins): CompilationResult { + logger.clear() + return runCompilation(scriptFiles, output, configurationFile, batchConfiguration, pluginSet) + } + + var candidatePlugins = plugins + var finalOutputDir = outputDir + var result = compile(outputDir, candidatePlugins) + // The compiler reports compiler plugins requested by the snippets, but not loaded yet, in a dedicated diagnostic. + val requestedPlugins = try { + logger.messages.mapNotNull(StatelessReplPluginRequestsCodec::extractMissingPluginRequests) + .takeIf { it.isNotEmpty() }?.flatten() + } catch (exception: Exception) { + return ResultWithDiagnostics.Failure( + "BtaReplCompiler: unable to decode compiler plugin requests: ${exception.message}".asErrorDiagnostics() + ) + } + if (requestedPlugins != null) { + candidatePlugins = plugins.merge(requestedPlugins).valueOr { return it } + + finalOutputDir = Files.createDirectories(workRoot.resolve("snippet-batch-$batchIndex-retry-out")) + result = compile(finalOutputDir, candidatePlugins) + if (logger.messages.any { StatelessReplPluginRequestsCodec.extractMissingPluginRequests(it) != null }) { + return ResultWithDiagnostics.Failure( + "BtaReplCompiler: compiler requested plugins after its single retry".asErrorDiagnostics() + ) + } + } + if (result != COMPILATION_SUCCESS) { return ResultWithDiagnostics.Failure( logger.messages.map { it.asErrorDiagnostics(path = refinedSnippets.last().snippet.locationId) } ) } - priorOutputDirs.add(outputDir) + priorOutputDirs.add(finalOutputDir) for ([refinedSnippet, scriptFile] in refinedSnippets.zip(scriptFiles)) { val classId = snippetClassId(scriptFile) // Brings in compiler-side refinement results, e.g. `@DependsOn`-resolved jars. val compilationConfiguration = refinedSnippet.configuration.withRefinedFromSnippetClass( - outputDir.resolve("${classId.shortClassName.asString()}.class").toFile() + finalOutputDir.resolve("${classId.shortClassName.asString()}.class").toFile() ) val compiledSnippet = compiledSnippetFromClassPath( - classPath = listOf(outputDir.toFile()), + classPath = listOf(finalOutputDir.toFile()), snippetClassFQName = classId.asSingleFqName().asString(), snippet = refinedSnippet.snippet, compilationConfiguration = compilationConfiguration, @@ -186,6 +201,7 @@ priorClassIds += classId lastCompiledSnippetInternal = lastCompiledSnippetInternal.add(compiledSnippet) } + plugins = candidatePlugins reports += logger.messages.map { ScriptDiagnostic( ScriptDiagnostic.unspecifiedInfo, it, ScriptDiagnostic.Severity.WARNING, @@ -198,19 +214,22 @@ } } - @OptIn(ExperimentalCompilerArgument::class, DeprecatedCompilerArgument::class) + @OptIn(ExperimentalCompilerArgument::class) private fun runCompilation( scriptFiles: List<Path>, outputDir: Path, configurationFile: Path, batchConfiguration: ScriptCompilationConfiguration, + plugins: StatelessReplCompilerPlugins, ): CompilationResult { val operation = toolchain.jvm.jvmCompilationOperationBuilder(scriptFiles, outputDir) operation.compilerArguments.let { arguments -> arguments[JvmCompilerArguments.CLASSPATH] = additionalClasspath + priorSnippetsResolvedClasspath() + priorOutputDirs arguments[CommonCompilerArguments.X_ALLOW_ANY_SCRIPTS_IN_SOURCE_ROOTS] = true arguments[CommonCompilerArguments.X_SUPPRESS_VERSION_WARNINGS] = true - arguments[CommonCompilerArguments.COMPILER_PLUGINS] = listOf(scriptingPlugin(configurationFile, batchConfiguration)) + arguments[CommonCompilerArguments.COMPILER_PLUGINS] = + listOf(scriptingPlugin(configurationFile, batchConfiguration, plugins)) + + plugins.asBtaCompilerPlugins() } return session.executeOperation(operation.build(), executionPolicy, logger) } @@ -219,7 +238,11 @@ * The scripting compiler plugin declaration that switches this compilation into * chained-REPL-snippet mode. */ - private fun scriptingPlugin(configurationFile: Path, batchConfiguration: ScriptCompilationConfiguration): CompilerPlugin = + private fun scriptingPlugin( + configurationFile: Path, + batchConfiguration: ScriptCompilationConfiguration, + plugins: StatelessReplCompilerPlugins, + ): CompilerPlugin = CompilerPlugin( pluginId = KOTLIN_SCRIPTING_PLUGIN_ID, classpath = scriptingPluginClasspath, @@ -229,6 +252,9 @@ add(CompilerPluginOption("repl-snippet-prior-class", classId.asString())) } add(CompilerPluginOption("repl-snippet-configuration", configurationFile.toAbsolutePath().toString())) + plugins.loadedKeyOptions().forEach { + add(CompilerPluginOption("repl-snippet-loaded-plugin", it)) + } // Refinement handlers are transient and cannot travel in the configuration file, so the compiler // loads the definition from its template and overrides it with the configuration from the file. scriptTemplateWithClasspathOf(batchConfiguration)?.let { template -> @@ -243,6 +269,20 @@ orderingRequirements = emptySet(), ) + private fun StatelessReplCompilerPlugins.asBtaCompilerPlugins(): List<CompilerPlugin> = + entries().map { [_, pluginId, classpath, options] -> + CompilerPlugin( + pluginId = pluginId, + classpath = classpath.map { it.toPath() }, + rawArguments = options.map { option -> + val separator = option.indexOf('=') + require(separator > 0) { "Invalid compiler plugin option '$option'." } + CompilerPluginOption(option.substring(0, separator), option.substring(separator + 1)) + }, + orderingRequirements = emptySet(), + ) + } + private fun scriptTemplateWithClasspathOf(configuration: ScriptCompilationConfiguration): ScriptTemplateWithClasspath? { val key = configuration[ScriptCompilationConfiguration.baseClass] to configuration[ScriptCompilationConfiguration.hostConfiguration]
diff --git a/libraries/examples/scripting/jsr223-bta/test/org/jetbrains/kotlin/jsr223/bta/test/KotlinJsr223BtaScriptEngineMainKtsTest.kt b/libraries/examples/scripting/jsr223-bta/test/org/jetbrains/kotlin/jsr223/bta/test/KotlinJsr223BtaScriptEngineMainKtsTest.kt index be15cbd..1ef3c6a 100644 --- a/libraries/examples/scripting/jsr223-bta/test/org/jetbrains/kotlin/jsr223/bta/test/KotlinJsr223BtaScriptEngineMainKtsTest.kt +++ b/libraries/examples/scripting/jsr223-bta/test/org/jetbrains/kotlin/jsr223/bta/test/KotlinJsr223BtaScriptEngineMainKtsTest.kt
@@ -14,9 +14,18 @@ import org.junit.jupiter.api.Test import java.io.File import java.nio.file.Files +import java.nio.file.Path import java.util.jar.JarEntry import java.util.jar.JarOutputStream +import javax.script.ScriptException import kotlin.io.path.invariantSeparatorsPathString +import kotlin.script.experimental.api.valueOrThrow +import kotlin.script.experimental.dependencies.CompoundDependenciesResolver +import kotlin.script.experimental.dependencies.maven.MavenDependenciesResolver +import kotlin.script.experimental.impl.internalScriptingRunSuspend +import kotlin.test.assertContains +import kotlin.test.assertFailsWith +import kotlin.test.assertTrue import kotlin.script.experimental.jvmhost.createJvmScriptDefinitionFromTemplate /** @@ -27,12 +36,19 @@ private val mainKtsScriptDefinition = createJvmScriptDefinitionFromTemplate<MainKtsScript>() - private fun newEngine(withMainKtsOnCompileClasspath: Boolean = false): KotlinJsr223BtaScriptEngineImpl { + private fun newEngine( + withMainKtsOnCompileClasspath: Boolean = false, + withSerializationRuntime: Boolean = false, + ): KotlinJsr223BtaScriptEngineImpl { + val additionalClasspath = buildList { + addAll(listOf(stdlibPath, scriptRuntimePath)) + if (withSerializationRuntime) addAll(serializationRuntimeClasspath()) + if (withMainKtsOnCompileClasspath) addAll(mainKtsPaths) + } val factory = KotlinJsr223BtaScriptEngineFactory( compilerClasspath = classpathFromSystemProperty("kotlinJsr223BtaImplClasspath"), scriptingPluginClasspath = classpathFromSystemProperty("kotlinJsr223BtaScriptingPluginClasspath"), - additionalClasspath = listOf(stdlibPath, scriptRuntimePath) + - if (withMainKtsOnCompileClasspath) mainKtsPaths else emptyList(), + additionalClasspath = additionalClasspath, daemonRunFilesPath = daemonRunFilesPath, daemonLogsPath = daemonLogsPath, daemonShutdownDelayMillis = 0, @@ -108,6 +124,142 @@ } @Test + fun testSerializationCompilerPluginPersistsAcrossSnippets() { + val engine = newEngine(withMainKtsOnCompileClasspath = true, withSerializationRuntime = true) + assertEquals( + null, + engine.eval( + """ + ${serializationPluginAnnotation()} + import kotlinx.serialization.Serializable + + @Serializable + data class User(val name: String) + """.trimIndent() + ) + ) + assertEquals( + null, + engine.eval( + """ + ${serializationPluginAnnotation()} + import kotlinx.serialization.Serializable + + @Serializable + data class Project(val name: String) + """.trimIndent() + ) + ) + + val descriptorNames = engine.eval( + "User.serializer().descriptor.serialName + \"|\" + Project.serializer().descriptor.serialName" + ).toString().split('|') + assertEquals(2, descriptorNames.size) + assertTrue(descriptorNames[0].endsWith(".User")) + assertTrue(descriptorNames[1].endsWith(".Project")) + } + + @Test + fun testSeveralCompilerPluginsRequestedBySingleSnippetPersistAcrossSnippets() { + val engine = newEngine(withMainKtsOnCompileClasspath = true, withSerializationRuntime = true) + assertEquals( + null, + engine.eval( + """ + ${serializationPluginAnnotation()} + ${allOpenPluginAnnotation()} + import kotlinx.serialization.Serializable + + @Serializable + class User(val name: String) + """.trimIndent() + ) + ) + // The all-open plugin makes serializable classes open, so they can be subclassed. + assertEquals( + null, + engine.eval( + """ + import kotlinx.serialization.Serializable + + class Admin(name: String) : User(name) + + @Serializable + class Project(val name: String) + + class InternalProject(name: String) : Project(name) + """.trimIndent() + ) + ) + + val descriptorNames = engine.eval( + "User.serializer().descriptor.serialName + \"|\" + Project.serializer().descriptor.serialName" + ).toString().split('|') + assertEquals(2, descriptorNames.size) + assertTrue(descriptorNames[0].endsWith(".User")) + assertTrue(descriptorNames[1].endsWith(".Project")) + assertEquals("a|b", engine.eval("Admin(\"a\").name + \"|\" + InternalProject(\"b\").name")) + } + + @Test + fun testSerializationCompilerPluginConflictKeepsOriginalOptions() { + val engine = newEngine(withMainKtsOnCompileClasspath = true, withSerializationRuntime = true) + engine.eval( + """ + ${serializationPluginAnnotation()} + import kotlinx.serialization.Serializable + + @Serializable + data class User(val name: String) + """.trimIndent() + ) + + val conflict = assertFailsWith<ScriptException> { + engine.eval( + """ + ${serializationPluginAnnotation("disableIntrinsic=true")} + import kotlinx.serialization.Serializable + + @Serializable + data class Project(val name: String) + """.trimIndent() + ) + } + assertContains(conflict.message.orEmpty(), "conflicting options for compiler plugin", ignoreCase = true) + assertTrue(engine.eval("User.serializer().descriptor.serialName").toString().endsWith(".User")) + } + + @Test + fun testSerializationCompilerPluginIsNotCommittedAfterFailedBatch() { + val engine = newEngine(withMainKtsOnCompileClasspath = true, withSerializationRuntime = true) + assertFailsWith<ScriptException> { + engine.eval( + """ + ${serializationPluginAnnotation()} + import kotlinx.serialization.Serializable + + @Serializable + data class Broken(val name: String) + unresolvedName + """.trimIndent() + ) + } + + val afterRollback = assertFailsWith<ScriptException> { + engine.eval( + """ + import kotlinx.serialization.Serializable + + @Serializable + data class AfterFailure(val name: String) + AfterFailure.serializer().descriptor.serialName + """.trimIndent() + ) + } + assertContains(afterRollback.message.orEmpty(), "serializer", ignoreCase = true) + } + + @Test @Disabled("Same-batch @file:Import snippet chaining is not supported yet (codegen of cross-snippet accesses)") fun testWithImport() { val engine = newEngine() @@ -126,6 +278,32 @@ // Absolute, since `@file:Import` paths are resolved relative to the (temporary) snippet source file. private val TEST_DATA_ROOT = File("libraries/tools/kotlin-main-kts-test/testData").absoluteFile.invariantSeparatorsPath +private fun serializationPluginAnnotation(options: String? = null): String { + val optionArgument = options?.let { ", \"$it\"" }.orEmpty() + return """@file:CompilerPlugin("${serializationPluginClasspathForScript()}"$optionArgument)""" +} + +private fun allOpenPluginAnnotation(): String { + val classpath = System.getProperty("kotlin.script.test.allopen.plugin.classpath")!! + .split(File.pathSeparator) + .joinToString(File.pathSeparator) { it.replace(File.separatorChar, '/') } + return """@file:CompilerPlugin("$classpath", "annotation=kotlinx.serialization.Serializable")""" +} + +private fun serializationPluginClasspathForScript(): String = + System.getProperty("kotlin.script.test.kotlinx.serialization.plugin.classpath")!! + .split(File.pathSeparator) + .joinToString(File.pathSeparator) { it.replace(File.separatorChar, '/') } + +@Suppress("DEPRECATION_ERROR") +private fun serializationRuntimeClasspath(): List<Path> = + internalScriptingRunSuspend { + CompoundDependenciesResolver(MavenDependenciesResolver()) + .resolve("org.jetbrains.kotlinx:kotlinx-serialization-core:1.8.1") + .valueOrThrow() + .map(File::toPath) + } + object DependsOnProbe { const val VALUE: String = "resolved" }
diff --git a/libraries/examples/scripting/jsr223-daemon/build.gradle.kts b/libraries/examples/scripting/jsr223-daemon/build.gradle.kts index b0cddcb..e08e64b 100644 --- a/libraries/examples/scripting/jsr223-daemon/build.gradle.kts +++ b/libraries/examples/scripting/jsr223-daemon/build.gradle.kts
@@ -28,11 +28,18 @@ } val daemonCompilerClasspath = configurations.create("daemonCompilerClasspath") +val kotlinxSerializationCompilerPluginClasspath = configurations.create("kotlinxSerializationCompilerPluginClasspath") +val allOpenCompilerPluginClasspath = configurations.create("allOpenCompilerPluginClasspath") dependencies { add(daemonCompilerClasspath.name, project(":kotlin-compiler")) add(daemonCompilerClasspath.name, project(":kotlin-daemon")) add(daemonCompilerClasspath.name, project(":kotlin-scripting-compiler")) + add(kotlinxSerializationCompilerPluginClasspath.name, project(":kotlinx-serialization-compiler-plugin.embeddable")) { + isTransitive = false + } + add(allOpenCompilerPluginClasspath.name, project(":kotlin-allopen-compiler-plugin")) { isTransitive = false } + testImplementation(project(":kotlin-scripting-dependencies-maven")) } sourceSets { @@ -51,8 +58,18 @@ dependsOn(":dist") workingDir = rootDir val classpathProvider = project.provider { daemonCompilerClasspath.files.joinToString(File.pathSeparator) } + val serializationPluginClasspathFiles: FileCollection = kotlinxSerializationCompilerPluginClasspath + inputs.files(serializationPluginClasspathFiles) + .withPropertyName("kotlinxSerializationCompilerPluginClasspath") + .withNormalizer(ClasspathNormalizer::class) + val allOpenPluginClasspathFiles: FileCollection = allOpenCompilerPluginClasspath + inputs.files(allOpenPluginClasspathFiles) + .withPropertyName("allOpenCompilerPluginClasspath") + .withNormalizer(ClasspathNormalizer::class) doFirst { systemProperty("kotlinJsr223DaemonCompilerClasspath", classpathProvider.get()) + systemProperty("kotlin.script.test.kotlinx.serialization.plugin.classpath", serializationPluginClasspathFiles.asPath) + systemProperty("kotlin.script.test.allopen.plugin.classpath", allOpenPluginClasspathFiles.asPath) } } }
diff --git a/libraries/examples/scripting/jsr223-daemon/src/org/jetbrains/kotlin/jsr223/daemon/DaemonReplCompiler.kt b/libraries/examples/scripting/jsr223-daemon/src/org/jetbrains/kotlin/jsr223/daemon/DaemonReplCompiler.kt index 4e3e895..aee7143 100644 --- a/libraries/examples/scripting/jsr223-daemon/src/org/jetbrains/kotlin/jsr223/daemon/DaemonReplCompiler.kt +++ b/libraries/examples/scripting/jsr223-daemon/src/org/jetbrains/kotlin/jsr223/daemon/DaemonReplCompiler.kt
@@ -16,11 +16,7 @@ import org.jetbrains.kotlin.daemon.common.* import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.ScriptNames -import org.jetbrains.kotlin.scripting.compiler.plugin.KOTLIN_SCRIPTING_PLUGIN_ID -import org.jetbrains.kotlin.scripting.compiler.plugin.ReplSnippetConfigurationCodec -import org.jetbrains.kotlin.scripting.compiler.plugin.ScriptTemplateWithClasspath -import org.jetbrains.kotlin.scripting.compiler.plugin.scriptTemplateWithClasspath -import org.jetbrains.kotlin.scripting.compiler.plugin.withRefinedFromSnippetClass +import org.jetbrains.kotlin.scripting.compiler.plugin.* import java.io.File import java.io.Serializable import java.nio.file.Files @@ -109,6 +105,7 @@ private val priorOutputDirs = mutableListOf<File>() private val priorClassIds = mutableListOf<ClassId>() + private var plugins = StatelessReplCompilerPlugins.EMPTY private var scriptTemplateCache: Pair<Any, ScriptTemplateWithClasspath?>? = null @@ -172,34 +169,66 @@ } val batchIndex = snippetCounter++ - val outputDir = File(workRoot, "snippet-batch-$batchIndex-out").also { it.mkdirs() } + var finalOutputDir = File(workRoot, "snippet-batch-$batchIndex-out").also { it.mkdirs() } val configurationFile = File(workRoot, "snippet-batch-$batchIndex-configuration.bin").also { ReplSnippetConfigurationCodec.writeTo(batchConfiguration, it) } val sourceDir = Files.createTempDirectory("jsr223-daemon-repl-snippet-src-").toFile() try { val scriptFiles = refinedSnippets.map { File(sourceDir, it.name).also { file -> file.writeText(it.snippet.text) } } - val arguments = buildBatchCompilerArguments( - scriptFiles, priorOutputDirs, priorClassIds, outputDir, configurationFile, batchConfiguration - ) - messageCollector.clear() - val exitCode = runDaemonCompile(arguments) + fun compile(outputDir: File, pluginSet: StatelessReplCompilerPlugins): Int { + messageCollector.clear() + val arguments = buildBatchCompilerArguments( + scriptFiles, + priorOutputDirs, + priorClassIds, + outputDir, + configurationFile, + batchConfiguration, + pluginSet, + ) + return runDaemonCompile(arguments) + } + + var candidatePlugins = plugins + var exitCode = compile(finalOutputDir, candidatePlugins) + // The compiler reports compiler plugins requested by the snippets, but not loaded yet, in a dedicated diagnostic. + val requestedPlugins = try { + messageCollector.messages.mapNotNull(StatelessReplPluginRequestsCodec::extractMissingPluginRequests) + .takeIf { it.isNotEmpty() }?.flatten() + } catch (exception: Exception) { + return ResultWithDiagnostics.Failure( + "DaemonReplCompiler: unable to decode compiler plugin requests: ${exception.message}".asErrorDiagnostics() + ) + } + if (requestedPlugins != null) { + candidatePlugins = plugins.merge(requestedPlugins).valueOr { return it } + + finalOutputDir = File(workRoot, "snippet-batch-$batchIndex-retry-out").also { it.mkdirs() } + exitCode = compile(finalOutputDir, candidatePlugins) + if (messageCollector.messages.any { StatelessReplPluginRequestsCodec.extractMissingPluginRequests(it) != null }) { + return ResultWithDiagnostics.Failure( + "DaemonReplCompiler: compiler requested plugins after its single retry".asErrorDiagnostics() + ) + } + } + if (exitCode != ExitCode.OK.code) { return ResultWithDiagnostics.Failure( messageCollector.messages.map { it.asErrorDiagnostics(path = refinedSnippets.last().snippet.locationId) } ) } - priorOutputDirs += outputDir + priorOutputDirs += finalOutputDir for ([refinedSnippet, scriptFile] in refinedSnippets.zip(scriptFiles)) { val classId = snippetClassId(scriptFile) // Brings in compiler-side refinement results, e.g. `@DependsOn`-resolved jars. val compilationConfiguration = refinedSnippet.configuration.withRefinedFromSnippetClass( - File(outputDir, "${classId.shortClassName.asString()}.class") + File(finalOutputDir, "${classId.shortClassName.asString()}.class") ) val compiledSnippet = compiledSnippetFromClassPath( - classPath = listOf(outputDir), + classPath = listOf(finalOutputDir), snippetClassFQName = classId.asSingleFqName().asString(), snippet = refinedSnippet.snippet, compilationConfiguration = compilationConfiguration, @@ -207,6 +236,7 @@ priorClassIds += classId lastCompiledSnippetInternal = lastCompiledSnippetInternal.add(compiledSnippet) } + plugins = candidatePlugins reports += messageCollector.messages.map { ScriptDiagnostic( ScriptDiagnostic.unspecifiedInfo, it, ScriptDiagnostic.Severity.WARNING, @@ -226,6 +256,7 @@ outputDir: File, configurationFile: File, batchConfiguration: ScriptCompilationConfiguration, + plugins: StatelessReplCompilerPlugins, ): List<String> { fun pluginOption(name: String, value: String) = "plugin:$KOTLIN_SCRIPTING_PLUGIN_ID:$name=$value" return buildList { @@ -247,6 +278,10 @@ } add("-P") add(pluginOption("repl-snippet-configuration", configurationFile.absolutePath)) + plugins.loadedKeyOptions().forEach { loadedPlugin -> + add("-P") + add(pluginOption("repl-snippet-loaded-plugin", loadedPlugin)) + } // Refinement handlers are transient and cannot travel in the configuration file, so the compiler // loads the definition from its template and overrides it with the configuration from the file. scriptTemplateWithClasspathOf(batchConfiguration)?.let { template -> @@ -255,6 +290,7 @@ add("-P") add(pluginOption("script-definitions-classpath", template.classpath.joinToString(File.pathSeparator) { it.path })) } + addAll(plugins.cliArguments()) add("-d") add(outputDir.absolutePath) add("-Xsuppress-version-warnings")
diff --git a/libraries/examples/scripting/jsr223-daemon/test/org/jetbrains/kotlin/jsr223/daemon/test/KotlinJsr223DaemonScriptEngineMainKtsTest.kt b/libraries/examples/scripting/jsr223-daemon/test/org/jetbrains/kotlin/jsr223/daemon/test/KotlinJsr223DaemonScriptEngineMainKtsTest.kt index d895cd7..ec68655 100644 --- a/libraries/examples/scripting/jsr223-daemon/test/org/jetbrains/kotlin/jsr223/daemon/test/KotlinJsr223DaemonScriptEngineMainKtsTest.kt +++ b/libraries/examples/scripting/jsr223-daemon/test/org/jetbrains/kotlin/jsr223/daemon/test/KotlinJsr223DaemonScriptEngineMainKtsTest.kt
@@ -5,10 +5,10 @@ package org.jetbrains.kotlin.jsr223.daemon.test -import org.jetbrains.kotlin.jsr223.daemon.KotlinJsr223DaemonScriptEngineFactory -import org.jetbrains.kotlin.jsr223.daemon.KotlinJsr223DaemonScriptEngineImpl import org.jetbrains.kotlin.daemon.common.DaemonLogOptions import org.jetbrains.kotlin.daemon.common.DaemonOptions +import org.jetbrains.kotlin.jsr223.daemon.KotlinJsr223DaemonScriptEngineFactory +import org.jetbrains.kotlin.jsr223.daemon.KotlinJsr223DaemonScriptEngineImpl import org.jetbrains.kotlin.mainKts.MainKtsScript import org.junit.jupiter.api.AfterEach import org.junit.jupiter.api.Assertions.assertEquals @@ -20,8 +20,16 @@ import java.nio.file.Path import java.util.jar.JarEntry import java.util.jar.JarOutputStream +import javax.script.ScriptException import kotlin.io.path.invariantSeparatorsPathString +import kotlin.script.experimental.api.valueOrThrow +import kotlin.script.experimental.dependencies.CompoundDependenciesResolver +import kotlin.script.experimental.dependencies.maven.MavenDependenciesResolver +import kotlin.script.experimental.impl.internalScriptingRunSuspend import kotlin.script.experimental.jvmhost.createJvmScriptDefinitionFromTemplate +import kotlin.test.assertContains +import kotlin.test.assertFailsWith +import kotlin.test.assertTrue /** * Ports a few jsr223-specific main-kts tests (see `MainKtsJsr223Test` in `kotlin-main-kts-test`) to @@ -41,11 +49,18 @@ private val dirsToDeleteAfterEngines = mutableListOf<Path>() - private fun newEngine(withMainKtsOnCompileClasspath: Boolean = false): KotlinJsr223DaemonScriptEngineImpl { + private fun newEngine( + withMainKtsOnCompileClasspath: Boolean = false, + withSerializationRuntime: Boolean = false, + ): KotlinJsr223DaemonScriptEngineImpl { + val additionalClasspath = buildList { + addAll(listOf(stdlibPath, scriptRuntimePath)) + if (withSerializationRuntime) addAll(serializationRuntimeClasspath()) + if (withMainKtsOnCompileClasspath) addAll(mainKtsPaths) + } val factory = KotlinJsr223DaemonScriptEngineFactory( compilerClasspath = compilerClasspath, - additionalClasspath = listOf(stdlibPath, scriptRuntimePath) + - if (withMainKtsOnCompileClasspath) mainKtsPaths else emptyList(), + additionalClasspath = additionalClasspath, daemonOptions = DaemonOptions( runFilesPath = daemonRunDir.resolve("run").toString(), shutdownDelayMilliseconds = 0, @@ -135,6 +150,142 @@ } @Test + fun testSerializationCompilerPluginPersistsAcrossSnippets() { + val engine = newEngine(withMainKtsOnCompileClasspath = true, withSerializationRuntime = true) + assertEquals( + null, + engine.eval( + """ + ${serializationPluginAnnotation()} + import kotlinx.serialization.Serializable + + @Serializable + data class User(val name: String) + """.trimIndent() + ) + ) + assertEquals( + null, + engine.eval( + """ + ${serializationPluginAnnotation()} + import kotlinx.serialization.Serializable + + @Serializable + data class Project(val name: String) + """.trimIndent() + ) + ) + + val descriptorNames = engine.eval( + "User.serializer().descriptor.serialName + \"|\" + Project.serializer().descriptor.serialName" + ).toString().split('|') + assertEquals(2, descriptorNames.size) + assertTrue(descriptorNames[0].endsWith(".User")) + assertTrue(descriptorNames[1].endsWith(".Project")) + } + + @Test + fun testSeveralCompilerPluginsRequestedBySingleSnippetPersistAcrossSnippets() { + val engine = newEngine(withMainKtsOnCompileClasspath = true, withSerializationRuntime = true) + assertEquals( + null, + engine.eval( + """ + ${serializationPluginAnnotation()} + ${allOpenPluginAnnotation()} + import kotlinx.serialization.Serializable + + @Serializable + class User(val name: String) + """.trimIndent() + ) + ) + // The all-open plugin makes serializable classes open, so they can be subclassed. + assertEquals( + null, + engine.eval( + """ + import kotlinx.serialization.Serializable + + class Admin(name: String) : User(name) + + @Serializable + class Project(val name: String) + + class InternalProject(name: String) : Project(name) + """.trimIndent() + ) + ) + + val descriptorNames = engine.eval( + "User.serializer().descriptor.serialName + \"|\" + Project.serializer().descriptor.serialName" + ).toString().split('|') + assertEquals(2, descriptorNames.size) + assertTrue(descriptorNames[0].endsWith(".User")) + assertTrue(descriptorNames[1].endsWith(".Project")) + assertEquals("a|b", engine.eval("Admin(\"a\").name + \"|\" + InternalProject(\"b\").name")) + } + + @Test + fun testSerializationCompilerPluginConflictKeepsOriginalOptions() { + val engine = newEngine(withMainKtsOnCompileClasspath = true, withSerializationRuntime = true) + engine.eval( + """ + ${serializationPluginAnnotation()} + import kotlinx.serialization.Serializable + + @Serializable + data class User(val name: String) + """.trimIndent() + ) + + val conflict = assertFailsWith<ScriptException> { + engine.eval( + """ + ${serializationPluginAnnotation("disableIntrinsic=true")} + import kotlinx.serialization.Serializable + + @Serializable + data class Project(val name: String) + """.trimIndent() + ) + } + assertContains(conflict.message.orEmpty(), "conflicting options for compiler plugin", ignoreCase = true) + assertTrue(engine.eval("User.serializer().descriptor.serialName").toString().endsWith(".User")) + } + + @Test + fun testSerializationCompilerPluginIsNotCommittedAfterFailedBatch() { + val engine = newEngine(withMainKtsOnCompileClasspath = true, withSerializationRuntime = true) + assertFailsWith<ScriptException> { + engine.eval( + """ + ${serializationPluginAnnotation()} + import kotlinx.serialization.Serializable + + @Serializable + data class Broken(val name: String) + unresolvedName + """.trimIndent() + ) + } + + val afterRollback = assertFailsWith<ScriptException> { + engine.eval( + """ + import kotlinx.serialization.Serializable + + @Serializable + data class AfterFailure(val name: String) + AfterFailure.serializer().descriptor.serialName + """.trimIndent() + ) + } + assertContains(afterRollback.message.orEmpty(), "serializer", ignoreCase = true) + } + + @Test @Disabled("Same-batch @file:Import snippet chaining is not supported yet (codegen of cross-snippet accesses)") fun testWithImport() { val engine = newEngine() @@ -153,6 +304,32 @@ // Absolute, since `@file:Import` paths are resolved relative to the (temporary) snippet source file. private val TEST_DATA_ROOT = File("libraries/tools/kotlin-main-kts-test/testData").absoluteFile.invariantSeparatorsPath +private fun serializationPluginAnnotation(options: String? = null): String { + val optionArgument = options?.let { ", \"$it\"" }.orEmpty() + return """@file:CompilerPlugin("${serializationPluginClasspathForScript()}"$optionArgument)""" +} + +private fun allOpenPluginAnnotation(): String { + val classpath = System.getProperty("kotlin.script.test.allopen.plugin.classpath")!! + .split(File.pathSeparator) + .joinToString(File.pathSeparator) { it.replace(File.separatorChar, '/') } + return """@file:CompilerPlugin("$classpath", "annotation=kotlinx.serialization.Serializable")""" +} + +private fun serializationPluginClasspathForScript(): String = + System.getProperty("kotlin.script.test.kotlinx.serialization.plugin.classpath")!! + .split(File.pathSeparator) + .joinToString(File.pathSeparator) { it.replace(File.separatorChar, '/') } + +@Suppress("DEPRECATION_ERROR") +private fun serializationRuntimeClasspath(): List<Path> = + internalScriptingRunSuspend { + CompoundDependenciesResolver(MavenDependenciesResolver()) + .resolve("org.jetbrains.kotlinx:kotlinx-serialization-core:1.8.1") + .valueOrThrow() + .map(File::toPath) + } + object DependsOnProbe { const val VALUE: String = "resolved" }
diff --git a/plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/configuration/ScriptingConfigurationKeys.kt b/plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/configuration/ScriptingConfigurationKeys.kt index 2ce5317..89b2109 100644 --- a/plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/configuration/ScriptingConfigurationKeys.kt +++ b/plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/configuration/ScriptingConfigurationKeys.kt
@@ -64,4 +64,8 @@ // File with a serialized `ScriptCompilationConfiguration` for the snippets compilation val REPL_SNIPPET_CONFIGURATION_FILE: CompilerConfigurationKey<File> = CompilerConfigurationKey.create("REPL_SNIPPET_CONFIGURATION_FILE") + + // Encoded compiler plugin requests already loaded by the stateless REPL host. + val REPL_SNIPPET_LOADED_PLUGINS: CompilerConfigurationKey<List<String>> = + CompilerConfigurationKey.create("REPL_SNIPPET_LOADED_PLUGINS") }
diff --git a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/FirScriptingCompilerExtensionRegistrar.kt b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/FirScriptingCompilerExtensionRegistrar.kt index d393885..de35815 100644 --- a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/FirScriptingCompilerExtensionRegistrar.kt +++ b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/FirScriptingCompilerExtensionRegistrar.kt
@@ -12,20 +12,10 @@ import org.jetbrains.kotlin.fir.builder.FirReplSnippetConfiguratorExtension import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar import org.jetbrains.kotlin.fir.extensions.FirExtensionSessionComponent -import org.jetbrains.kotlin.fir.extensions.FirReplSnippetResolveExtension -import org.jetbrains.kotlin.scripting.compiler.plugin.services.ClasspathBackedFirReplHistoryProvider -import org.jetbrains.kotlin.scripting.compiler.plugin.services.Fir2IrReplSnippetConfiguratorExtensionImpl -import org.jetbrains.kotlin.scripting.compiler.plugin.services.Fir2IrScriptConfiguratorExtensionImpl -import org.jetbrains.kotlin.scripting.compiler.plugin.services.FirReplSnippetConfiguratorExtensionImpl -import org.jetbrains.kotlin.scripting.compiler.plugin.services.FirReplSnippetResolveExtensionImpl -import org.jetbrains.kotlin.scripting.compiler.plugin.services.FirScriptConfiguratorExtensionImpl -import org.jetbrains.kotlin.scripting.compiler.plugin.services.FirScriptDefinitionProviderService -import org.jetbrains.kotlin.scripting.compiler.plugin.services.FirScriptResolutionConfigurationExtensionImpl -import org.jetbrains.kotlin.scripting.compiler.plugin.services.firReplHistoryProvider -import org.jetbrains.kotlin.scripting.compiler.plugin.services.isReplSnippetSource -import org.jetbrains.kotlin.scripting.configuration.ScriptingConfigurationKeys +import org.jetbrains.kotlin.scripting.compiler.plugin.impl.StatelessReplPluginRequestReporter import org.jetbrains.kotlin.scripting.compiler.plugin.impl.isSnippetDefinition -import org.jetbrains.kotlin.scripting.compiler.plugin.services.scriptDefinitionProviderService +import org.jetbrains.kotlin.scripting.compiler.plugin.services.* +import org.jetbrains.kotlin.scripting.configuration.ScriptingConfigurationKeys import org.jetbrains.kotlin.scripting.resolve.toSourceCode import kotlin.script.experimental.api.ScriptCompilationConfiguration import kotlin.script.experimental.api.repl @@ -46,6 +36,7 @@ +Fir2IrScriptConfiguratorExtensionImpl.getFactory() if (compilerConfiguration.getBoolean(ScriptingConfigurationKeys.REPL_SNIPPET_STATELESS_MODE)) { + val pluginRequestReporter = StatelessReplPluginRequestReporter(compilerConfiguration) val priorClassIds = compilerConfiguration.getList(ScriptingConfigurationKeys.REPL_SNIPPET_PRIOR_CLASSES) var capturedSession: FirSession? = null val historyProvider = ClasspathBackedFirReplHistoryProvider(priorClassIds) { capturedSession } @@ -64,7 +55,7 @@ } +FirReplSnippetConfiguratorExtension.Factory { session -> capturedSession = session - FirReplSnippetConfiguratorExtensionImpl(session, replHostConfiguration) + FirReplSnippetConfiguratorExtensionImpl(session, replHostConfiguration, pluginRequestReporter) } +FirExtensionSessionComponent.Factory { session -> capturedSession = session
diff --git a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/ScriptingCommandLineProcessor.kt b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/ScriptingCommandLineProcessor.kt index 93d563d..d24397f 100644 --- a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/ScriptingCommandLineProcessor.kt +++ b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/ScriptingCommandLineProcessor.kt
@@ -91,6 +91,11 @@ "Path to a file with a serialized ScriptCompilationConfiguration for the snippets compilation", required = false, allowMultipleOccurrences = false ) + val REPL_SNIPPET_LOADED_PLUGIN_OPTION = CliOption( + "repl-snippet-loaded-plugin", "<encoded plugin request>", + "Compiler plugin request already loaded by the stateless REPL host; repeat for each plugin", + required = false, allowMultipleOccurrences = true + ) } override val pluginId = KOTLIN_SCRIPTING_PLUGIN_ID @@ -110,6 +115,7 @@ REPL_SNIPPET_PRIOR_CLASS_OPTION, REPL_SNIPPET_STATELESS_MODE_OPTION, REPL_SNIPPET_CONFIGURATION_OPTION, + REPL_SNIPPET_LOADED_PLUGIN_OPTION, ) override fun processOption(option: AbstractCliOption, value: String, configuration: CompilerConfiguration) = when (option) { @@ -195,6 +201,9 @@ REPL_SNIPPET_CONFIGURATION_OPTION -> { configuration.put(ScriptingConfigurationKeys.REPL_SNIPPET_CONFIGURATION_FILE, File(value)) } + REPL_SNIPPET_LOADED_PLUGIN_OPTION -> { + configuration.add(ScriptingConfigurationKeys.REPL_SNIPPET_LOADED_PLUGINS, value) + } else -> throw CliOptionProcessingException("Unknown option: ${option.optionName}") } }
diff --git a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/StatelessReplCompilerPlugins.kt b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/StatelessReplCompilerPlugins.kt new file mode 100644 index 0000000..4514abc --- /dev/null +++ b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/StatelessReplCompilerPlugins.kt
@@ -0,0 +1,74 @@ +/* + * Copyright 2010-2026 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.scripting.compiler.plugin + +import java.io.File +import kotlin.script.experimental.api.ResultWithDiagnostics +import kotlin.script.experimental.api.asErrorDiagnostics + +class StatelessReplCompilerPlugins private constructor( + private val byKey: Map<String, StatelessReplPluginRequest>, +) { + fun merge(requests: List<StatelessReplPluginRequest>): ResultWithDiagnostics<StatelessReplCompilerPlugins> { + val merged = LinkedHashMap(byKey) + for (request in requests) { + val sameKey = merged[request.key] + if (sameKey != null) { + if (sameKey.pluginId != request.pluginId || sameKey.options != request.options) { + return conflict(sameKey.description()) + } + continue + } + + val samePlugin = merged.values.firstOrNull { it.pluginId == request.pluginId } + if (samePlugin != null) { + if (samePlugin.options != request.options) return conflict(request.pluginId) + continue + } + + merged[request.key] = request + } + return ResultWithDiagnostics.Success(StatelessReplCompilerPlugins(merged)) + } + + fun cliArguments(): List<String> = buildList { + byKey.values.flatMap { it.classpath }.distinct().forEach { classpath -> + add("-Xplugin=${classpath.path}") + } + byKey.values.forEach { [_, pluginId, _, options] -> + options.forEach { option -> + val optionSeparator = option.indexOf('=') + require(optionSeparator > 0) { "Invalid compiler plugin option '$option'." } + val optionName = option.substring(0, optionSeparator) + val optionValue = option.substring(optionSeparator + 1) + add("-P") + add("plugin:$pluginId:$optionName=$optionValue") + } + } + } + + fun loadedKeys(): List<String> = byKey.keys.toList() + + fun entries(): List<StatelessReplPluginRequest> = byKey.values.toList() + + fun loadedKeyOptions(): List<String> = byKey.values.map { [key, pluginId, _, options] -> + StatelessReplPluginRequestsCodec.encodeLoadedPluginOption(key, pluginId, options) + } + + private fun StatelessReplPluginRequest.description(): String { + val classpathKey = classpath.joinToString(File.pathSeparator) { it.absoluteFile.normalize().path } + return if (key == classpathKey) classpath.joinToString(",") { it.path } else key + } + + private fun conflict(pluginDescription: String): ResultWithDiagnostics.Failure = + ResultWithDiagnostics.Failure( + "Conflicting options for compiler plugin '$pluginDescription'.".asErrorDiagnostics() + ) + + companion object { + val EMPTY = StatelessReplCompilerPlugins(emptyMap()) + } +}
diff --git a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/StatelessReplPluginRequests.kt b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/StatelessReplPluginRequests.kt new file mode 100644 index 0000000..15173d9 --- /dev/null +++ b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/StatelessReplPluginRequests.kt
@@ -0,0 +1,91 @@ +/* + * Copyright 2010-2026 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.scripting.compiler.plugin + +import java.io.* +import java.util.* + +data class StatelessReplPluginRequest( + val key: String, + val pluginId: String, + val classpath: List<File>, + val options: List<String>, +) + +data class StatelessReplLoadedPlugin( + val key: String, + val pluginId: String, + val options: List<String>, +) + +object StatelessReplPluginRequestsCodec { + private const val MAX_ENTRIES = 10_000 + private const val MISSING_PLUGIN_HEADER = "Compilation requires compiler plugin " + private const val PLUGIN_CLASSPATH_PREFIX = "-Xplugin=" + private const val PLUGIN_OPTION_PREFIX = "-P plugin:" + private val missingPluginHeaderRegex = Regex("${Regex.escape(MISSING_PLUGIN_HEADER)}'(.+)' \\(id '([^']+)'\\):") + + /** + * Renders the error diagnostic reported by a stateless snippet compilation for a requested compiler plugin + * that is not loaded yet. The header names the request and the plugin id, and it is followed by the legacy + * CLI plugin arguments (`-Xplugin=<jar>` and `-P plugin:<id>:<option>`) needed to load the plugin, one per line, + * so the host can extract the request with [extractMissingPluginRequests] and retry the compilation. + */ + fun missingPluginMessage(request: StatelessReplPluginRequest): String = buildString { + append("$MISSING_PLUGIN_HEADER'${request.key}' (id '${request.pluginId}'):") + request.classpath.forEach { append("\n $PLUGIN_CLASSPATH_PREFIX${it.path}") } + request.options.forEach { append("\n $PLUGIN_OPTION_PREFIX${request.pluginId}:$it") } + } + + /** + * Extracts the requests from all diagnostics rendered by [missingPluginMessage] found in [message], + * or returns `null` if the message contains no such diagnostic. + */ + fun extractMissingPluginRequests(message: String): List<StatelessReplPluginRequest>? { + val requests = mutableListOf<StatelessReplPluginRequest>() + val lines = message.lines() + var index = 0 + while (index < lines.size) { + val header = missingPluginHeaderRegex.find(lines[index++]) ?: continue + val key = header.groupValues[1] + val pluginId = header.groupValues[2] + val optionPrefix = "$PLUGIN_OPTION_PREFIX$pluginId:" + val classpath = mutableListOf<File>() + val options = mutableListOf<String>() + while (index < lines.size) { + val line = lines[index].trim() + when { + line.startsWith(PLUGIN_CLASSPATH_PREFIX) -> classpath += File(line.removePrefix(PLUGIN_CLASSPATH_PREFIX)) + line.startsWith(optionPrefix) -> options += line.removePrefix(optionPrefix) + else -> break + } + index++ + } + require(classpath.isNotEmpty()) { "No classpath specified for the requested compiler plugin '$key'" } + requests += StatelessReplPluginRequest(key, pluginId, classpath, options) + } + return requests.takeIf { it.isNotEmpty() } + } + + fun encodeLoadedPluginOption(key: String, pluginId: String, options: List<String>): String { + val bytes = ByteArrayOutputStream() + DataOutputStream(bytes).use { output -> + output.writeUTF(key) + output.writeUTF(pluginId) + output.writeInt(options.size) + options.forEach(output::writeUTF) + } + return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes.toByteArray()) + } + + fun decodeLoadedPluginOption(value: String): StatelessReplLoadedPlugin = + DataInputStream(Base64.getUrlDecoder().decode(value).inputStream()).use { input -> + val key = input.readUTF() + val pluginId = input.readUTF() + val count = input.readInt().also { require(it in 0..MAX_ENTRIES) { "Invalid loaded plugin option count: $it" } } + StatelessReplLoadedPlugin(key, pluginId, List(count) { input.readUTF() }) + } +}
diff --git a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/StatelessReplPluginRequestReporter.kt b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/StatelessReplPluginRequestReporter.kt new file mode 100644 index 0000000..19a38d4 --- /dev/null +++ b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/StatelessReplPluginRequestReporter.kt
@@ -0,0 +1,116 @@ +/* + * Copyright 2010-2026 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.scripting.compiler.plugin.impl + +import com.intellij.openapi.util.Disposer +import org.jetbrains.kotlin.cli.common.kotlinPaths +import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity +import org.jetbrains.kotlin.cli.common.messages.MessageCollector +import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.config.MessageCollectorAccess +import org.jetbrains.kotlin.config.messageCollector +import org.jetbrains.kotlin.scripting.compiler.plugin.ReplSnippetConfigurationCodec +import org.jetbrains.kotlin.scripting.compiler.plugin.StatelessReplLoadedPlugin +import org.jetbrains.kotlin.scripting.compiler.plugin.StatelessReplPluginRequest +import org.jetbrains.kotlin.scripting.compiler.plugin.StatelessReplPluginRequestsCodec +import org.jetbrains.kotlin.scripting.configuration.ScriptingConfigurationKeys +import kotlin.script.experimental.api.ScriptCompilationConfiguration +import kotlin.script.experimental.api.ScriptCompilerPlugin +import kotlin.script.experimental.api.compilerOptions + +@OptIn(MessageCollectorAccess::class) +class StatelessReplPluginRequestReporter(private val compilerConfiguration: CompilerConfiguration) { + private val messageCollector: MessageCollector = compilerConfiguration.messageCollector + private val baseCompilerOptions = compilerConfiguration[ScriptingConfigurationKeys.REPL_SNIPPET_CONFIGURATION_FILE] + ?.let(ReplSnippetConfigurationCodec::readFrom) + ?.get(ScriptCompilationConfiguration.compilerOptions).orEmpty() + private val loadedPlugins = compilerConfiguration.getList(ScriptingConfigurationKeys.REPL_SNIPPET_LOADED_PLUGINS) + .mapNotNull { encoded -> + runCatching { StatelessReplPluginRequestsCodec.decodeLoadedPluginOption(encoded) } + .onFailure { + messageCollector.report( + CompilerMessageSeverity.ERROR, + "Invalid loaded REPL compiler plugin request: ${it.message}" + ) + } + .getOrNull() + } + .associateBy(StatelessReplLoadedPlugin::key) + private val globalPluginIds = compilerConfiguration.getList(CompilerPluginRegistrar.COMPILER_PLUGIN_REGISTRARS) + .mapTo(mutableSetOf()) { it.pluginId } + private val requests = linkedMapOf<String, StatelessReplPluginRequest>() + + fun report(source: kotlin.script.experimental.api.SourceCode, refinedConfiguration: ScriptCompilationConfiguration) { + val plugins = collectScriptCompilerPlugins( + baseCompilerOptions, + listOf(source), + { refinedConfiguration }, + messageCollector, + ) + + val newRequests = mutableListOf<StatelessReplPluginRequest>() + for (plugin in plugins) { + val key = plugin.requestKey + val loadedOptions = loadedPlugins[key] + if (loadedOptions != null) { + if (loadedOptions.pluginId !in globalPluginIds) { + messageCollector.report( + CompilerMessageSeverity.ERROR, + "Stateless REPL compiler plugin '${loadedOptions.pluginId}' was marked loaded but is not registered." + ) + } else if (loadedOptions.options != plugin.options) { + reportConflict(plugin.descriptionForDiagnostic()) + } + continue + } + + val previous = requests[key] + if (previous != null) { + if (previous.options != plugin.options) reportConflict(plugin.descriptionForDiagnostic()) + continue + } + + val classpath = validateAndResolveScriptCompilerPlugin( + plugin, + compilerConfiguration.kotlinPaths, + globalPluginIds, + messageCollector, + ) ?: continue + if (classpath.isEmpty()) continue + + val registrarCount = compilerConfiguration.getList(CompilerPluginRegistrar.COMPILER_PLUGIN_REGISTRARS).size + val disposable = Disposer.newDisposable("stateless REPL compiler plugin validation") + val pluginId = try { + val validatedConfiguration = compilerConfiguration.copy() + .withScriptCompilerPlugins(listOf(plugin), disposable, messageCollector) + ?: continue + validatedConfiguration.getList(CompilerPluginRegistrar.COMPILER_PLUGIN_REGISTRARS) + .drop(registrarCount) + .singleOrNull() + ?.pluginId + ?: continue + } finally { + Disposer.dispose(disposable) + } + + val request = StatelessReplPluginRequest(key, pluginId, classpath, plugin.options) + requests[key] = request + newRequests += request + } + + // The host extracts the requests from these diagnostics, so that it can retry the compilation with the plugins loaded. + newRequests.forEach { request -> + messageCollector.report(CompilerMessageSeverity.ERROR, StatelessReplPluginRequestsCodec.missingPluginMessage(request)) + } + } + + private fun reportConflict(description: String) { + messageCollector.report(CompilerMessageSeverity.ERROR, "Conflicting options for compiler plugin '$description'.") + } + + private fun ScriptCompilerPlugin.descriptionForDiagnostic(): String = id ?: classpath.joinToString(",") +}
diff --git a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/scriptCompilerPlugins.kt b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/scriptCompilerPlugins.kt index 703a235..43fd73f 100644 --- a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/scriptCompilerPlugins.kt +++ b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/scriptCompilerPlugins.kt
@@ -21,11 +21,7 @@ import org.jetbrains.kotlin.extensions.ProjectExtensionDescriptor import org.jetbrains.kotlin.utils.KotlinPaths import java.io.File -import kotlin.script.experimental.api.ScriptCompilationConfiguration -import kotlin.script.experimental.api.ScriptCompilerPlugin -import kotlin.script.experimental.api.SourceCode -import kotlin.script.experimental.api.compilerOptions -import kotlin.script.experimental.api.compilerPlugins +import kotlin.script.experimental.api.* // Short ids are limited to KotlinPaths.Jar entries. // Compose requires runtime setup; Parcelize is Android-specific; Atomicfu needs a runtime transformation. @@ -163,20 +159,9 @@ val pluginsByRegistrar = LinkedHashMap<CompilerPluginRegistrar, ScriptCompilerPlugin>() for (plugin in pluginsToLoad) { - val distJar = plugin.id?.let { id -> - scriptCompilerPluginDistributionJar(id) ?: return reportError("Unknown compiler plugin id '$id'.") - } - val classpath = if (distJar != null) { - val paths = kotlinPaths - ?: return reportError("Compiler plugin id '${plugin.id}' cannot be resolved by this host. Use a jar path instead.") - listOf(paths.jar(distJar)) - } else { - plugin.classpath - }.map { it.absoluteFile.normalize() } - - for (jar in classpath) { - if (!jar.isFile) return reportError("Compiler plugin jar '$jar' does not exist or is not a file.") - } + val classpath = validateAndResolveScriptCompilerPlugin(plugin, kotlinPaths, globalPluginIds, messageCollector) + ?: return null + if (classpath.isEmpty()) continue val classpathArgument = classpath.joinToString(",") { it.path } val pluginOptions = plugin.options @@ -269,9 +254,44 @@ return derivedConfiguration } -private val ScriptCompilerPlugin.requestKey: String +internal val ScriptCompilerPlugin.requestKey: String get() = id ?: classpath.joinToString(File.pathSeparator) { it.absoluteFile.normalize().path } +internal fun validateAndResolveScriptCompilerPlugin( + plugin: ScriptCompilerPlugin, + kotlinPaths: KotlinPaths?, + globalPluginIds: Set<String>, + messageCollector: MessageCollector, +): List<File>? { + fun reportError(message: String): List<File>? { + messageCollector.report(CompilerMessageSeverity.ERROR, message) + return null + } + + if (plugin.id != null && plugin.id in globalPluginIds) { + if (plugin.options.isNotEmpty()) { + return reportError("Compiler plugin '${plugin.id}' is already loaded globally and cannot be configured from a script.") + } + return emptyList() + } + + val distJar = plugin.id?.let { id -> + scriptCompilerPluginDistributionJar(id) ?: return reportError("Unknown compiler plugin id '$id'.") + } + val classpath = if (distJar != null) { + val paths = kotlinPaths + ?: return reportError("Compiler plugin id '${plugin.id}' cannot be resolved by this host. Use a jar path instead.") + listOf(paths.jar(distJar)) + } else { + plugin.classpath + }.map { it.absoluteFile.normalize() } + + for (jar in classpath) { + if (!jar.isFile) return reportError("Compiler plugin jar '$jar' does not exist or is not a file.") + } + return classpath +} + private val ScriptCompilerPlugin.description: String get() = id ?: classpath.joinToString(",")
diff --git a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/services/FirReplSnippetConfiguratorExtensionImpl.kt b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/services/FirReplSnippetConfiguratorExtensionImpl.kt index f6584fa..b6622ea 100644 --- a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/services/FirReplSnippetConfiguratorExtensionImpl.kt +++ b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/services/FirReplSnippetConfiguratorExtensionImpl.kt
@@ -5,7 +5,9 @@ package org.jetbrains.kotlin.scripting.compiler.plugin.services -import org.jetbrains.kotlin.* +import org.jetbrains.kotlin.KtFakeSourceElementKind +import org.jetbrains.kotlin.KtSourceElement +import org.jetbrains.kotlin.KtSourceFile import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.fir.* @@ -38,7 +40,9 @@ import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.scripting.compiler.plugin.impl.StatelessReplPluginRequestReporter import org.jetbrains.kotlin.scripting.compiler.plugin.impl.currentSnippetNo +import org.jetbrains.kotlin.scripting.resolve.toSourceCode import kotlin.contracts.ExperimentalContracts import kotlin.contracts.contract import kotlin.script.experimental.api.* @@ -58,6 +62,7 @@ class FirReplSnippetConfiguratorExtensionImpl( session: FirSession, private val hostConfiguration: ScriptingHostConfiguration, + private val pluginRequestReporter: StatelessReplPluginRequestReporter? = null, ) : FirReplSnippetConfiguratorExtension(session) { override fun isReplSnippetsSource(sourceFile: KtSourceFile?, scriptSource: KtSourceElement): Boolean = @@ -72,6 +77,8 @@ return } + pluginRequestReporter?.report(sourceFile.toSourceCode(), configuration) + configuration[ScriptCompilationConfiguration.implicitReceivers]?.forEachIndexed { index, implicitReceiver -> receivers.add( buildScriptReceiverParameter { @@ -262,6 +269,13 @@ fun getFactory(hostConfiguration: ScriptingHostConfiguration): Factory { return Factory { session -> FirReplSnippetConfiguratorExtensionImpl(session, hostConfiguration) } } + + fun getFactory( + hostConfiguration: ScriptingHostConfiguration, + pluginRequestReporter: StatelessReplPluginRequestReporter, + ): Factory { + return Factory { session -> FirReplSnippetConfiguratorExtensionImpl(session, hostConfiguration, pluginRequestReporter) } + } } }
diff --git a/plugins/scripting/scripting-tests/build.gradle.kts b/plugins/scripting/scripting-tests/build.gradle.kts index dcec92a..417619e 100644 --- a/plugins/scripting/scripting-tests/build.gradle.kts +++ b/plugins/scripting/scripting-tests/build.gradle.kts
@@ -6,6 +6,7 @@ } val powerAssertCompilerPluginJar = configurations.create("powerAssertCompilerPluginJar") +val allOpenCompilerPluginClasspath = configurations.create("allOpenCompilerPluginClasspath") val kotlinxSerializationGradlePluginClasspath = configurations.create("kotlinxSerializationGradlePluginClasspath") val kotlinDataFrameGradlePluginClasspath = configurations.create("kotlinDataFrameGradlePluginClasspath") val kotlinxCoroutinesCoreGradlePluginClasspath = configurations.create("kotlinxCoroutinesCoreGradlePluginClasspath") @@ -34,6 +35,7 @@ testRuntimeOnly(project(":compiler:fir:plugin.api")) powerAssertCompilerPluginJar(project(":kotlin-power-assert-compiler-plugin")) { isTransitive = false } + allOpenCompilerPluginClasspath(project(":kotlin-allopen-compiler-plugin")) { isTransitive = false } kotlinxSerializationGradlePluginClasspath(project(":kotlinx-serialization-compiler-plugin.embeddable")) { isTransitive = true } kotlinDataFrameGradlePluginClasspath(project(":kotlin-dataframe-compiler-plugin.embeddable")) { isTransitive = true } kotlinxCoroutinesCoreGradlePluginClasspath(libs.kotlinx.coroutines.core) { isTransitive = false } @@ -60,6 +62,7 @@ workingDir = rootDir addClasspathProperty(testSourceSet.output.classesDirs, "kotlin.test.script.classpath") addClasspathProperty(powerAssertCompilerPluginJar, "kotlin.power.assert.compiler.plugin.jar") + addClasspathProperty(allOpenCompilerPluginClasspath, "kotlin.script.test.allopen.plugin.classpath") addClasspathProperty(kotlinxSerializationGradlePluginClasspath, "kotlin.script.test.kotlinx.serialization.plugin.classpath") addClasspathProperty(kotlinDataFrameGradlePluginClasspath, "kotlin.script.test.kotlin.dataframe.plugin.classpath") addClasspathProperty(kotlinxCoroutinesCoreGradlePluginClasspath, "kotlin.script.test.kotlinx.coroutines.core.classpath")
diff --git a/plugins/scripting/scripting-tests/tests/org/jetbrains/kotlin/scripting/test/repl/ReplSnippetStatelessCompilationTest.kt b/plugins/scripting/scripting-tests/tests/org/jetbrains/kotlin/scripting/test/repl/ReplSnippetStatelessCompilationTest.kt index a129073..086a2b9 100644 --- a/plugins/scripting/scripting-tests/tests/org/jetbrains/kotlin/scripting/test/repl/ReplSnippetStatelessCompilationTest.kt +++ b/plugins/scripting/scripting-tests/tests/org/jetbrains/kotlin/scripting/test/repl/ReplSnippetStatelessCompilationTest.kt
@@ -5,24 +5,23 @@ package org.jetbrains.kotlin.scripting.compiler.test +import kotlinx.coroutines.runBlocking import org.jetbrains.kotlin.cli.common.ExitCode import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments import org.jetbrains.kotlin.cli.common.arguments.cliArgument +import org.jetbrains.kotlin.cli.common.arguments.parseCommandLineArguments +import org.jetbrains.kotlin.cli.common.messages.MessageCollectorImpl +import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime +import org.jetbrains.kotlin.config.Services import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.ScriptNames -import org.jetbrains.kotlin.scripting.compiler.plugin.KOTLIN_SCRIPTING_PLUGIN_ID -import org.jetbrains.kotlin.scripting.compiler.plugin.ReplSnippetConfigurationCodec -import org.jetbrains.kotlin.scripting.compiler.plugin.impl.SCRIPT_BASE_COMPILER_ARGUMENTS_PROPERTY -import org.jetbrains.kotlin.scripting.compiler.plugin.impl.SnippetArtifactMetadata -import org.jetbrains.kotlin.scripting.compiler.plugin.impl.SnippetArtifactMetadataCodec -import org.jetbrains.kotlin.scripting.compiler.plugin.impl.readRefinedCompilationConfiguration -import org.jetbrains.kotlin.scripting.compiler.plugin.impl.readSnippetArtifactMetadata -import org.jetbrains.kotlin.scripting.compiler.plugin.withRefinedFromCompiler -import org.jetbrains.kotlin.scripting.compiler.test.TestScriptWithRequire +import org.jetbrains.kotlin.scripting.compiler.plugin.* +import org.jetbrains.kotlin.scripting.compiler.plugin.impl.* import org.jetbrains.kotlin.scripting.test.SCRIPT_TEST_BASE_COMPILER_ARGUMENTS_PROPERTY +import org.jetbrains.kotlin.scripting.test.getBaseCompilerArgumentsFromProperty import org.jetbrains.kotlin.scripting.test.runWithK2JVMCompiler import org.jetbrains.kotlin.scripting.test.withTempDir import org.jetbrains.kotlin.utils.PathUtil @@ -31,6 +30,8 @@ import java.nio.file.Files import kotlin.reflect.KClass import kotlin.script.experimental.api.* +import kotlin.script.experimental.dependencies.CompoundDependenciesResolver +import kotlin.script.experimental.dependencies.maven.MavenDependenciesResolver import kotlin.script.experimental.host.createCompilationConfigurationFromTemplate import kotlin.script.experimental.impl.internalScriptingRunSuspend import kotlin.script.experimental.jvm.JvmDependency @@ -81,6 +82,166 @@ } @Test + fun testStatelessReplReportsAndLoadsRequestedCompilerPlugin() { + if (!isK2) return + + withTempDir { workRoot -> + val pluginArguments = serializationPluginClasspath().map { "-Xplugin=${it.absolutePath}" } + val plainCompiler = StatelessReplCompiler( + workRoot = workRoot, + compilerPluginArguments = pluginArguments, + additionalClasspath = serializationRuntimeClasspath(), + ) + plainCompiler.compile( + "import kotlinx.serialization.Serializable\n@Serializable data class User(val name: String)", + "plain-serialization.kts", + ) + val serializerClassSuffix = buildString { + append("User") + repeat(2) { append('$') } + append("serializer.class") + } + assertTrue(plainCompiler.lastOutputDir.classFileNames().any { it.endsWith(serializerClassSuffix) }) + + val source = """ + import kotlinx.serialization.Serializable + + @Serializable + data class User(val name: String) + """.trimIndent() + val firstCompiler = StatelessReplCompiler( + workRoot = workRoot, + snippetConfiguration = serializationPluginConfiguration(), + additionalClasspath = serializationRuntimeClasspath(), + ) + val errors = firstCompiler.compileCollectingErrors(source, "plugin-request.repl.kts") + val missingPluginsErrors = errors.filter { it.startsWith("Compilation requires compiler plugin ") } + assertEquals(1, missingPluginsErrors.size, "Expected a single missing plugins diagnostic, got: $errors") + + val [requestKey, requestPluginId, requestClasspath, requestOptions] = + assertNotNull(StatelessReplPluginRequestsCodec.extractMissingPluginRequests(missingPluginsErrors.single())).single() + assertEquals(serializationPluginRequestKey(), requestKey) + assertTrue(requestClasspath.single().isFile) + assertTrue(requestOptions.isEmpty()) + + val forwardedPluginArguments = requestClasspath.map { "-Xplugin=${it.absolutePath}" } + val forwardedCompiler = StatelessReplCompiler( + workRoot = workRoot, + snippetConfiguration = serializationPluginConfiguration(), + loadedPlugins = listOf(StatelessReplLoadedPlugin(requestKey, requestPluginId, requestOptions)), + compilerPluginArguments = forwardedPluginArguments, + additionalClasspath = serializationRuntimeClasspath(), + ) + forwardedCompiler.compile(source, "plugin-forwarded.repl.kts") + assertTrue( + forwardedCompiler.lastOutputDir.classFileNames().any { it.endsWith(serializerClassSuffix) }, + "the serialization plugin must generate the serializer class", + ) + forwardedCompiler.compile("User.serializer().descriptor.serialName", "plugin-usage.repl.kts") + } + } + + @Test + fun testStatelessReplReportsAndLoadsSeveralCompilerPluginsRequestedBySingleSnippet() { + if (!isK2) return + + withTempDir { workRoot -> + val snippetConfiguration = ScriptCompilationConfiguration { + compilerPlugins( + ScriptCompilerPlugin.fromClasspath(serializationPluginClasspath()), + ScriptCompilerPlugin.fromClasspath(allOpenPluginClasspath(), listOf(ALL_OPEN_SERIALIZABLE_OPTION)), + ) + } + val source = """ + import kotlinx.serialization.Serializable + + @Serializable + class User(val name: String) + """.trimIndent() + val errors = StatelessReplCompiler( + workRoot = workRoot, + snippetConfiguration = snippetConfiguration, + additionalClasspath = serializationRuntimeClasspath(), + ).compileCollectingErrors(source, "plugins-request.repl.kts") + val missingPluginsErrors = errors.filter { it.startsWith("Compilation requires compiler plugin ") } + assertEquals(2, missingPluginsErrors.size, "Expected a diagnostic per missing plugin, got: $errors") + + val requests = missingPluginsErrors.flatMap { assertNotNull(StatelessReplPluginRequestsCodec.extractMissingPluginRequests(it)) } + assertEquals( + listOf(serializationPluginRequestKey(), allOpenPluginRequestKey()), + requests.map { it.key }, + ) + assertEquals(listOf(emptyList(), listOf(ALL_OPEN_SERIALIZABLE_OPTION)), requests.map { it.options }) + assertEquals(2, requests.map { it.pluginId }.toSet().size, "Expected distinct plugin ids, got: $requests") + + val plugins = StatelessReplCompilerPlugins.EMPTY.merge(requests).valueOrThrow() + val forwardedCompiler = StatelessReplCompiler( + workRoot = workRoot, + snippetConfiguration = snippetConfiguration, + loadedPlugins = requests.map { StatelessReplLoadedPlugin(it.key, it.pluginId, it.options) }, + compilerPluginArguments = plugins.cliArguments(), + additionalClasspath = serializationRuntimeClasspath(), + ) + forwardedCompiler.compile(source, "plugins-forwarded.repl.kts") + assertTrue( + forwardedCompiler.lastOutputDir.classFileNames().any { it.endsWith("User\$\$serializer.class") }, + "the serialization plugin must generate the serializer class", + ) + // The all-open plugin makes the serializable class open, so it can be subclassed in a later snippet. + forwardedCompiler.compile("class Admin(name: String) : User(name)", "plugins-usage.repl.kts") + } + } + + @Test + fun testStatelessReplRejectsConflictingRequestsOfSamePluginInSingleSnippet() { + if (!isK2) return + + withTempDir { workRoot -> + val compiler = StatelessReplCompiler( + workRoot = workRoot, + snippetConfiguration = ScriptCompilationConfiguration { + compilerPlugins( + ScriptCompilerPlugin.fromClasspath(allOpenPluginClasspath(), listOf("annotation=test.First")), + ScriptCompilerPlugin.fromClasspath(allOpenPluginClasspath(), listOf("annotation=test.Second")), + ) + }, + ) + val errors = compiler.compileCollectingErrors("1", "plugins-conflict.repl.kts") + assertTrue( + errors.any { it.contains("conflicting options for compiler plugin", ignoreCase = true) }, + "Expected a conflict diagnostic, got: $errors", + ) + val requests = errors.mapNotNull(StatelessReplPluginRequestsCodec::extractMissingPluginRequests).flatten() + assertEquals(listOf(listOf("annotation=test.First")), requests.map { it.options }) + } + } + + @Test + fun testStatelessReplRejectsChangedOptionsForLoadedCompilerPlugin() { + if (!isK2) return + + withTempDir { workRoot -> + val compiler = StatelessReplCompiler( + workRoot = workRoot, + snippetConfiguration = serializationPluginConfiguration(listOf("different=true")), + loadedPlugins = listOf( + StatelessReplLoadedPlugin( + serializationPluginRequestKey(), + "org.jetbrains.kotlinx.serialization", + emptyList(), + ) + ), + compilerPluginArguments = serializationPluginClasspath().map { "-Xplugin=${it.absolutePath}" }, + ) + compiler.compileExpectingFailure( + "1", + "plugin-conflict.repl.kts", + listOf("conflicting options for compiler plugin"), + ) + } + } + + @Test fun testStatelessReplExecutesMultiSnippetSequence() { if (!isK2) return @@ -541,6 +702,9 @@ * classpath exactly as the hosts do; `null` leaves the transported configuration as the only source. */ private val definitionClass: KClass<*>? = null, + private val loadedPlugins: List<StatelessReplLoadedPlugin> = emptyList(), + private val compilerPluginArguments: List<String> = emptyList(), + private val additionalClasspath: List<File> = emptyList(), ) { private val snippetConfigurationFile: File? by lazy { snippetConfiguration?.let { File(workRoot, "snippet-configuration.bin").also { f -> ReplSnippetConfigurationCodec.writeTo(it, f) } } @@ -594,6 +758,18 @@ } } + /** Compiles expecting a compilation error and returns the reported error messages; the session is left untouched. */ + fun compileCollectingErrors(source: String, name: String): List<String> { + val outputDir = File(workRoot, "out-failing-${counter++}").also { it.mkdirs() } + val messageCollector = MessageCollectorImpl() + val exitCode = withSourceFile(source, name) { scriptFile -> + val arguments = getBaseCompilerArgumentsFromProperty().orEmpty() + buildArguments(scriptFile, outputDir) + K2JVMCompiler().exec(messageCollector, Services.EMPTY, parseCommandLineArguments<K2JVMCompilerArguments>(arguments)) + } + assertEquals(ExitCode.COMPILATION_ERROR, exitCode, "Unexpected exit code, messages: ${messageCollector.messages}") + return messageCollector.errors.map { it.message } + } + private fun <R> withSourceFile(source: String, name: String, body: (File) -> R): R { val sourceDir = Files.createTempDirectory("k2-repl-cli-src-").toFile() try { @@ -604,8 +780,13 @@ } private fun buildArguments(scriptFile: File, outputDir: File): List<String> { - val classpathEntries = listOf(ForTestCompileRuntime.runtimeJarForTests()) + priorOutputDirs + val classpathEntries = mutableListOf<File>() + classpathEntries.add(ForTestCompileRuntime.runtimeJarForTests()) + classpathEntries.add(ForTestCompileRuntime.scriptingTestsRuntimeClasspathForTests()) + classpathEntries.addAll(additionalClasspath) + classpathEntries.addAll(priorOutputDirs) return buildList { + addAll(compilerPluginArguments) add(K2JVMCompilerArguments::classpath.cliArgument) add(classpathEntries.joinToString(File.pathSeparator) { it.absolutePath }) add(K2JVMCompilerArguments::allowAnyScriptsInSourceRoots.cliArgument) @@ -616,6 +797,13 @@ add("-P") add("plugin:$KOTLIN_SCRIPTING_PLUGIN_ID:repl-snippet-configuration=${it.absolutePath}") } + loadedPlugins.forEach { [key, pluginId, options] -> + add("-P") + add( + "plugin:$KOTLIN_SCRIPTING_PLUGIN_ID:repl-snippet-loaded-plugin=" + + StatelessReplPluginRequestsCodec.encodeLoadedPluginOption(key, pluginId, options) + ) + } definitionClass?.let { add("-P") add("plugin:$KOTLIN_SCRIPTING_PLUGIN_ID:script-definitions=${it.java.name}") @@ -637,6 +825,38 @@ } } +private fun serializationRuntimeClasspath(): List<File> = + runBlocking { + CompoundDependenciesResolver(MavenDependenciesResolver()) + .resolve("org.jetbrains.kotlinx:kotlinx-serialization-core:1.8.1") + .valueOrThrow() + } + +private fun serializationPluginConfiguration(options: List<String> = emptyList()): ScriptCompilationConfiguration = + ScriptCompilationConfiguration { + compilerPlugins(ScriptCompilerPlugin.fromClasspath(serializationPluginClasspath(), options)) + } + +private fun serializationPluginClasspath(): List<File> = + System.getProperty("kotlin.script.test.kotlinx.serialization.plugin.classpath") + ?.split(File.pathSeparator) + ?.map(::File) + .orEmpty() + +private fun serializationPluginRequestKey(): String = + serializationPluginClasspath().joinToString(File.pathSeparator) { it.absoluteFile.normalize().path } + +private const val ALL_OPEN_SERIALIZABLE_OPTION = "annotation=kotlinx.serialization.Serializable" + +private fun allOpenPluginClasspath(): List<File> = + System.getProperty("kotlin.script.test.allopen.plugin.classpath") + ?.split(File.pathSeparator) + ?.map(::File) + .orEmpty() + +private fun allOpenPluginRequestKey(): String = + allOpenPluginClasspath().joinToString(File.pathSeparator) { it.absoluteFile.normalize().path } + private fun File.classFileNames(): List<String> = walkTopDown().filter { it.isFile && it.extension == "class" }.map { it.name }.toList()
diff --git a/plugins/scripting/scripting-tests/tests/org/jetbrains/kotlin/scripting/test/repl/StatelessReplCompilerPluginsTest.kt b/plugins/scripting/scripting-tests/tests/org/jetbrains/kotlin/scripting/test/repl/StatelessReplCompilerPluginsTest.kt new file mode 100644 index 0000000..8d995f1 --- /dev/null +++ b/plugins/scripting/scripting-tests/tests/org/jetbrains/kotlin/scripting/test/repl/StatelessReplCompilerPluginsTest.kt
@@ -0,0 +1,121 @@ +/* + * Copyright 2010-2026 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.scripting.compiler.test + +import org.jetbrains.kotlin.scripting.compiler.plugin.StatelessReplCompilerPlugins +import org.jetbrains.kotlin.scripting.compiler.plugin.StatelessReplLoadedPlugin +import org.jetbrains.kotlin.scripting.compiler.plugin.StatelessReplPluginRequest +import org.jetbrains.kotlin.scripting.compiler.plugin.StatelessReplPluginRequestsCodec +import org.junit.jupiter.api.Test +import java.io.File +import kotlin.script.experimental.api.valueOrThrow +import kotlin.test.assertContains +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith +import kotlin.test.assertNull + +class StatelessReplCompilerPluginsTest { + @Test + fun testMergeDeduplicatesEqualRequests() { + val request = request() + + val merged = StatelessReplCompilerPlugins.EMPTY.merge(listOf(request, request)).valueOrThrow() + + assertEquals(1, merged.loadedKeys().size) + assertEquals(1, merged.cliArguments().count { it.startsWith("-Xplugin=") }) + assertEquals(1, merged.loadedKeyOptions().size) + } + + @Test + fun testMergeDeduplicatesSamePluginAcrossRequestKeys() { + val request = request() + val aliasRequest = request.copy(key = "serialization") + + val merged = StatelessReplCompilerPlugins.EMPTY.merge(listOf(request, aliasRequest)).valueOrThrow() + + assertEquals(listOf(request.key), merged.loadedKeys()) + assertEquals(1, merged.cliArguments().count { it.startsWith("-Xplugin=") }) + } + + @Test + fun testMergeRejectsConflictingOptions() { + val request = request() + val conflict = request.copy(options = listOf("disableIntrinsic=false")) + + val failure = assertFailsWith<RuntimeException> { + StatelessReplCompilerPlugins.EMPTY.merge(listOf(request, conflict)).valueOrThrow() + } + + assertContains( + failure.message.orEmpty(), + "Conflicting options for compiler plugin '${request.classpath.joinToString(",") { it.path }}'.", + ) + } + + @Test + fun testCliArgumentsUseCompatibleLegacySyntax() { + val classpath = listOf(File("compiler-plugins/serialization.jar"), File("compiler-plugins/dependency.jar")) + val request = StatelessReplPluginRequest( + key = "serialization", + pluginId = "org.jetbrains.kotlinx.serialization", + classpath = classpath, + options = listOf("disableIntrinsic=true"), + ) + + val arguments = StatelessReplCompilerPlugins.EMPTY.merge(listOf(request)).valueOrThrow().cliArguments() + + assertEquals( + listOf( + "-Xplugin=${classpath[0].path}", + "-Xplugin=${classpath[1].path}", + "-P", + "plugin:org.jetbrains.kotlinx.serialization:disableIntrinsic=true", + ), + arguments, + ) + } + + @Test + fun testRequestAndLoadedPluginCodecsRoundTrip() { + val request = request() + + val otherRequest = request.copy(key = "other", pluginId = "other.plugin", options = emptyList()) + + val message = StatelessReplPluginRequestsCodec.missingPluginMessage(request) + assertEquals( + """ + Compilation requires compiler plugin '${request.key}' (id 'org.jetbrains.kotlinx.serialization'): + -Xplugin=${request.classpath.single().path} + -P plugin:org.jetbrains.kotlinx.serialization:disableIntrinsic=true + """.trimIndent(), + message, + ) + + // Hosts receive the diagnostics rendered with prefixes, possibly several of them per compilation. + assertEquals(listOf(request), StatelessReplPluginRequestsCodec.extractMissingPluginRequests("error: $message")) + assertEquals( + listOf(request, otherRequest), + StatelessReplPluginRequestsCodec.extractMissingPluginRequests( + "ERROR: $message\nERROR: " + StatelessReplPluginRequestsCodec.missingPluginMessage(otherRequest) + ) + ) + assertNull(StatelessReplPluginRequestsCodec.extractMissingPluginRequests("error: Compilation requires compiler plugins: x")) + + val loadedPlugin = StatelessReplLoadedPlugin(request.key, request.pluginId, request.options) + val encoded = StatelessReplPluginRequestsCodec.encodeLoadedPluginOption( + loadedPlugin.key, + loadedPlugin.pluginId, + loadedPlugin.options, + ) + assertEquals(loadedPlugin, StatelessReplPluginRequestsCodec.decodeLoadedPluginOption(encoded)) + } + + private fun request(): StatelessReplPluginRequest { + val classpath = listOf(File("compiler-plugins/serialization.jar").absoluteFile.normalize()) + val key = classpath.joinToString(File.pathSeparator) { it.absoluteFile.normalize().path } + return StatelessReplPluginRequest(key, "org.jetbrains.kotlinx.serialization", classpath, listOf("disableIntrinsic=true")) + } +}