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

[CLI] add support running scripts in js compiler, extract common code with jvm part

Browse Source
This commit is contained in:
Vitaliy.Tikhonov
2019-09-02 21:04:08 +03:00
committed by romanart
parent 50c08b25d3
commit f59e393e37
18 changed files with 175 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.kt
+6
View File
@@ -76,6 +76,9 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
)
var progressiveMode by FreezableVar(false)
@Argument(value = "-script", description = "Evaluate the script file")
var script: Boolean by FreezableVar(false)
@Argument(value = "-P", valueDescription = PLUGIN_OPTION_FORMAT, description = "Pass an option to a plugin")
var pluginOptions: Array<String>? by FreezableVar(null)
@@ -304,6 +307,9 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
)
var useFir: Boolean by FreezableVar(false)
@Argument(value = "-Xdisable-default-scripting-plugin", description = "Do not enable scripting plugin by default")
var disableDefaultScriptingPlugin: Boolean by FreezableVar(false)
open fun configureAnalysisFlags(collector: MessageCollector): MutableMap<AnalysisFlag<*>, Any> {
return HashMap<AnalysisFlag<*>, Any>().apply {
put(AnalysisFlags.skipMetadataVersionCheck, skipMetadataVersionCheck)
compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JSCompilerArguments.kt
+3
View File
@@ -137,4 +137,7 @@ class K2JSCompilerArguments : CommonCompilerArguments() {
@Argument(value = "-Xmetadata-only", description = "Generate *.meta.js and *.kjsm files only")
var metadataOnly: Boolean by FreezableVar(false)
@Argument(value = "-Xenable-js-scripting", description = "Enable experimental support of .kts files using K/JS (with -Xir only)")
var enableJsScripting: Boolean by FreezableVar(false)
}
compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt
-6
View File
@@ -45,9 +45,6 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
@Argument(value = "-no-reflect", description = "Don't include kotlin-reflect.jar into classpath")
var noReflect: Boolean by FreezableVar(false)
@Argument(value = "-script", description = "Evaluate the script file")
var script: Boolean by FreezableVar(false)
@Argument(
value = "-script-templates",
valueDescription = "<fully qualified class name[,]>",
@@ -254,9 +251,6 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
)
var jvmDefault: String by FreezableVar(JvmDefaultMode.DEFAULT.description)
@Argument(value = "-Xdisable-default-scripting-plugin", description = "Do not enable scripting plugin by default")
var disableDefaultScriptingPlugin: Boolean by FreezableVar(false)
@Argument(value = "-Xdisable-standard-script", description = "Disable standard kotlin script support")
var disableStandardScript: Boolean by FreezableVar(false)
compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java
+4 -2
View File
@@ -95,6 +95,9 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
return irCompiler;
}
@Override
protected void addPlatformOptions(@NotNull List<String> $self, @NotNull K2JSCompilerArguments arguments) {}
static {
moduleKindMap.put(K2JsArgumentConstants.MODULE_PLAIN, ModuleKind.PLAIN);
moduleKindMap.put(K2JsArgumentConstants.MODULE_COMMONJS, ModuleKind.COMMON_JS);
@@ -195,8 +198,7 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
return COMPILATION_ERROR;
}
ExitCode pluginLoadResult =
PluginCliParser.loadPluginsSafe(arguments.getPluginClasspaths(), arguments.getPluginOptions(), configuration);
ExitCode pluginLoadResult = loadPlugins(paths, arguments, configuration);
if (pluginLoadResult != ExitCode.OK) return pluginLoadResult;
configuration.put(JSConfigurationKeys.LIBRARIES, configureLibraries(arguments, paths, messageCollector));
compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt
+52 -16
View File
@@ -9,11 +9,11 @@ import com.intellij.openapi.Disposable
import com.intellij.openapi.util.io.FileUtil
import com.intellij.openapi.util.text.StringUtil
import org.jetbrains.kotlin.cli.common.*
import org.jetbrains.kotlin.cli.common.ExitCode.COMPILATION_ERROR
import org.jetbrains.kotlin.cli.common.ExitCode.OK
import org.jetbrains.kotlin.cli.common.ExitCode.*
import org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments
import org.jetbrains.kotlin.cli.common.arguments.K2JsArgumentConstants
import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoot
import org.jetbrains.kotlin.cli.common.extensions.ScriptEvaluationExtension
import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.*
import org.jetbrains.kotlin.cli.common.messages.GroupingMessageCollector
import org.jetbrains.kotlin.cli.common.messages.MessageCollector
@@ -43,6 +43,7 @@ import org.jetbrains.kotlin.serialization.js.ModuleKind
import org.jetbrains.kotlin.util.Logger
import org.jetbrains.kotlin.utils.JsMetadataVersion
import org.jetbrains.kotlin.utils.KotlinPaths
import org.jetbrains.kotlin.utils.PathUtil
import org.jetbrains.kotlin.utils.join
import java.io.File
import java.io.IOException
@@ -70,6 +71,33 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
): ExitCode {
val messageCollector = configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
val pluginLoadResult = loadPlugins(paths, arguments, configuration)
if (pluginLoadResult != ExitCode.OK) return pluginLoadResult
//TODO: add to configuration everything that may come in handy at script compiler and use it there
if (arguments.script) {
if (!arguments.enableJsScripting) {
messageCollector.report(ERROR, "Script for K/JS should be enabled explicitly, see -Xenable-js-scripting")
return COMPILATION_ERROR
}
configuration.put(CommonConfigurationKeys.MODULE_NAME, "repl.kts")
val environment = KotlinCoreEnvironment.getOrCreateApplicationEnvironmentForProduction(rootDisposable, configuration)
val projectEnv = KotlinCoreEnvironment.ProjectEnvironment(rootDisposable, environment)
projectEnv.registerExtensionsFromPlugins(configuration)
val scriptingEvaluators = ScriptEvaluationExtension.getInstances(projectEnv.project)
val scriptingEvaluator = scriptingEvaluators.find { it.isAccepted(arguments) }
if (scriptingEvaluator == null) {
messageCollector.report(ERROR, "Unable to evaluate script, no scripting plugin loaded")
return COMPILATION_ERROR
}
return scriptingEvaluator.eval(arguments, configuration, projectEnv)
}
if (arguments.freeArgs.isEmpty() && !IncrementalCompilation.isEnabledForJs()) {
if (arguments.version) {
return OK
@@ -78,13 +106,6 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
return COMPILATION_ERROR
}
val pluginLoadResult = PluginCliParser.loadPluginsSafe(
arguments.pluginClasspaths,
arguments.pluginOptions,
configuration
)
if (pluginLoadResult != OK) return pluginLoadResult
val libraries: List<String> = configureLibraries(arguments.libraries)
val friendLibraries: List<String> = configureLibraries(arguments.friendModules)
@@ -99,11 +120,11 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
val environmentForJS =
KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JS_CONFIG_FILES)
val project = environmentForJS.project
val projectJs = environmentForJS.project
val configurationJs = environmentForJS.configuration
val sourcesFiles = environmentForJS.getSourceFiles()
environmentForJS.configuration.put(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE, arguments.allowKotlinPackage)
configurationJs.put(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE, arguments.allowKotlinPackage)
if (!checkKotlinPackageUsage(environmentForJS, sourcesFiles)) return ExitCode.COMPILATION_ERROR
@@ -128,9 +149,11 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
val outputFile = File(outputFilePath)
configuration.put(CommonConfigurationKeys.MODULE_NAME, FileUtil.getNameWithoutExtension(outputFile))
configurationJs.put(CommonConfigurationKeys.MODULE_NAME, FileUtil.getNameWithoutExtension(outputFile))
val config = JsConfig(project, configuration)
// TODO: in this method at least 3 different compiler configurations are used (original, env.configuration, jsConfig.configuration)
// Such situation seems a bit buggy...
val config = JsConfig(projectJs, configurationJs)
val outputDir: File = outputFile.parentFile ?: outputFile.absoluteFile.parentFile!!
try {
config.configuration.put(JSConfigurationKeys.OUTPUT_DIR, outputDir.canonicalFile)
@@ -179,9 +202,9 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
val phaseConfig = createPhaseConfig(jsPhases, arguments, messageCollector)
val compiledModule = compile(
project,
projectJs,
sourcesFiles,
configuration,
config.configuration,
phaseConfig,
allDependencies = resolvedLibraries,
friendDependencies = friendDependencies,
@@ -293,6 +316,8 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
return JsMetadataVersion(*versionArray)
}
override fun MutableList<String>.addPlatformOptions(arguments: K2JSCompilerArguments) {}
companion object {
private val moduleKindMap = mapOf(
K2JsArgumentConstants.MODULE_PLAIN to ModuleKind.PLAIN,
@@ -349,4 +374,15 @@ fun messageCollectorLogger(collector: MessageCollector) = object : Logger {
(collector as? GroupingMessageCollector)?.flush()
kotlin.error(message)
}
}
fun loadPluginsForTests(configuration: CompilerConfiguration): ExitCode {
var pluginClasspaths: Iterable<String> = emptyList()
val kotlinPaths = PathUtil.kotlinPathsForCompiler
val libPath = kotlinPaths.libPath.takeIf { it.exists() && it.isDirectory } ?: File(".")
val (jars, _) =
PathUtil.KOTLIN_SCRIPTING_PLUGIN_CLASSPATH_JARS.mapNotNull { File(libPath, it) }.partition { it.exists() }
pluginClasspaths = jars.map { it.canonicalPath } + pluginClasspaths
return PluginCliParser.loadPluginsSafe(pluginClasspaths, mutableListOf(), configuration)
}
compiler/cli/src/org/jetbrains/kotlin/cli/common/CLICompiler.kt
+51 -4
View File
@@ -24,11 +24,10 @@ import org.jetbrains.kotlin.cli.common.ExitCode.COMPILATION_ERROR
import org.jetbrains.kotlin.cli.common.ExitCode.INTERNAL_ERROR
import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
import org.jetbrains.kotlin.cli.common.environment.setIdeaIoUseFallback
import org.jetbrains.kotlin.cli.common.messages.*
import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.INFO
import org.jetbrains.kotlin.cli.common.messages.GroupingMessageCollector
import org.jetbrains.kotlin.cli.common.messages.MessageCollector
import org.jetbrains.kotlin.cli.common.messages.MessageCollectorUtil
import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
import org.jetbrains.kotlin.cli.jvm.plugins.PluginCliParser
import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
import org.jetbrains.kotlin.config.CompilerConfiguration
import org.jetbrains.kotlin.config.Services
import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
@@ -36,8 +35,10 @@ import org.jetbrains.kotlin.progress.CompilationCanceledException
import org.jetbrains.kotlin.progress.CompilationCanceledStatus
import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus
import org.jetbrains.kotlin.utils.KotlinPaths
import org.jetbrains.kotlin.utils.PathUtil
import java.io.File
import java.io.PrintStream
import java.util.ArrayList
abstract class CLICompiler<A : CommonCompilerArguments> : CLITool<A>() {
@@ -134,5 +135,51 @@ abstract class CLICompiler<A : CommonCompilerArguments> : CLITool<A>() {
rootDisposable: Disposable,
paths: KotlinPaths?
): ExitCode
protected abstract fun MutableList<String>.addPlatformOptions(arguments: A)
protected fun loadPlugins(paths: KotlinPaths?, arguments: A, configuration: CompilerConfiguration): ExitCode {
var pluginClasspaths: Iterable<String> = arguments.pluginClasspaths?.asIterable() ?: emptyList()
val pluginOptions = arguments.pluginOptions?.toMutableList() ?: ArrayList()
if (!arguments.disableDefaultScriptingPlugin) {
val explicitOrLoadedScriptingPlugin =
pluginClasspaths.any { File(it).name.startsWith(PathUtil.KOTLIN_SCRIPTING_COMPILER_PLUGIN_NAME) } ||
tryLoadScriptingPluginFromCurrentClassLoader(configuration)
if (!explicitOrLoadedScriptingPlugin) {
val kotlinPaths = paths ?: PathUtil.kotlinPathsForCompiler
val libPath = kotlinPaths.libPath.takeIf { it.exists() && it.isDirectory } ?: File(".")
val (jars, missingJars) =
PathUtil.KOTLIN_SCRIPTING_PLUGIN_CLASSPATH_JARS.map { File(libPath, it) }.partition { it.exists() }
if (missingJars.isEmpty()) {
pluginClasspaths = jars.map { it.canonicalPath } + pluginClasspaths
} else {
val messageCollector = configuration.getNotNull(MESSAGE_COLLECTOR_KEY)
messageCollector.report(
CompilerMessageSeverity.LOGGING,
"Scripting plugin will not be loaded: not all required jars are present in the classpath (missing files: $missingJars)"
)
}
}
pluginOptions.addPlatformOptions(arguments)
} else {
pluginOptions.add("plugin:kotlin.scripting:disable=true")
}
return PluginCliParser.loadPluginsSafe(pluginClasspaths, pluginOptions, configuration)
}
private fun tryLoadScriptingPluginFromCurrentClassLoader(configuration: CompilerConfiguration): Boolean = try {
val pluginRegistrarClass = PluginCliParser::class.java.classLoader.loadClass(
"org.jetbrains.kotlin.scripting.compiler.plugin.ScriptingCompilerConfigurationComponentRegistrar"
)
val pluginRegistrar = pluginRegistrarClass.newInstance() as? ComponentRegistrar
if (pluginRegistrar != null) {
configuration.add(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS, pluginRegistrar)
true
} else false
} catch (_: Throwable) {
// TODO: add finer error processing and logging
false
}
}
compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt
+10 -52
View File
@@ -198,59 +198,17 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
}
}
private fun loadPlugins(paths: KotlinPaths?, arguments: K2JVMCompilerArguments, configuration: CompilerConfiguration): ExitCode {
var pluginClasspaths: Iterable<String> = arguments.pluginClasspaths?.asIterable() ?: emptyList()
val pluginOptions = arguments.pluginOptions?.toMutableList() ?: ArrayList()
if (!arguments.disableDefaultScriptingPlugin) {
val explicitOrLoadedScriptingPlugin =
pluginClasspaths.any { File(it).name.startsWith(PathUtil.KOTLIN_SCRIPTING_COMPILER_PLUGIN_NAME) } ||
tryLoadScriptingPluginFromCurrentClassLoader(configuration)
// if scripting plugin is not enabled explicitly (probably from another path) and not in the classpath already,
// try to find and enable it implicitly
if (!explicitOrLoadedScriptingPlugin) {
val kotlinPaths = paths ?: PathUtil.kotlinPathsForCompiler
val libPath = kotlinPaths.libPath.takeIf { it.exists() && it.isDirectory } ?: File(".")
val (jars, missingJars) =
PathUtil.KOTLIN_SCRIPTING_PLUGIN_CLASSPATH_JARS.mapNotNull { File(libPath, it) }.partition { it.exists() }
if (missingJars.isEmpty()) {
pluginClasspaths = jars.map { it.canonicalPath } + pluginClasspaths
} else {
val messageCollector = configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
messageCollector.report(
LOGGING,
"Scripting plugin will not be loaded: not all required jars are present in the classpath (missing files: $missingJars)"
)
}
}
if (arguments.scriptTemplates?.isNotEmpty() == true) {
pluginOptions.add("plugin:kotlin.scripting:script-templates=${arguments.scriptTemplates!!.joinToString(",")}")
}
if (arguments.scriptResolverEnvironment?.isNotEmpty() == true) {
pluginOptions.add(
"plugin:kotlin.scripting:script-resolver-environment=${arguments.scriptResolverEnvironment!!.joinToString(
","
)}"
)
}
} else {
pluginOptions.add("plugin:kotlin.scripting:disable=true")
override fun MutableList<String>.addPlatformOptions(arguments: K2JVMCompilerArguments) {
if (arguments.scriptTemplates?.isNotEmpty() == true) {
add("plugin:kotlin.scripting:script-templates=${arguments.scriptTemplates!!.joinToString(",")}")
}
if (arguments.scriptResolverEnvironment?.isNotEmpty() == true) {
add(
"plugin:kotlin.scripting:script-resolver-environment=${arguments.scriptResolverEnvironment!!.joinToString(
","
)}"
)
}
return PluginCliParser.loadPluginsSafe(pluginClasspaths, pluginOptions, configuration)
}
private fun tryLoadScriptingPluginFromCurrentClassLoader(configuration: CompilerConfiguration): Boolean = try {
val pluginRegistrarClass = PluginCliParser::class.java.classLoader.loadClass(
"org.jetbrains.kotlin.scripting.compiler.plugin.ScriptingCompilerConfigurationComponentRegistrar"
)
val pluginRegistrar = pluginRegistrarClass.newInstance() as? ComponentRegistrar
if (pluginRegistrar != null) {
configuration.add(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS, pluginRegistrar)
true
} else false
} catch (_: Throwable) {
// TODO: add finer error processing and logging
false
}
private fun createCoreEnvironment(
compiler/cli/src/org/jetbrains/kotlin/cli/metadata/K2MetadataCompiler.kt
+3 -1
View File
@@ -49,6 +49,8 @@ class K2MetadataCompiler : CLICompiler<K2MetadataCompilerArguments>() {
// No specific arguments yet
}
override fun MutableList<String>.addPlatformOptions(arguments: K2MetadataCompilerArguments) {}
override fun doExecute(
arguments: K2MetadataCompilerArguments,
configuration: CompilerConfiguration,
@@ -57,7 +59,7 @@ class K2MetadataCompiler : CLICompiler<K2MetadataCompilerArguments>() {
): ExitCode {
val collector = configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
val pluginLoadResult = PluginCliParser.loadPluginsSafe(arguments.pluginClasspaths, arguments.pluginOptions, configuration)
val pluginLoadResult = loadPlugins(paths, arguments, configuration)
if (pluginLoadResult != ExitCode.OK) return pluginLoadResult
for (arg in arguments.freeArgs) {
compiler/testData/cli/js/jsExtraHelp.out
Vendored
+3
View File
@@ -1,5 +1,6 @@
Usage: kotlinc-js <options> <source files>
where advanced options include:
-Xenable-js-scripting Enable experimental support of .kts files using K/JS (with -Xir only)
-Xfriend-modules=<path> Paths to friend modules
-Xfriend-modules-disabled Disable internal declaration export
-Xir Use IR backend
@@ -17,6 +18,8 @@ where advanced options include:
Should be a subset of sources passed as free arguments
-Xcoroutines={enable|warn|error}
Enable coroutines or report warnings or errors on declarations and use sites of 'suspend' modifier
-Xdisable-default-scripting-plugin
Do not enable scripting plugin by default
-Xdisable-phases Disable backend phases
-Xdump-directory Dump backend state into directory
-Xdump-fqname FqName of declaration that should be dumped
compiler/testData/cli/js/jsHelp.out
Vendored
+1
View File
@@ -28,6 +28,7 @@ where possible options include:
instead of going through a graceful migration cycle.
Code written in the progressive mode is backward compatible; however, code written in
non-progressive mode may cause compilation errors in the progressive mode.
-script Evaluate the script file
-nowarn Generate no warnings
-verbose Enable verbose logging output
-version Display compiler version
compiler/testData/cli/jvm/extraHelp.out
Vendored
+2 -2
View File
@@ -17,8 +17,6 @@ where advanced options include:
default is 'disable' in language version 1.2 and below,
'enable' since language version 1.3
-Xdump-declarations-to=<path> Path to JSON file to dump Java to Kotlin declaration mappings
-Xdisable-default-scripting-plugin
Do not enable scripting plugin by default
-Xdisable-standard-script Disable standard kotlin script support
-Xfriend-paths=<path> Paths to output directories for friend modules (whose internals should be visible)
-Xmultifile-parts-inherit Compile multifile classes as a hierarchy of parts and facade
@@ -79,6 +77,8 @@ where advanced options include:
Should be a subset of sources passed as free arguments
-Xcoroutines={enable|warn|error}
Enable coroutines or report warnings or errors on declarations and use sites of 'suspend' modifier
-Xdisable-default-scripting-plugin
Do not enable scripting plugin by default
-Xdisable-phases Disable backend phases
-Xdump-directory Dump backend state into directory
-Xdump-fqname FqName of declaration that should be dumped
compiler/testData/cli/jvm/help.out
Vendored
+1 -1
View File
@@ -10,7 +10,6 @@ where possible options include:
-no-jdk Don't include Java runtime into classpath
-no-reflect Don't include kotlin-reflect.jar into classpath
-no-stdlib Don't include kotlin-stdlib.jar or kotlin-reflect.jar into classpath
-script Evaluate the script file
-script-templates <fully qualified class name[,]>
Script definition template classes
-Werror Report an error if there are any warnings
@@ -26,6 +25,7 @@ where possible options include:
instead of going through a graceful migration cycle.
Code written in the progressive mode is backward compatible; however, code written in
non-progressive mode may cause compilation errors in the progressive mode.
-script Evaluate the script file
-nowarn Generate no warnings
-verbose Enable verbose logging output
-version Display compiler version
compiler/util/src/org/jetbrains/kotlin/utils/PathUtil.kt
+5 -1
View File
@@ -66,6 +66,8 @@ object PathUtil {
const val KOTLIN_SCRIPTING_COMMON_JAR = "$KOTLIN_SCRIPTING_COMMON_NAME.jar"
const val KOTLIN_SCRIPTING_JVM_NAME = "kotlin-scripting-jvm"
const val KOTLIN_SCRIPTING_JVM_JAR = "$KOTLIN_SCRIPTING_JVM_NAME.jar"
const val KOTLIN_SCRIPTING_JS_NAME = "kotlin-scripting-js"
const val KOTLIN_SCRIPTING_JS_JAR = "$KOTLIN_SCRIPTING_JS_NAME.jar"
const val KOTLIN_DAEMON_NAME = "kotlin-daemon"
const val KTOR_NAME = "ktor-network-1.0.1"
const val KOTLIN_DAEMON_JAR = "$KOTLIN_SCRIPTING_JVM_NAME.jar"
@@ -75,10 +77,12 @@ object PathUtil {
const val KOTLINX_COROUTINES_CORE_JAR = "$KOTLINX_COROUTINES_CORE_NAME.jar"
const val KOTLIN_SCRIPTING_COMPILER_IMPL_NAME = "kotlin-scripting-compiler-impl"
const val KOTLIN_SCRIPTING_COMPILER_IMPL_JAR = "$KOTLIN_SCRIPTING_COMPILER_IMPL_NAME.jar"
const val JS_ENGINES_NAME = "js.engines"
const val JS_ENGINES_JAR = "$JS_ENGINES_NAME.jar"
val KOTLIN_SCRIPTING_PLUGIN_CLASSPATH_JARS = arrayOf(
KOTLIN_SCRIPTING_COMPILER_PLUGIN_JAR, KOTLIN_SCRIPTING_COMPILER_IMPL_JAR,
KOTLIN_SCRIPTING_COMMON_JAR, KOTLIN_SCRIPTING_JVM_JAR
KOTLIN_SCRIPTING_COMMON_JAR, KOTLIN_SCRIPTING_JVM_JAR, KOTLIN_SCRIPTING_JS_JAR, JS_ENGINES_JAR
)
const val KOTLIN_TEST_NAME = "kotlin-test"
plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/AbstractScriptEvaluationExtension.kt
+6 -9
View File
@@ -23,8 +23,6 @@ import kotlin.script.experimental.host.toScriptSource
abstract class AbstractScriptEvaluationExtension : ScriptEvaluationExtension {
abstract fun getSourcePath(arguments: CommonCompilerArguments): String
abstract fun setupScriptConfiguration(configuration: CompilerConfiguration, sourcePath: String)
abstract fun createEnvironment(
@@ -40,11 +38,7 @@ abstract class AbstractScriptEvaluationExtension : ScriptEvaluationExtension {
scriptCompilationConfiguration: ScriptCompilationConfiguration
): ResultWithDiagnostics<CompiledScript<*>>
abstract suspend fun preprocessEvaluation(
scriptEvaluator: ScriptEvaluator,
scriptCompilationConfiguration: ScriptCompilationConfiguration,
evaluationConfiguration: ScriptEvaluationConfiguration
)
protected abstract fun ScriptEvaluationConfiguration.Builder.platformEvaluationConfiguration()
override fun eval(
arguments: CommonCompilerArguments,
@@ -57,12 +51,14 @@ abstract class AbstractScriptEvaluationExtension : ScriptEvaluationExtension {
messageCollector.report(CompilerMessageSeverity.ERROR, "Unable to process the script, scripting plugin is not configured")
return ExitCode.COMPILATION_ERROR
}
val sourcePath = getSourcePath(arguments)
val sourcePath = arguments.freeArgs.first()
setupScriptConfiguration(configuration, sourcePath)
val environment = createEnvironment(projectEnvironment, configuration)
if (messageCollector.hasErrors()) return ExitCode.COMPILATION_ERROR
val scriptFile = File(sourcePath)
if (scriptFile.isDirectory || !scriptDefinitionProvider.isScript(scriptFile)) {
val extensionHint =
@@ -82,6 +78,8 @@ abstract class AbstractScriptEvaluationExtension : ScriptEvaluationExtension {
val evaluationConfiguration = definition.evaluationConfiguration.with {
constructorArgs(scriptArgs.toTypedArray())
platformEvaluationConfiguration()
}
val scriptCompilationConfiguration = definition.compilationConfiguration
@@ -99,7 +97,6 @@ abstract class AbstractScriptEvaluationExtension : ScriptEvaluationExtension {
return@runBlocking ExitCode.COMPILATION_ERROR
}
preprocessEvaluation(scriptEvaluator, scriptCompilationConfiguration, evaluationConfiguration)
val evalResult = scriptEvaluator.invoke(compiledScript, evaluationConfiguration).valueOr {
for (report in it.reports) {
messageCollector.report(report.severity.toCompilerMessageSeverity(), report.render(withSeverity = false))
plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/JsScriptEvaluationExtension.kt
+19 -18
View File
@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.scripting.definitions.ScriptDefinition
import org.jetbrains.kotlin.scripting.definitions.platform
import org.jetbrains.kotlin.scripting.repl.js.CompiledToJsScript
import org.jetbrains.kotlin.scripting.repl.js.JsScriptCompiler
import org.jetbrains.kotlin.scripting.repl.js.JsScriptDependencyCompiler
import org.jetbrains.kotlin.scripting.repl.js.JsScriptEvaluator
import kotlin.script.experimental.api.*
import kotlin.script.experimental.host.ScriptingHostConfiguration
@@ -35,10 +36,6 @@ fun loadScriptConfiguration(configuration: CompilerConfiguration) {
class JsScriptEvaluationExtension : AbstractScriptEvaluationExtension() {
override fun getSourcePath(arguments: CommonCompilerArguments): String {
return (arguments as K2JSCompilerArguments).scriptPath!!
}
override fun setupScriptConfiguration(configuration: CompilerConfiguration, sourcePath: String) {
loadScriptConfiguration(configuration)
}
@@ -59,8 +56,12 @@ class JsScriptEvaluationExtension : AbstractScriptEvaluationExtension() {
}
private var environment: KotlinCoreEnvironment? = null
private var dependencyJsCode: String? = null
private val scriptCompiler: JsScriptCompiler by lazy {
JsScriptCompiler(environment!!)
val env = environment ?: error("Expected environment is initialized prior to compiler instantiation")
JsScriptCompiler(env).apply {
dependencyJsCode = JsScriptDependencyCompiler(env.configuration, nameTables, symbolTable).compile(dependencies)
}
}
override suspend fun compilerInvoke(
@@ -68,22 +69,22 @@ class JsScriptEvaluationExtension : AbstractScriptEvaluationExtension() {
script: SourceCode,
scriptCompilationConfiguration: ScriptCompilationConfiguration
): ResultWithDiagnostics<CompiledScript<*>> {
this.environment = environment
return scriptCompiler.invoke(script, scriptCompilationConfiguration)
return scriptCompiler.invoke(script, scriptCompilationConfiguration).onSuccess {
val compiledResult = it as CompiledToJsScript
val actualResult = dependencyJsCode?.let { d ->
dependencyJsCode = null
CompiledToJsScript(d + "\n" + compiledResult.jsCode, compiledResult.compilationConfiguration)
} ?: compiledResult
ResultWithDiagnostics.Success(actualResult)
}
}
override suspend fun preprocessEvaluation(
scriptEvaluator: ScriptEvaluator,
scriptCompilationConfiguration: ScriptCompilationConfiguration,
evaluationConfiguration: ScriptEvaluationConfiguration
) {
scriptEvaluator.invoke(
CompiledToJsScript(
scriptCompiler.scriptDependencyBinary,
scriptCompilationConfiguration
),
evaluationConfiguration
)
override fun ScriptEvaluationConfiguration.Builder.platformEvaluationConfiguration() {
}
override fun isAccepted(arguments: CommonCompilerArguments): Boolean {
plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/JvmCliScriptEvaluationExtension.kt
+6 -10
View File
@@ -16,11 +16,15 @@ import org.jetbrains.kotlin.config.JVMConfigurationKeys
import org.jetbrains.kotlin.scripting.compiler.plugin.impl.ScriptJvmCompilerFromEnvironment
import kotlin.script.experimental.api.*
import kotlin.script.experimental.jvm.BasicJvmScriptEvaluator
import kotlin.script.experimental.jvm.baseClassLoader
import kotlin.script.experimental.jvm.jvm
class JvmCliScriptEvaluationExtension : AbstractScriptEvaluationExtension() {
override fun getSourcePath(arguments: CommonCompilerArguments): String {
return arguments.freeArgs.first()
override fun ScriptEvaluationConfiguration.Builder.platformEvaluationConfiguration() {
jvm {
baseClassLoader(null)
}
}
override fun setupScriptConfiguration(configuration: CompilerConfiguration, sourcePath: String) {
@@ -53,14 +57,6 @@ class JvmCliScriptEvaluationExtension : AbstractScriptEvaluationExtension() {
return scriptCompiler.compile(script, scriptCompilationConfiguration)
}
override suspend fun preprocessEvaluation(
scriptEvaluator: ScriptEvaluator,
scriptCompilationConfiguration: ScriptCompilationConfiguration,
evaluationConfiguration: ScriptEvaluationConfiguration
) {
//do nothing
}
override fun isAccepted(arguments: CommonCompilerArguments): Boolean =
arguments is K2JVMCompilerArguments && arguments.script
}
plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/pluginRegisrar.kt
+1
View File
@@ -51,6 +51,7 @@ class ScriptingCompilerConfigurationComponentRegistrar : ComponentRegistrar {
)
)
ScriptEvaluationExtension.registerExtensionIfRequired(project, JvmCliScriptEvaluationExtension())
ScriptEvaluationExtension.registerExtensionIfRequired(project, JsScriptEvaluationExtension())
ShellExtension.registerExtensionIfRequired(project, JvmCliReplShellExtension())
ReplFactoryExtension.registerExtensionIfRequired(project,
JvmStandardReplFactoryExtension()
prepare/compiler/build.gradle.kts
+2
View File
@@ -83,6 +83,8 @@ val distLibraryProjects = listOfNotNull(
":kotlin-scripting-compiler",
":kotlin-scripting-compiler-impl",
":kotlin-scripting-jvm",
":kotlin-scripting-js",
":js:js.engines",
":kotlin-stdlib-js-ir".takeIf { kotlinBuildProperties.jsIrDist },
":kotlin-source-sections-compiler-plugin",
":kotlin-test:kotlin-test-js",