Move scripting support classes to the scripting compiler impl module

plugins/scripting/scripting-compiler/build.gradle.kts

@@ -17,6 +17,7 @@ dependencies {
     compile(project(":kotlin-scripting-compiler-impl"))
     compile(kotlinStdlib())
     compileOnly(project(":kotlin-reflect-api"))
+    compile(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) { isTransitive = false }
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 
     testCompile(project(":compiler:frontend"))
@@ -37,8 +38,8 @@ sourceSets {
 
 tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinCompile<*>> {
     kotlinOptions {
-        languageVersion = "1.2"
-        apiVersion = "1.2"
+        languageVersion = "1.3"
+        apiVersion = "1.3"
         freeCompilerArgs += "-Xskip-metadata-version-check"
     }
 }

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

@@ -19,8 +19,9 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
-import org.jetbrains.kotlin.script.ScriptDefinitionProvider
-import org.jetbrains.kotlin.script.StandardScriptDefinition
+import org.jetbrains.kotlin.scripting.configuration.ScriptingConfigurationKeys
+import org.jetbrains.kotlin.scripting.definitions.ScriptDefinitionProvider
+import org.jetbrains.kotlin.scripting.definitions.StandardScriptDefinition
 import java.io.File
 
 class JvmCliScriptEvaluationExtension : ScriptEvaluationExtension {
@@ -42,7 +43,7 @@ class JvmCliScriptEvaluationExtension : ScriptEvaluationExtension {
         val scriptFile = File(sourcePath)
         if (scriptFile.isDirectory || !scriptDefinitionProvider.isScript(scriptFile.name)) {
             val extensionHint =
-                if (configuration.get(JVMConfigurationKeys.SCRIPT_DEFINITIONS) == listOf(StandardScriptDefinition)) " (.kts)"
+                if (configuration.get(ScriptingConfigurationKeys.SCRIPT_DEFINITIONS) == listOf(StandardScriptDefinition)) " (.kts)"
                 else ""
             messageCollector.report(ERROR, "Specify path to the script file$extensionHint as the first argument")
             return COMPILATION_ERROR

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

@@ -1,45 +0,0 @@
-/*
- * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
- * that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.scripting.compiler.plugin
-
-import com.intellij.core.JavaCoreProjectEnvironment
-import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
-import org.jetbrains.kotlin.cli.common.extensions.ReplFactoryExtension
-import org.jetbrains.kotlin.cli.common.repl.ReplCompiler
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.script.KotlinScriptDefinition
-import org.jetbrains.kotlin.script.KotlinScriptDefinitionFromAnnotatedTemplate
-import org.jetbrains.kotlin.scripting.repl.GenericReplCompiler
-import java.io.File
-import java.net.URLClassLoader
-
-class JvmStandardReplFactoryExtension : ReplFactoryExtension {
-
-    override fun makeReplCompiler(
-        templateClassName: String,
-        templateClasspath: List<File>,
-        baseClassLoader: ClassLoader?,
-        configuration: CompilerConfiguration,
-        projectEnvironment: JavaCoreProjectEnvironment
-    ): ReplCompiler = GenericReplCompiler(
-        projectEnvironment.parentDisposable,
-        makeScriptDefinition(templateClasspath, templateClassName, baseClassLoader),
-        configuration,
-        configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
-    )
-
-    private fun makeScriptDefinition(
-        templateClasspath: List<File>, templateClassName: String, baseClassLoader: ClassLoader?
-    ): KotlinScriptDefinition = try {
-        val classloader = URLClassLoader(templateClasspath.map { it.toURI().toURL() }.toTypedArray(), baseClassLoader)
-        val cls = classloader.loadClass(templateClassName)
-        KotlinScriptDefinitionFromAnnotatedTemplate(cls.kotlin, emptyMap())
-    } catch (ex: ClassNotFoundException) {
-        throw IllegalStateException("Cannot find script definition template class $templateClassName", ex)
-    } catch (ex: Exception) {
-        throw IllegalStateException("Error loading script definition template $templateClassName", ex)
-    }
-}

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

@@ -1,30 +0,0 @@
-/*
- * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
- * that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.scripting.compiler.plugin
-
-import com.intellij.mock.MockProject
-import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.scripting.compiler.plugin.dependencies.collectScriptsCompilationDependencies
-import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.extensions.CollectAdditionalSourcesExtension
-import org.jetbrains.kotlin.psi.KtFile
-
-class ScriptingCollectAdditionalSourcesExtension(val project: MockProject) : CollectAdditionalSourcesExtension {
-    override fun collectAdditionalSourcesAndUpdateConfiguration(
-        knownSources: Collection<KtFile>,
-        configuration: CompilerConfiguration,
-        project: Project
-    ): Collection<KtFile> {
-        val (newSourcesClasspath, newSources, _) = collectScriptsCompilationDependencies(
-            configuration,
-            project,
-            knownSources
-        )
-        configuration.addJvmClasspathRoots(newSourcesClasspath)
-        return newSources
-    }
-}

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

@@ -6,14 +6,15 @@
 package org.jetbrains.kotlin.scripting.compiler.plugin
 
 import org.jetbrains.kotlin.compiler.plugin.AbstractCliOption
-import java.io.File
 import org.jetbrains.kotlin.compiler.plugin.CliOption
 import org.jetbrains.kotlin.compiler.plugin.CliOptionProcessingException
 import org.jetbrains.kotlin.compiler.plugin.CommandLineProcessor
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.CompilerConfigurationKey
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
-import org.jetbrains.kotlin.scripting.KOTLIN_SCRIPTING_PLUGIN_ID
+import org.jetbrains.kotlin.scripting.configuration.KOTLIN_SCRIPTING_PLUGIN_ID
+import org.jetbrains.kotlin.scripting.configuration.ScriptingConfigurationKeys
+import java.io.File
 
 object ScriptingConfigurationKeys {
     val DISABLE_SCRIPTING_PLUGIN_OPTION: CompilerConfigurationKey<Boolean> =
@@ -63,7 +64,6 @@ class ScriptingCommandLineProcessor : CommandLineProcessor {
             "Script resolver environment in key-value pairs (the value could be quoted and escaped)",
             required = false, allowMultipleOccurrences = true
         )
-
     }
 
     override val pluginId = KOTLIN_SCRIPTING_PLUGIN_ID
@@ -87,9 +87,9 @@ class ScriptingCommandLineProcessor : CommandLineProcessor {
         }
 
         SCRIPT_DEFINITIONS_OPTION, LEGACY_SCRIPT_TEMPLATES_OPTION -> {
-            val currentDefs = configuration.getList(ScriptingConfigurationKeys.SCRIPT_DEFINITIONS).toMutableList()
+            val currentDefs = configuration.getList(ScriptingConfigurationKeys.SCRIPT_DEFINITIONS_CLASSES).toMutableList()
             currentDefs.addAll(value.split(','))
-            configuration.put(ScriptingConfigurationKeys.SCRIPT_DEFINITIONS, currentDefs)
+            configuration.put(ScriptingConfigurationKeys.SCRIPT_DEFINITIONS_CLASSES, currentDefs)
         }
         SCRIPT_DEFINITIONS_CLASSPATH_OPTION -> {
             val currentCP = configuration.getList(ScriptingConfigurationKeys.SCRIPT_DEFINITIONS_CLASSPATH).toMutableList()

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

@@ -15,11 +15,12 @@ import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.extensions.CompilerConfigurationExtension
 import org.jetbrains.kotlin.idea.KotlinFileType
-import org.jetbrains.kotlin.script.ScriptDefinitionProvider
-import org.jetbrains.kotlin.script.StandardScriptDefinition
+import org.jetbrains.kotlin.scripting.compiler.plugin.definitions.CliScriptDefinitionProvider
+import org.jetbrains.kotlin.scripting.configuration.ScriptingConfigurationKeys
+import org.jetbrains.kotlin.scripting.configuration.configureScriptDefinitions
+import org.jetbrains.kotlin.scripting.definitions.ScriptDefinitionProvider
 import org.jetbrains.kotlin.scripting.definitions.ScriptDefinitionsFromClasspathDiscoverySource
-import org.jetbrains.kotlin.scripting.definitions.loadScriptTemplatesFromClasspath
-import org.jetbrains.kotlin.scripting.legacy.CliScriptDefinitionProvider
+import org.jetbrains.kotlin.scripting.definitions.StandardScriptDefinition
 import java.io.File
 
 class ScriptingCompilerConfigurationExtension(val project: MockProject) : CompilerConfigurationExtension {
@@ -39,7 +40,7 @@ class ScriptingCompilerConfigurationExtension(val project: MockProject) : Compil
             }
             val scriptResolverEnv = configuration.getMap(ScriptingConfigurationKeys.LEGACY_SCRIPT_RESOLVER_ENVIRONMENT_OPTION)
 
-            val explicitScriptDefinitions = configuration.getList(ScriptingConfigurationKeys.SCRIPT_DEFINITIONS)
+            val explicitScriptDefinitions = configuration.getList(ScriptingConfigurationKeys.SCRIPT_DEFINITIONS_CLASSES)
 
             if (explicitScriptDefinitions.isNotEmpty()) {
                 configureScriptDefinitions(
@@ -52,13 +53,16 @@ class ScriptingCompilerConfigurationExtension(val project: MockProject) : Compil
             }
             // If not disabled explicitly, we should always support at least the standard script definition
             if (!configuration.getBoolean(JVMConfigurationKeys.DISABLE_STANDARD_SCRIPT_DEFINITION) &&
-                !configuration.getList(JVMConfigurationKeys.SCRIPT_DEFINITIONS).contains(StandardScriptDefinition)
+                !configuration.getList(ScriptingConfigurationKeys.SCRIPT_DEFINITIONS).contains(StandardScriptDefinition)
             ) {
-                configuration.add(JVMConfigurationKeys.SCRIPT_DEFINITIONS, StandardScriptDefinition)
+                configuration.add(
+                    ScriptingConfigurationKeys.SCRIPT_DEFINITIONS,
+                    StandardScriptDefinition
+                )
             }
 
             configuration.add(
-                JVMConfigurationKeys.SCRIPT_DEFINITIONS_SOURCES,
+                ScriptingConfigurationKeys.SCRIPT_DEFINITIONS_SOURCES,
                 ScriptDefinitionsFromClasspathDiscoverySource(
                     configuration.jvmClasspathRoots,
                     configuration.get(ScriptingConfigurationKeys.LEGACY_SCRIPT_RESOLVER_ENVIRONMENT_OPTION) ?: emptyMap(),
@@ -69,15 +73,18 @@ class ScriptingCompilerConfigurationExtension(val project: MockProject) : Compil
 
         // If not disabled explicitly, we should always support at least the standard script definition
         if (!configuration.getBoolean(JVMConfigurationKeys.DISABLE_STANDARD_SCRIPT_DEFINITION) &&
-            StandardScriptDefinition !in configuration.getList(JVMConfigurationKeys.SCRIPT_DEFINITIONS)
+            StandardScriptDefinition !in configuration.getList(ScriptingConfigurationKeys.SCRIPT_DEFINITIONS)
         ) {
-            configuration.add(JVMConfigurationKeys.SCRIPT_DEFINITIONS, StandardScriptDefinition)
+            configuration.add(
+                ScriptingConfigurationKeys.SCRIPT_DEFINITIONS,
+                StandardScriptDefinition
+            )
         }
 
         val scriptDefinitionProvider = ScriptDefinitionProvider.getInstance(project) as? CliScriptDefinitionProvider
         if (scriptDefinitionProvider != null) {
-            scriptDefinitionProvider.setScriptDefinitionsSources(configuration.getList(JVMConfigurationKeys.SCRIPT_DEFINITIONS_SOURCES))
-            scriptDefinitionProvider.setScriptDefinitions(configuration.getList(JVMConfigurationKeys.SCRIPT_DEFINITIONS))
+            scriptDefinitionProvider.setScriptDefinitionsSources(configuration.getList(ScriptingConfigurationKeys.SCRIPT_DEFINITIONS_SOURCES))
+            scriptDefinitionProvider.setScriptDefinitions(configuration.getList(ScriptingConfigurationKeys.SCRIPT_DEFINITIONS))
 
             // Register new file extensions
             val fileTypeRegistry = FileTypeRegistry.getInstance() as CoreFileTypeRegistry
@@ -92,17 +99,3 @@ class ScriptingCompilerConfigurationExtension(val project: MockProject) : Compil
     }
 }
 
-fun configureScriptDefinitions(
-    scriptTemplates: List<String>,
-    configuration: CompilerConfiguration,
-    baseClassloader: ClassLoader,
-    messageCollector: MessageCollector,
-    scriptResolverEnv: Map<String, Any?>
-) {
-    // TODO: consider using escaping to allow kotlin escaped names in class names
-    val templatesFromClasspath = loadScriptTemplatesFromClasspath(
-        scriptTemplates, configuration.jvmClasspathRoots, emptyList(), baseClassloader, scriptResolverEnv, messageCollector
-    )
-    configuration.addAll(JVMConfigurationKeys.SCRIPT_DEFINITIONS, templatesFromClasspath.toList())
-}
-

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/definitions/CliScriptDefinitionProvider.kt

@@ -3,12 +3,12 @@
  * that can be found in the license/LICENSE.txt file.
  */
 
-package org.jetbrains.kotlin.scripting.legacy
+package org.jetbrains.kotlin.scripting.compiler.plugin.definitions
 
-import org.jetbrains.kotlin.script.KotlinScriptDefinition
-import org.jetbrains.kotlin.script.ScriptDefinitionsSource
-import org.jetbrains.kotlin.script.StandardScriptDefinition
+import org.jetbrains.kotlin.scripting.definitions.KotlinScriptDefinition
 import org.jetbrains.kotlin.scripting.definitions.LazyScriptDefinitionProvider
+import org.jetbrains.kotlin.scripting.definitions.ScriptDefinitionsSource
+import org.jetbrains.kotlin.scripting.definitions.StandardScriptDefinition
 import kotlin.concurrent.write
 
 open class CliScriptDefinitionProvider : LazyScriptDefinitionProvider() {

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/definitions/CliScriptDependenciesProvider.kt

@@ -1,30 +1,19 @@
 /*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
  */
 
-package org.jetbrains.kotlin.scripting.legacy
+package org.jetbrains.kotlin.scripting.compiler.plugin.definitions
 
 import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
-import org.jetbrains.kotlin.script.ScriptContentLoader
-import org.jetbrains.kotlin.script.ScriptDependenciesProvider
-import org.jetbrains.kotlin.script.ScriptReportSink
-import org.jetbrains.kotlin.script.adjustByDefinition
+import org.jetbrains.kotlin.scripting.definitions.ScriptDependenciesProvider
 import org.jetbrains.kotlin.scripting.definitions.findScriptDefinition
+import org.jetbrains.kotlin.scripting.resolve.ScriptContentLoader
+import org.jetbrains.kotlin.scripting.resolve.ScriptReportSink
+import org.jetbrains.kotlin.scripting.resolve.adjustByDefinition
 import java.io.File
 import java.util.concurrent.locks.ReentrantReadWriteLock
 import kotlin.concurrent.read

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/definitions/CliScriptReportSink.kt

@@ -3,16 +3,17 @@
  * that can be found in the license/LICENSE.txt file.
  */
 
-package org.jetbrains.kotlin.scripting.legacy
+package org.jetbrains.kotlin.scripting.compiler.plugin.definitions
 
 import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
-import org.jetbrains.kotlin.script.ScriptReportSink
+import org.jetbrains.kotlin.scripting.resolve.ScriptReportSink
 import kotlin.script.experimental.dependencies.ScriptReport
 
-internal class CliScriptReportSink(private val messageCollector: MessageCollector) : ScriptReportSink {
+internal class CliScriptReportSink(private val messageCollector: MessageCollector) :
+    ScriptReportSink {
     override fun attachReports(scriptFile: VirtualFile, reports: List<ScriptReport>) {
         reports.forEach {
             messageCollector.report(it.severity.convertSeverity(), it.message, location(scriptFile, it.position))

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/dependencies/ScriptsCompilationDependencies.kt

@@ -1,86 +0,0 @@
-/*
- * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
- * that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.scripting.compiler.plugin.dependencies
-
-import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.cli.jvm.compiler.createSourceFilesFromSourceRoots
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.script.ScriptDependenciesProvider
-import java.io.File
-
-data class ScriptsCompilationDependencies(
-    val classpath: List<File>,
-    val sources: List<KtFile>,
-    val sourceDependencies: List<SourceDependencies>
-) {
-    data class SourceDependencies(
-        val scriptFile: KtFile,
-        val sourceDependencies: List<KtFile>
-    )
-}
-
-// recursively collect dependencies from initial and imported scripts
-fun collectScriptsCompilationDependencies(
-    configuration: CompilerConfiguration,
-    project: Project,
-    initialSources: Iterable<KtFile>
-): ScriptsCompilationDependencies {
-    val collectedClassPath = ArrayList<File>()
-    val collectedSources = ArrayList<KtFile>()
-    val collectedSourceDependencies = ArrayList<ScriptsCompilationDependencies.SourceDependencies>()
-    var remainingSources = initialSources
-    val knownSourcePaths = initialSources.mapNotNullTo(HashSet()) { it.virtualFile?.path }
-    val importsProvider = ScriptDependenciesProvider.getInstance(project)
-    if (importsProvider != null) {
-        while (true) {
-            val newRemainingSources = ArrayList<KtFile>()
-            for (source in remainingSources) {
-                val dependencies = importsProvider.getScriptDependencies(source)
-                if (dependencies != null) {
-                    collectedClassPath.addAll(dependencies.classpath)
-
-                    val sourceDependenciesRoots = dependencies.scripts.map {
-                        KotlinSourceRoot(it.path, false)
-                    }
-                    val sourceDependencies =
-                        createSourceFilesFromSourceRoots(
-                            configuration, project, sourceDependenciesRoots,
-                            // TODO: consider receiving and using precise location from the resolver in the future
-                            source.virtualFile?.path?.let { CompilerMessageLocation.create(it) }
-                        )
-                    if (sourceDependencies.isNotEmpty()) {
-                        collectedSourceDependencies.add(
-                            ScriptsCompilationDependencies.SourceDependencies(
-                                source,
-                                sourceDependencies
-                            )
-                        )
-
-                        val newSources = sourceDependencies.filterNot { knownSourcePaths.contains(it.virtualFile.path) }
-                        for (newSource in newSources) {
-                            collectedSources.add(newSource)
-                            newRemainingSources.add(newSource)
-                            knownSourcePaths.add(newSource.virtualFile.path)
-                        }
-                    }
-                }
-            }
-            if (newRemainingSources.isEmpty()) break
-            else {
-                remainingSources = newRemainingSources
-            }
-        }
-    }
-    return ScriptsCompilationDependencies(
-        collectedClassPath.distinctBy { it.absolutePath },
-        collectedSources,
-        collectedSourceDependencies
-    )
-}

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

@@ -17,14 +17,13 @@ import org.jetbrains.kotlin.extensions.CompilerConfigurationExtension
 import org.jetbrains.kotlin.extensions.ProjectExtensionDescriptor
 import org.jetbrains.kotlin.resolve.extensions.ExtraImportsProviderExtension
 import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension
-import org.jetbrains.kotlin.script.ScriptDefinitionProvider
-import org.jetbrains.kotlin.script.ScriptDependenciesProvider
-import org.jetbrains.kotlin.script.ScriptReportSink
-import org.jetbrains.kotlin.scripting.legacy.CliScriptDefinitionProvider
-import org.jetbrains.kotlin.scripting.legacy.CliScriptDependenciesProvider
-import org.jetbrains.kotlin.scripting.legacy.CliScriptReportSink
-import org.jetbrains.kotlin.scripting.extensions.ScriptExtraImportsProviderExtension
-import org.jetbrains.kotlin.scripting.extensions.ScriptingResolveExtension
+import org.jetbrains.kotlin.scripting.compiler.plugin.definitions.CliScriptDefinitionProvider
+import org.jetbrains.kotlin.scripting.compiler.plugin.definitions.CliScriptDependenciesProvider
+import org.jetbrains.kotlin.scripting.compiler.plugin.definitions.CliScriptReportSink
+import org.jetbrains.kotlin.scripting.definitions.ScriptDefinitionProvider
+import org.jetbrains.kotlin.scripting.definitions.ScriptDependenciesProvider
+import org.jetbrains.kotlin.scripting.extensions.*
+import org.jetbrains.kotlin.scripting.resolve.ScriptReportSink
 
 private fun <T> ProjectExtensionDescriptor<T>.registerExtensionIfRequired(project: MockProject, extension: T) {
     try {

plugins/scripting/scripting-compiler/tests/org/jetbrains/kotlin/scripting/compiler/plugin/ScriptProviderTest.kt

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.scripting.compiler.plugin
+
+import org.jetbrains.kotlin.scripting.compiler.plugin.definitions.CliScriptDefinitionProvider
+import org.jetbrains.kotlin.scripting.definitions.KotlinScriptDefinition
+import org.jetbrains.kotlin.scripting.definitions.ScriptDefinitionsSource
+import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
+import org.junit.Assert
+import org.junit.Test
+import java.util.concurrent.atomic.AtomicInteger
+import kotlin.script.templates.standard.ScriptTemplateWithArgs
+
+class ScriptProviderTest : KtUsefulTestCase() {
+
+    @Test
+    fun testLazyScriptDefinitionsProvider() {
+
+        val genDefCounter = AtomicInteger()
+        val standardDef = FakeScriptDefinition()
+        val shadedDef = FakeScriptDefinition(".x.kts")
+        val provider = TestCliScriptDefinitionProvider(standardDef).apply {
+            setScriptDefinitions(listOf(shadedDef, standardDef))
+            setScriptDefinitionsSources(listOf(
+                TestScriptDefinitionSource(
+                    genDefCounter,
+                    ".y.kts",
+                    ".x.kts"
+                )
+            ))
+        }
+
+        Assert.assertEquals(0, genDefCounter.get())
+
+        provider.isScript("a.kt").let {
+            Assert.assertFalse(it)
+            Assert.assertEquals(0, genDefCounter.get())
+        }
+
+        provider.isScript("a.y.kts").let {
+            Assert.assertTrue(it)
+            Assert.assertEquals(1, genDefCounter.get())
+        }
+
+        provider.isScript("a.x.kts").let {
+            Assert.assertTrue(it)
+            Assert.assertEquals(1, genDefCounter.get())
+            Assert.assertEquals(1, shadedDef.matchCounter.get())
+        }
+
+        provider.isScript("a.z.kts").let {
+            Assert.assertTrue(it)
+            Assert.assertEquals(2, genDefCounter.get())
+            Assert.assertEquals(1, standardDef.matchCounter.get())
+        }
+
+        provider.isScript("a.ktx").let {
+            Assert.assertFalse(it)
+            Assert.assertEquals(2, genDefCounter.get())
+        }
+    }
+}
+
+private open class FakeScriptDefinition(val suffix: String = ".kts") : KotlinScriptDefinition(ScriptTemplateWithArgs::class) {
+    val matchCounter = AtomicInteger()
+    override fun isScript(fileName: String): Boolean = fileName.endsWith(suffix).also {
+        if (it) matchCounter.incrementAndGet()
+    }
+}
+
+private class TestScriptDefinitionSource(val counter: AtomicInteger, val defGens: Iterable<() -> FakeScriptDefinition>) :
+    ScriptDefinitionsSource
+{
+    constructor(counter: AtomicInteger, vararg suffixes: String) : this(counter, suffixes.map { {
+        FakeScriptDefinition(
+            it
+        )
+    } })
+
+    override val definitions: Sequence<KotlinScriptDefinition> = sequence {
+        for (gen in defGens) {
+            counter.incrementAndGet()
+            yield(gen())
+        }
+    }
+}
+
+private class TestCliScriptDefinitionProvider(private val standardDef: KotlinScriptDefinition) : CliScriptDefinitionProvider() {
+    override fun getDefaultScriptDefinition(): KotlinScriptDefinition = standardDef
+}

plugins/scripting/scripting-compiler/tests/org/jetbrains/kotlin/scripting/compiler/plugin/ScriptingCompilerPluginTest.kt

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.compiler.plugin.AbstractCliOption
 import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.scripting.configuration.ScriptingConfigurationKeys
 import org.jetbrains.kotlin.scripting.definitions.SCRIPT_DEFINITION_MARKERS_PATH
 import org.jetbrains.kotlin.scripting.definitions.discoverScriptTemplatesInClasspath
 import org.jetbrains.kotlin.scripting.definitions.loadScriptTemplatesFromClasspath
@@ -166,7 +167,7 @@ class ScriptingCompilerPluginTest : TestCaseWithTmpdir() {
             addJvmClasspathRoots(runtimeClasspath)
             addJvmClasspathRoots(scriptingClasspath)
             addJvmClasspathRoot(defsOut)
-            addAll(JVMConfigurationKeys.SCRIPT_DEFINITIONS, lazyDefs)
+            addAll(ScriptingConfigurationKeys.SCRIPT_DEFINITIONS, lazyDefs)
         }
 
         val res = KotlinToJVMBytecodeCompiler.compileBunchOfSources(scriptsCompileEnv)