Scripting: update scripts in source roots handling

#KT-52525 fixed
related to #KT-52735

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

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2022 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.extensions
+
+import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.config.languageVersionSettings
+import org.jetbrains.kotlin.extensions.ProcessSourcesBeforeCompilingExtension
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.scripting.definitions.ScriptDefinitionProvider
+import org.jetbrains.kotlin.scripting.resolve.KtFileScriptSource
+import kotlin.script.experimental.api.*
+
+class ScriptingProcessSourcesBeforeCompilingExtension(val project: Project) : ProcessSourcesBeforeCompilingExtension {
+
+    override fun processSources(sources: Collection<KtFile>, configuration: CompilerConfiguration): Collection<KtFile> {
+        val versionSettings = configuration.languageVersionSettings
+        val shouldSkipStandaloneScripts = versionSettings.supportsFeature(LanguageFeature.SkipStandaloneScriptsInSourceRoots)
+        val definitionProvider by lazy(LazyThreadSafetyMode.NONE) { ScriptDefinitionProvider.getInstance(project) }
+        val messageCollector = configuration.getNotNull(MESSAGE_COLLECTOR_KEY)
+
+        fun KtFile.isStandaloneScript(): Boolean {
+            val scriptDefinition = definitionProvider?.findDefinition(KtFileScriptSource(this))
+            return scriptDefinition?.compilationConfiguration?.get(ScriptCompilationConfiguration.isStandalone) ?: true
+        }
+
+        // filter out scripts that are not suitable for source roots, according to the compiler configuration and script definitions
+        return sources.filter { ktFile ->
+            when {
+                !ktFile.isScript() -> true
+                configuration.getBoolean(CommonConfigurationKeys.ALLOW_ANY_SCRIPTS_IN_SOURCE_ROOTS) -> true
+                !ktFile.isStandaloneScript() -> true
+                else -> {
+                    if (!shouldSkipStandaloneScripts) {
+                        messageCollector.report(
+                            CompilerMessageSeverity.WARNING,
+                            "Script '${ktFile.name}' is not supposed to be used along with regular Kotlin sources, and will be ignored in the future versions by default. (Use -Xallow-any-scripts-in-source-roots command line option to opt-in for the old behavior.)"
+                        )
+                    }
+                    !shouldSkipStandaloneScripts
+                }
+            }
+        }
+    }
+}

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

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.extensions.CollectAdditionalSourcesExtension
 import org.jetbrains.kotlin.extensions.CompilerConfigurationExtension
+import org.jetbrains.kotlin.extensions.ProcessSourcesBeforeCompilingExtension
 import org.jetbrains.kotlin.extensions.ProjectExtensionDescriptor
 import org.jetbrains.kotlin.resolve.extensions.ExtraImportsProviderExtension
 import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension
@@ -24,6 +25,7 @@ import org.jetbrains.kotlin.scripting.compiler.plugin.definitions.CliScriptDepen
 import org.jetbrains.kotlin.scripting.compiler.plugin.definitions.CliScriptReportSink
 import org.jetbrains.kotlin.scripting.compiler.plugin.extensions.JvmStandardReplFactoryExtension
 import org.jetbrains.kotlin.scripting.compiler.plugin.extensions.ScriptingCollectAdditionalSourcesExtension
+import org.jetbrains.kotlin.scripting.compiler.plugin.extensions.ScriptingProcessSourcesBeforeCompilingExtension
 import org.jetbrains.kotlin.scripting.definitions.ScriptDefinitionProvider
 import org.jetbrains.kotlin.scripting.definitions.ScriptDependenciesProvider
 import org.jetbrains.kotlin.scripting.extensions.ScriptExtraImportsProviderExtension
