Scripting: extract API to check if script is related to any gradle project

KT-35268 cannot be implemented without explicit action for loading configurations for script outside of project model

^KT-35268
^KT-34625

idea/idea-gradle/src/org/jetbrains/kotlin/idea/scripting/gradle/GradleScriptConfigurationLoader.kt

@@ -37,16 +37,20 @@ class GradleScriptConfigurationLoader(project: Project) : DefaultScriptConfigura
             // todo: use default configuration loader for out-of-project scripts?
 
             return true
-        } else {
-            // Gradle read files from FS
-            GlobalScope.launch(EDT(project)) {
-                runWriteAction {
-                    FileDocumentManager.getInstance().saveAllDocuments()
-                }
-            }
-
-            return super.loadDependencies(isFirstLoad, ktFile, scriptDefinition, context)
         }
+
+        if (!isInAffectedGradleProjectFiles(ktFile.project, ktFile.originalFile.virtualFile)) {
+            // todo: provide an action to load configuration through scripting API: KT-34625, KT-35268
+        }
+
+        // Gradle read files from FS
+        GlobalScope.launch(EDT(project)) {
+            runWriteAction {
+                FileDocumentManager.getInstance().saveAllDocuments()
+            }
+        }
+
+        return super.loadDependencies(isFirstLoad, ktFile, scriptDefinition, context)
     }
 
     override fun getInputsStamp(virtualFile: VirtualFile, file: KtFile): CachedConfigurationInputs {

idea/idea-gradle/src/org/jetbrains/kotlin/idea/scripting/gradle/GradleScriptListener.kt

@@ -40,14 +40,6 @@ open class GradleScriptListener(project: Project) : ScriptChangeListener(project
     }
 
     override fun isApplicable(vFile: VirtualFile): Boolean {
-        val gradleSettings = ExternalSystemApiUtil.getSettings(project, GradleConstants.SYSTEM_ID)
+        return isInAffectedGradleProjectFiles(project, vFile)
-        if (gradleSettings.getLinkedProjectsSettings().isEmpty()) return false
-
-        val projectSettings = gradleSettings.getLinkedProjectsSettings().filterIsInstance<GradleProjectSettings>().firstOrNull()
-            ?: return false
-
-        val affectedFiles = ExternalSystemApiUtil.getAllManagers().filterIsInstance<GradleManager>().firstOrNull()
-            ?.getAffectedExternalProjectFiles(projectSettings.externalProjectPath, project)
-        return affectedFiles?.any { it.toPath().systemIndependentPath == vFile.path } == true
     }
 }

idea/idea-gradle/src/org/jetbrains/kotlin/idea/scripting/gradle/utils.kt

@@ -5,23 +5,54 @@
 
 package org.jetbrains.kotlin.idea.scripting.gradle
 
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.components.service
+import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
 import com.intellij.openapi.components.service
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.registry.Registry
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.*
 import com.intellij.psi.impl.source.tree.LeafPsiElement
+import com.intellij.util.io.systemIndependentPath
 import org.gradle.util.GradleVersion
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.psi.KtCallExpression
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtScriptInitializer
 import org.jetbrains.kotlin.psi.psiUtil.getChildrenOfType
+import org.jetbrains.plugins.gradle.GradleManager
+import org.jetbrains.plugins.gradle.settings.GradleProjectSettings
+import org.jetbrains.plugins.gradle.util.GradleConstants
+import java.io.File
 
 private val sections = arrayListOf("buildscript", "plugins", "initscript", "pluginManagement")
 
 fun isGradleKotlinScript(virtualFile: VirtualFile) = virtualFile.name.endsWith(".gradle.kts")
 
+fun isInAffectedGradleProjectFiles(project: Project, file: VirtualFile): Boolean {
+    val affectedFiles = getAffectedGradleProjectFiles(project)
+    return isInAffectedGradleProjectFiles(affectedFiles, file)
+}
+
+fun isInAffectedGradleProjectFiles(files: List<File>, file: VirtualFile): Boolean {
+    // todo: avoid isUnitTestMode usage
+    if (ApplicationManager.getApplication().isUnitTestMode) return true
+
+    return files.any { it.toPath().systemIndependentPath == file.path }
+}
+
+fun getAffectedGradleProjectFiles(project: Project): List<File> {
+    val gradleSettings = ExternalSystemApiUtil.getSettings(project, GradleConstants.SYSTEM_ID)
+    if (gradleSettings.getLinkedProjectsSettings().isEmpty()) return emptyList()
+
+    val projectSettings = gradleSettings.getLinkedProjectsSettings().filterIsInstance<GradleProjectSettings>().firstOrNull()
+        ?: return emptyList()
+
+    return ExternalSystemApiUtil.getAllManagers().filterIsInstance<GradleManager>().firstOrNull()
+        ?.getAffectedExternalProjectFiles(projectSettings.externalProjectPath, project) ?: emptyList()
+}
+
 fun getGradleScriptInputsStamp(
     project: Project,
     file: VirtualFile,