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
2020-01-16 09:33:30 +03:00
parent a373ab96d4
commit 858698cf9a
12 changed files with 262 additions and 23 deletions
@@ -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"))
    }
 }
@@ -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
            }
@@ -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)
@@ -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.
@@ -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) }
    }

@@ -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(ktFile) { "finish dependencies loading" }
-
-        return true
+        debug(file) { "finish dependencies loading" }
+        return result
    }

    protected open fun getInputsStamp(virtualFile: VirtualFile, file: KtFile): CachedConfigurationInputs {
@@ -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)) {
-            // todo: provide an action to load configuration through scripting API: KT-34625, KT-35268
+        if (!isInAffectedGradleProjectFiles(ktFile.project, vFile.path)) {
+            ScriptConfigurationManager.markFileWithManualConfigurationLoading(vFile)
+            return true
        }

        // Gradle read files from FS
@@ -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")
+    }
+}
@@ -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"
-private const val insidePlaceholder = "// INSIDE_SECTIONS"
+open class GradleScriptInputsWatcherTest : AbstractScriptConfigurationLoadingTest() {
+    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)
@@ -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)
+}
@@ -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"/>
@@ -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"/>