@@ -56,6 +58,7 @@ class ScriptingCompilerConfigurationComponentRegistrar : ComponentRegistrar {
         withClassloadingProblemsReporting(messageCollector) {
             CompilerConfigurationExtension.registerExtension(project, ScriptingCompilerConfigurationExtension(project, hostConfiguration))
             CollectAdditionalSourcesExtension.registerExtension(project, ScriptingCollectAdditionalSourcesExtension(project))
+            ProcessSourcesBeforeCompilingExtension.registerExtension(project, ScriptingProcessSourcesBeforeCompilingExtension(project))
             ScriptEvaluationExtension.registerExtensionIfRequired(project, JvmCliScriptEvaluationExtension())
             ShellExtension.registerExtensionIfRequired(project, JvmCliReplShellExtension())
             ReplFactoryExtension.registerExtensionIfRequired(project, JvmStandardReplFactoryExtension())

plugins/scripting/scripting-compiler/testData/compiler/mixedCompilation/simpleScript.main.kts

@@ -0,0 +1,2 @@
+
+val ok = "OK"

plugins/scripting/scripting-compiler/testData/compiler/mixedCompilation/simpleScriptInstance.kt

@@ -0,0 +1,4 @@
+
+fun main() {
+    println(SimpleScript_main(emptyArray<String>(), java.io.File("")).ok)
+}

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.scripting.compiler.plugin
 
 import org.jetbrains.kotlin.cli.common.CLITool
+import org.jetbrains.kotlin.cli.common.ExitCode
 import org.jetbrains.kotlin.cli.common.environment.setIdeaIoUseFallback
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
 import org.jetbrains.kotlin.scripting.compiler.test.linesSplitTrim
@@ -187,6 +188,58 @@ class ScriptingWithCliCompilerTest {
         )
     }
 
+    @Test
+    fun testCompileScriptWithRegularKotlin() {
+
+        fun compileVariant(vararg flags: String): Pair<List<String>, ExitCode> {
+            return withTempDir { tmpdir ->
+                val (_, err, exitCode) = captureOutErrRet {
+                    CLITool.doMainNoExit(
+                        K2JVMCompiler(),
+                        arrayOf(
+                            "-d", tmpdir.path,
+                            "-cp", getMainKtsClassPath().joinToString(File.pathSeparator),
+                            *flags,
+                            "$TEST_DATA_DIR/compiler/mixedCompilation/simpleScriptInstance.kt",
+                            "$TEST_DATA_DIR/compiler/mixedCompilation/simpleScript.main.kts"
+                        )
+                    )
+                }
+                err.linesSplitTrim() to exitCode
+            }
+        }
+
+        val scriptInSourceRootWarning =
+            "warning: script 'simpleScript.main.kts' is not supposed to be used along with regular Kotlin sources, and will be ignored in the future versions"
+
+        val unresolvedScriptError =
+            "simpleScriptInstance.kt:3:13: error: unresolved reference: SimpleScript_main"
+
+        compileVariant("-language-version", "1.7").let { (errLines, exitCode) ->
+            Assert.assertTrue(errLines.any { it.startsWith(scriptInSourceRootWarning) })
+            Assert.assertEquals(ExitCode.OK, exitCode)
+        }
+
+        compileVariant("-language-version", "1.7", "-Xallow-any-scripts-in-source-roots").let { (errLines, exitCode) ->
+            Assert.assertTrue(errLines.none { it.startsWith(scriptInSourceRootWarning) })
+            Assert.assertEquals(ExitCode.OK, exitCode)
+        }
+
+        compileVariant("-language-version", "1.9").let { (errLines, exitCode) ->
+            if (errLines.none { it.endsWith(unresolvedScriptError) }) {
+                Assert.fail("Expecting unresolved reference: SimpleScript_main error, got:\n${errLines.joinToString("\n")}")
+            }
+            Assert.assertEquals(ExitCode.COMPILATION_ERROR, exitCode)
+        }
+
+        compileVariant("-language-version", "1.9", "-Xallow-any-scripts-in-source-roots").let { (errLines, exitCode) ->
+            Assert.assertTrue(errLines.none {
+                it.endsWith(unresolvedScriptError) || it.startsWith(scriptInSourceRootWarning)
+            })
+            Assert.assertEquals(ExitCode.OK, exitCode)
+        }
+    }
+
     private fun getMainKtsClassPath(): List<File> {
         return listOf(
             File("dist/kotlinc/lib/kotlin-main-kts.jar").also {

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

@@ -224,10 +224,10 @@ internal fun <T> captureOutErrRet(body: () -> T): Triple<String, String, T> {
     return Triple(outStream.toString().trim(), errStream.toString().trim(), ret)
 }
 
-internal fun <R> withTempDir(keyName: String = "tmp", body: (File) -> R) {
+internal fun <R> withTempDir(keyName: String = "tmp", body: (File) -> R): R {
     val tempDir = Files.createTempDirectory(keyName).toFile()
     try {
-        body(tempDir)
+        return body(tempDir)
     } finally {
         tempDir.deleteRecursively()
     }