Provide a notification for gradle script that aren't related to any gradle project (KT-35268)

Add action to load/reload configuration for them manually
^KT-35268 Fixed

idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptConfigurationManager.kt

@@ -21,6 +21,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.projectRoots.JavaSdkType
 import com.intellij.openapi.projectRoots.Sdk
 import com.intellij.openapi.roots.ProjectRootManager
+import com.intellij.openapi.util.Key
 import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiFile
@@ -31,7 +32,9 @@ import org.jetbrains.kotlin.idea.caches.project.getAllProjectSdks
 import org.jetbrains.kotlin.idea.core.script.configuration.AbstractScriptConfigurationManager
 import org.jetbrains.kotlin.idea.core.script.configuration.cache.ScriptConfigurationSnapshot
 import org.jetbrains.kotlin.idea.core.script.configuration.listener.ScriptConfigurationUpdater
+import org.jetbrains.kotlin.idea.core.script.configuration.loader.ScriptConfigurationLoader
 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.UserDataProperty
 import org.jetbrains.kotlin.scripting.definitions.ScriptDependenciesProvider
 import org.jetbrains.kotlin.scripting.resolve.ScriptCompilationConfigurationResult
 import org.jetbrains.kotlin.scripting.resolve.ScriptCompilationConfigurationWrapper
@@ -70,6 +73,12 @@ interface ScriptConfigurationManager {
      */
     fun getConfiguration(file: KtFile): ScriptCompilationConfigurationWrapper?
 
+    /**
+     * Reload the configuration for [file] even it is already loaded.
+     * [loader] is used to load configuration. Other loaders aren't taken into account.
+     */
+    fun forceReloadConfiguration(file: VirtualFile, loader: ScriptConfigurationLoader): ScriptCompilationConfigurationWrapper?
+
     @Deprecated("Use getScriptClasspath(KtFile) instead")
     fun getScriptClasspath(file: VirtualFile): List<VirtualFile>
 
@@ -165,5 +174,13 @@ interface ScriptConfigurationManager {
         fun clearCaches(project: Project) {
             (getInstance(project) as AbstractScriptConfigurationManager).clearCaches()
         }
+
+        fun markFileWithManualConfigurationLoading(file: VirtualFile) {
+            file.LOAD_CONFIGURATION_MANUALLY = true
+        }
+
+        fun isManualConfigurationLoading(file: VirtualFile): Boolean = file.LOAD_CONFIGURATION_MANUALLY ?: false
+
+        private var VirtualFile.LOAD_CONFIGURATION_MANUALLY: Boolean? by UserDataProperty(Key.create<Boolean>("MANUAL_CONFIGURATION_LOADING"))
     }
 }

idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptTrafficLightRendererContributor.kt

@@ -29,7 +29,10 @@ class ScriptTrafficLightRendererContributor : TrafficLightRendererContributor {
             if (!ScriptDefinitionsManager.getInstance(file.project).isReady()) {
                 status.reasonWhySuspended = "Loading kotlin script definitions"
                 status.errorAnalyzingFinished = false
-            } else if (!ScriptConfigurationManager.getInstance(project).hasConfiguration(file)) {
+            } else if (
+                !ScriptConfigurationManager.getInstance(project).hasConfiguration(file)
+                && !ScriptConfigurationManager.isManualConfigurationLoading(file.originalFile.virtualFile)
+            ) {
                 status.reasonWhySuspended = "Loading kotlin script dependencies"
                 status.errorAnalyzingFinished = false
             }

idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/configuration/AbstractScriptConfigurationManager.kt

@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.idea.core.script.configuration.cache.ScriptConfigura
 import org.jetbrains.kotlin.idea.core.script.configuration.cache.ScriptConfigurationSnapshot
 import org.jetbrains.kotlin.idea.core.script.configuration.cache.ScriptConfigurationState
 import org.jetbrains.kotlin.idea.core.script.configuration.listener.ScriptConfigurationUpdater
+import org.jetbrains.kotlin.idea.core.script.configuration.loader.ScriptConfigurationLoader
 import org.jetbrains.kotlin.idea.core.script.configuration.utils.ScriptClassRootsCache
 import org.jetbrains.kotlin.idea.core.script.configuration.utils.ScriptClassRootsIndexer
 import org.jetbrains.kotlin.idea.core.script.configuration.utils.getKtFile
@@ -82,6 +83,17 @@ internal abstract class AbstractScriptConfigurationManager(
         forceSync: Boolean = false
     )
 
+    /**
+     * Will be called on user action
+     * Load configuration event it is already cached or inputs are up-to-date
+     *
+     * @param loader is used to load configuration. Other loaders aren't taken into account.
+     */
+    protected abstract fun forceReloadConfiguration(
+        file: KtFile,
+        loader: ScriptConfigurationLoader
+    )
+
     @Deprecated("Use getScriptClasspath(KtFile) instead")
     override fun getScriptClasspath(file: VirtualFile): List<VirtualFile> {
         val ktFile = project.getKtFile(file) ?: return emptyList()
@@ -122,6 +134,19 @@ internal abstract class AbstractScriptConfigurationManager(
         return getAppliedConfiguration(virtualFile)?.configuration
     }
 
+    override fun forceReloadConfiguration(
+        file: VirtualFile,
+        loader: ScriptConfigurationLoader
+    ): ScriptCompilationConfigurationWrapper? {
+        val ktFile = project.getKtFile(file, null) ?: return null
+
+        rootsIndexer.transaction {
+            forceReloadConfiguration(ktFile, loader)
+        }
+
+        return getAppliedConfiguration(file)?.configuration
+    }
+
     override val updater: ScriptConfigurationUpdater = object : ScriptConfigurationUpdater {
         override fun ensureUpToDatedConfigurationSuggested(file: KtFile) {
             reloadIfOutOfDate(listOf(file), true)

idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/configuration/DefaultScriptConfigurationManager.kt

@@ -32,14 +32,10 @@ import org.jetbrains.kotlin.idea.core.script.settings.KotlinScriptingSettings
 import org.jetbrains.kotlin.idea.core.util.EDT
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.scripting.definitions.findScriptDefinition
-import org.jetbrains.kotlin.scripting.resolve.ScriptCompilationConfigurationWrapper
 import org.jetbrains.kotlin.scripting.resolve.ScriptReportSink
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
 import kotlin.script.experimental.api.*
-import kotlin.script.experimental.jvm.impl.toClassPathOrEmpty
-import kotlin.script.experimental.jvm.jdkHome
-import kotlin.script.experimental.jvm.jvm
 
 /**
  * Standard implementation of scripts configuration loading and caching
@@ -184,7 +180,7 @@ internal class DefaultScriptConfigurationManager(project: Project) :
         if (syncLoader == null) {
             // run async loader
             if (forceSync) {
-                async.first { it.loadDependencies(isFirstLoad, file, scriptDefinition, loadingContext) }
+                async.firstOrNull { it.loadDependencies(isFirstLoad, file, scriptDefinition, loadingContext) }
             } else {
                 backgroundExecutor.ensureScheduled(virtualFile) {
                     val cached = getCachedConfigurationState(virtualFile)
@@ -197,13 +193,28 @@ internal class DefaultScriptConfigurationManager(project: Project) :
                         // don't start loading if nothing was changed
                         // (in case we checking for up-to-date and loading concurrently)
                         val actualIsFirstLoad = cached == null
-                        async.first { it.loadDependencies(actualIsFirstLoad, file, scriptDefinition, loadingContext) }
+                        async.firstOrNull { it.loadDependencies(actualIsFirstLoad, file, scriptDefinition, loadingContext) }
                     }
                 }
             }
         }
     }
 
+    override fun forceReloadConfiguration(file: KtFile, loader: ScriptConfigurationLoader) {
+        val virtualFile = file.originalFile.virtualFile ?: return
+
+        if (!ScriptDefinitionsManager.getInstance(project).isReady()) return
+        val scriptDefinition = file.findScriptDefinition() ?: return
+
+        if (!loader.shouldRunInBackground(scriptDefinition)) {
+            loader.loadDependencies(false, file, scriptDefinition, loadingContext)
+        } else {
+            backgroundExecutor.ensureScheduled(virtualFile) {
+                loader.loadDependencies(false, file, scriptDefinition, loadingContext)
+            }
+        }
+    }
+
     /**
      * Save configurations into cache.
      * Start indexing for new class/source roots.

idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/configuration/listener/ScriptChangesNotifier.kt

@@ -16,6 +16,7 @@ import com.intellij.openapi.fileEditor.FileEditorManagerListener
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.util.Alarm
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.core.script.configuration.listener.ScriptChangeListener.Companion.LISTENER
 import org.jetbrains.kotlin.idea.core.script.isScriptChangesNotifierDisabled
 
@@ -76,6 +77,8 @@ internal class ScriptChangesNotifier(
     private fun getListener(project: Project, file: VirtualFile): ScriptChangeListener? {
         if (project.isDisposed || areListenersDisabled()) return null
 
+        if (ScriptConfigurationManager.isManualConfigurationLoading(file)) return null
+
         return listeners.firstOrNull { it.isApplicable(file) }
     }
 

idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/configuration/loader/DefaultScriptConfigurationLoader.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.core.script.configuration.loader
 import com.intellij.openapi.diagnostic.ControlFlowException
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.core.script.configuration.cache.CachedConfigurationInputs
 import org.jetbrains.kotlin.idea.core.script.configuration.cache.ScriptConfigurationSnapshot
 import org.jetbrains.kotlin.idea.core.script.debug
@@ -38,12 +39,26 @@ open class DefaultScriptConfigurationLoader(val project: Project) : ScriptConfig
     ): Boolean {
         val virtualFile = ktFile.originalFile.virtualFile
 
-        debug(ktFile) { "start dependencies loading" }
+        if (ScriptConfigurationManager.isManualConfigurationLoading(virtualFile)) return false
 
-        val inputs = getInputsStamp(virtualFile, ktFile)
+        val result = getConfigurationThroughScriptingApi(ktFile, virtualFile, scriptDefinition)
+
+        context.suggestNewConfiguration(virtualFile, result)
+
+        return true
+    }
+
+    protected fun getConfigurationThroughScriptingApi(
+        file: KtFile,
+        vFile: VirtualFile,
+        scriptDefinition: ScriptDefinition
+    ): ScriptConfigurationSnapshot {
+        debug(file) { "start dependencies loading" }
+
+        val inputs = getInputsStamp(vFile, file)
         val scriptingApiResult = try {
             refineScriptCompilationConfiguration(
-                KtFileScriptSource(ktFile), scriptDefinition, ktFile.project
+                KtFileScriptSource(file), scriptDefinition, file.project
             )
         } catch (e: Throwable) {
             if (e is ControlFlowException) throw e
@@ -57,11 +72,8 @@ open class DefaultScriptConfigurationLoader(val project: Project) : ScriptConfig
             scriptingApiResult.valueOrNull()
         )
 
-        context.suggestNewConfiguration(virtualFile, result)
+        debug(file) { "finish dependencies loading" }
-
+        return result
-        debug(ktFile) { "finish dependencies loading" }
-
-        return true
     }
 
     protected open fun getInputsStamp(virtualFile: VirtualFile, file: KtFile): CachedConfigurationInputs {

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

@@ -10,6 +10,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.core.script.configuration.cache.CachedConfigurationInputs
 import org.jetbrains.kotlin.idea.core.script.configuration.loader.DefaultScriptConfigurationLoader
 import org.jetbrains.kotlin.idea.core.script.configuration.loader.ScriptConfigurationLoadingContext
@@ -18,6 +19,30 @@ import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.scripting.definitions.ScriptDefinition
 
+class GradleScriptConfigurationLoaderForOutOfProjectScripts(project: Project) : DefaultScriptConfigurationLoader(project) {
+    override fun loadDependencies(
+        isFirstLoad: Boolean,
+        ktFile: KtFile,
+        scriptDefinition: ScriptDefinition,
+        context: ScriptConfigurationLoadingContext
+    ): Boolean {
+        val vFile = ktFile.originalFile.virtualFile
+
+        // Gradle read files from FS
+        GlobalScope.launch(EDT(project)) {
+            runWriteAction {
+                FileDocumentManager.getInstance().saveAllDocuments()
+            }
+        }
+
+        val result = getConfigurationThroughScriptingApi(ktFile, vFile, scriptDefinition)
+
+        context.saveNewConfiguration(vFile, result)
+
+        return true
+    }
+}
+
 class GradleScriptConfigurationLoader(project: Project) : DefaultScriptConfigurationLoader(project) {
     override fun shouldRunInBackground(scriptDefinition: ScriptDefinition): Boolean {
         return if (useScriptConfigurationFromImportOnly()) false else super.shouldRunInBackground(scriptDefinition)
@@ -29,18 +54,19 @@ class GradleScriptConfigurationLoader(project: Project) : DefaultScriptConfigura
         scriptDefinition: ScriptDefinition,
         context: ScriptConfigurationLoadingContext
     ): Boolean {
-        if (!isGradleKotlinScript(ktFile.originalFile.virtualFile)) return false
+        val vFile = ktFile.originalFile.virtualFile
+
+        if (!isGradleKotlinScript(vFile)) return false
 
         if (useScriptConfigurationFromImportOnly()) {
             // do nothing, project import notification will be already showed
             // and configuration for gradle build scripts will be saved at the end of import
-            // todo: use default configuration loader for out-of-project scripts?
-
             return true
         }
 
-        if (!isInAffectedGradleProjectFiles(ktFile.project, ktFile.originalFile.virtualFile.path)) {
+        if (!isInAffectedGradleProjectFiles(ktFile.project, vFile.path)) {
-            // todo: provide an action to load configuration through scripting API: KT-34625, KT-35268
+            ScriptConfigurationManager.markFileWithManualConfigurationLoading(vFile)
+            return true
         }
 
         // Gradle read files from FS

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

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2020 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.idea.scripting.gradle
+
+import com.intellij.openapi.fileEditor.FileEditor
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.Key
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.ui.EditorNotificationPanel
+import com.intellij.ui.EditorNotifications
+import org.jetbrains.kotlin.idea.KotlinFileType
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
+
+class GradleScriptOutOfSourceNotificationProvider(private val project: Project) : EditorNotifications.Provider<EditorNotificationPanel>() {
+    override fun getKey(): Key<EditorNotificationPanel> = KEY
+
+    override fun createNotificationPanel(file: VirtualFile, fileEditor: FileEditor): EditorNotificationPanel? {
+        if (!isGradleKotlinScript(file)) return null
+        if (file.fileType != KotlinFileType.INSTANCE) return null
+
+        if (isInAffectedGradleProjectFiles(project, file.path)) return null
+
+        return EditorNotificationPanel().apply {
+            text("This script isn't related to any Gradle Project. To update its highlighting, please, load its script configuration.")
+            createActionLabel("Load configuration") {
+                ScriptConfigurationManager.getInstance(project).forceReloadConfiguration(file, loaderForOutOfProjectScripts)
+            }
+        }
+    }
+
+    private val loaderForOutOfProjectScripts by lazy {
+        GradleScriptConfigurationLoaderForOutOfProjectScripts(project)
+    }
+
+    companion object {
+        private val KEY = Key.create<EditorNotificationPanel>("GradleScriptOutOfSourceNotification")
+    }
+}

idea/idea-gradle/tests/org/jetbrains/kotlin/idea/scripting/gradle/GradleScriptInputsWatcherTest.kt

@@ -13,10 +13,12 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.plugins.gradle.util.GradleConstants
 import java.io.File
 
-private const val outsidePlaceholder = "// OUTSIDE_SECTIONS"
+open class GradleScriptInputsWatcherTest : AbstractScriptConfigurationLoadingTest() {
-private const val insidePlaceholder = "// INSIDE_SECTIONS"
+    companion object {
+        internal const val outsidePlaceholder = "// OUTSIDE_SECTIONS"
+        internal const val insidePlaceholder = "// INSIDE_SECTIONS"
+    }
 
-class GradleScriptInputsWatcherTest : AbstractScriptConfigurationLoadingTest() {
     private lateinit var testFiles: TestFiles
 
     data class TestFiles(val buildKts: KtFile, val settings: KtFile, val prop: PsiFile)

idea/idea-gradle/tests/org/jetbrains/kotlin/idea/scripting/gradle/GradleScriptOutOfProjectTest.kt

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2010-2020 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.idea.scripting.gradle
+
+import junit.framework.TestCase
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
+import org.jetbrains.kotlin.idea.script.AbstractScriptConfigurationLoadingTest
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.plugins.gradle.util.GradleConstants
+import java.io.File
+
+class GradleScriptOutOfProjectTest : AbstractScriptConfigurationLoadingTest() {
+
+    override fun setUpTestProject() {
+        val rootDir = "idea/testData/script/definition/loading/gradle/"
+
+        val buildGradleKts = File(rootDir).walkTopDown().find { it.name == GradleConstants.KOTLIN_DSL_SCRIPT_NAME }
+            ?: error("Couldn't find main script")
+
+        configureScriptFile(rootDir, buildGradleKts)
+
+        ScriptConfigurationManager.markFileWithManualConfigurationLoading(myFile.virtualFile)
+    }
+
+    private val loaderForOutOfProjectScripts by lazy {
+        GradleScriptConfigurationLoaderForOutOfProjectScripts(project)
+    }
+
+    fun testManualLoadingForUpToDate() {
+        assertConfigurationShouldBeLoadedManually()
+
+        scriptConfigurationManager.forceReloadConfiguration(myFile.virtualFile, loaderForOutOfProjectScripts)
+
+        assertConfigurationWasLoaded()
+    }
+
+    fun testManualLoadingForOutOfDate() {
+        assertConfigurationShouldBeLoadedManually()
+
+        makeChangesInsideSections()
+
+        assertNoBackgroundTasks()
+        assertNoLoading()
+
+        scriptConfigurationManager.forceReloadConfiguration(myFile.virtualFile, loaderForOutOfProjectScripts)
+
+        assertConfigurationWasLoaded()
+    }
+
+    fun testFileAttributesForManualLoading() {
+        assertConfigurationShouldBeLoadedManually()
+
+        scriptConfigurationManager.forceReloadConfiguration(myFile.virtualFile, loaderForOutOfProjectScripts)
+
+        assertConfigurationWasLoaded()
+
+        ScriptConfigurationManager.clearCaches(project)
+
+        assertNotNull(getConfiguration())
+    }
+
+    fun testNoNotificationAfterForReload() {
+        assertConfigurationShouldBeLoadedManually()
+
+        scriptConfigurationManager.forceReloadConfiguration(myFile.virtualFile, loaderForOutOfProjectScripts)
+        assertConfigurationWasLoaded()
+
+        makeChangesInsideSections()
+
+        scriptConfigurationManager.forceReloadConfiguration(myFile.virtualFile, loaderForOutOfProjectScripts)
+        assertConfigurationWasLoaded()
+
+    }
+
+    private fun makeChangesInsideSections() {
+        changeContents(myFile.text.replace(GradleScriptInputsWatcherTest.insidePlaceholder, "application"), myFile)
+    }
+
+    private fun assertConfigurationShouldBeLoadedManually() {
+        assertNull(getConfiguration())
+        assertAndDoAllBackgroundTasks()
+        assertNoLoading()
+    }
+
+    private fun assertConfigurationWasLoaded() {
+        assertAndDoAllBackgroundTasks()
+        assertSingleLoading()
+        assertNoSuggestedConfiguration()
+        assertNotNull(getConfiguration())
+    }
+
+    private fun getConfiguration() =
+        scriptConfigurationManager.getConfiguration(myFile as KtFile)
+}

idea/resources/META-INF/gradle-java.xml

@@ -27,6 +27,7 @@
         <externalProjectDataService implementation="org.jetbrains.kotlin.idea.KotlinJavaMPPSourceSetDataService"/>
         <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinNativeLibraryDataService"/>
         <externalSystemTaskNotificationListener implementation="org.jetbrains.kotlin.idea.scripting.gradle.GradleScriptDefinitionsUpdater"/>
+        <editorNotificationProvider implementation="org.jetbrains.kotlin.idea.scripting.gradle.GradleScriptOutOfSourceNotificationProvider"/>
 
         <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinJvmTestClassGradleConfigurationProducer"/>
         <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinMultiplatformJvmTestClassGradleConfigurationProducer"/>

idea/resources/META-INF/gradle-java.xml.191

@@ -24,6 +24,7 @@
         <externalProjectDataService implementation="org.jetbrains.kotlin.idea.KotlinJavaMPPSourceSetDataService"/>
         <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinNativeLibraryDataService"/>
         <externalSystemTaskNotificationListener implementation="org.jetbrains.kotlin.idea.scripting.gradle.GradleScriptDefinitionsUpdater"/>
+        <editorNotificationProvider implementation="org.jetbrains.kotlin.idea.scripting.gradle.GradleScriptOutOfSourceNotificationProvider"/>
 
         <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinJvmTestClassGradleConfigurationProducer"/>
         <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinMultiplatformJvmTestClassGradleConfigurationProducer"/>