Run partial import only for specified build root

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

@@ -22,6 +22,7 @@ import com.intellij.openapi.vfs.VirtualFile
 import org.gradle.util.GradleVersion
 import org.jetbrains.kotlin.idea.KotlinIcons
 import org.jetbrains.kotlin.idea.KotlinIdeaGradleBundle
+import org.jetbrains.kotlin.idea.scripting.gradle.roots.GradleBuildRoot
 import org.jetbrains.kotlin.idea.scripting.gradle.roots.GradleBuildRootsManager
 import org.jetbrains.kotlin.idea.util.application.getServiceSafe
 import org.jetbrains.kotlin.psi.UserDataProperty
@@ -32,25 +33,26 @@ import org.jetbrains.plugins.gradle.util.GradleConstants
 val scriptConfigurationsNeedToBeUpdatedBalloon
     get() = Registry.`is`("kotlin.gradle.scripts.scriptConfigurationsNeedToBeUpdatedBalloon", false)
 
-fun runPartialGradleImport(project: Project) {
-    getGradleProjectSettings(project).forEach {
-        ExternalSystemUtil.refreshProject(
-            it.externalProjectPath,
-            ImportSpecBuilder(project, GradleConstants.SYSTEM_ID)
-                .build()
-        )
+fun runPartialGradleImportForAllRoots(project: Project) {
+    GradleBuildRootsManager.getInstance(project).getAllRoots().forEach { root ->
+        runPartialGradleImport(project, root)
     }
 }
 
+fun runPartialGradleImport(project: Project, root: GradleBuildRoot) {
+    ExternalSystemUtil.refreshProject(
+        root.pathPrefix,
+        ImportSpecBuilder(project, GradleConstants.SYSTEM_ID)
+            .build()
+    )
+}
+
 fun getMissingConfigurationActionText() = KotlinIdeaGradleBundle.message("action.label.import.project")
 
-fun autoReloadScriptConfigurations(project: Project, file: VirtualFile): Boolean {
-    val path = GradleBuildRootsManager.getInstance(project)
-        .getScriptInfo(file)?.buildRoot?.pathPrefix ?: return false
-
+fun autoReloadScriptConfigurations(project: Project, root: GradleBuildRoot): Boolean {
     return ExternalSystemApiUtil
         .getSettings(project, GradleConstants.SYSTEM_ID)
-        .getLinkedProjectSettings(path)
+        .getLinkedProjectSettings(root.pathPrefix)
         ?.isUseAutoImport ?: false
 }
 
@@ -61,7 +63,8 @@ private var Project.notificationPanel: ScriptConfigurationChangedNotification?
 fun scriptConfigurationsNeedToBeUpdated(project: Project, file: VirtualFile) {
     if (!scriptConfigurationsNeedToBeUpdatedBalloon) return
 
-    if (autoReloadScriptConfigurations(project, file)) {
+    val root = GradleBuildRootsManager.getInstance(project).getScriptInfo(file)?.buildRoot ?: return
+    if (autoReloadScriptConfigurations(project, root)) {
         // import should be run automatically by Gradle plugin
         return
     }
@@ -103,10 +106,13 @@ private class ScriptConfigurationChangedNotification(val project: Project) :
     init {
         addAction(LoadConfigurationAction())
         addAction(NotificationAction.createSimple(KotlinIdeaGradleBundle.message("action.label.enable.auto.import")) {
-            getGradleProjectSettings(project).forEach {
-                it.isUseAutoImport = true
+            GradleBuildRootsManager.getInstance(project).getAllRoots().forEach { root ->
+                val projectSettings = getGradleProjectSettings(project).find { it.externalProjectPath == root.pathPrefix }
+                if (projectSettings != null) {
+                    projectSettings.isUseAutoImport = true
+                }
+                runPartialGradleImport(project, root)
             }
-            runPartialGradleImport(project)
         })
     }
 
@@ -119,7 +125,7 @@ private class ScriptConfigurationChangedNotification(val project: Project) :
     private class LoadConfigurationAction : AnAction(KotlinIdeaGradleBundle.message("action.label.import.project")) {
         override fun actionPerformed(e: AnActionEvent) {
             val project = e.project ?: return
-            runPartialGradleImport(project)
+            runPartialGradleImportForAllRoots(project)
         }
     }
 }

idea/idea-gradle/src/org/jetbrains/kotlin/idea/scripting/gradle/GradleImportHelper.kt.201

@@ -23,35 +23,42 @@ import org.jetbrains.kotlin.idea.KotlinIcons
 import org.jetbrains.kotlin.idea.KotlinIdeaGradleBundle
 import org.jetbrains.kotlin.idea.core.script.settings.KotlinScriptingSettings
 import org.jetbrains.kotlin.idea.scripting.gradle.importing.KotlinDslScriptModelResolver
+import org.jetbrains.kotlin.idea.scripting.gradle.roots.GradleBuildRoot
 import org.jetbrains.kotlin.idea.scripting.gradle.roots.GradleBuildRootsManager
+import org.jetbrains.kotlin.scripting.definitions.findScriptDefinition
 import org.jetbrains.plugins.gradle.service.project.GradlePartialResolverPolicy
 import org.jetbrains.plugins.gradle.settings.GradleProjectSettings
 import org.jetbrains.plugins.gradle.util.GradleConstants
 
-fun runPartialGradleImport(project: Project) {
-    getGradleProjectSettings(project).forEach { gradleProjectSettings ->
-        ExternalSystemUtil.refreshProject(
-            gradleProjectSettings.externalProjectPath,
-            ImportSpecBuilder(project, GradleConstants.SYSTEM_ID)
-                .projectResolverPolicy(
-                    GradlePartialResolverPolicy { it is KotlinDslScriptModelResolver }
-                )
-        )
+fun runPartialGradleImportForAllRoots(project: Project) {
+    GradleBuildRootsManager.getInstance(project).getAllRoots().forEach { root ->
+        runPartialGradleImport(project, root)
     }
 }
 
+fun runPartialGradleImport(project: Project, root: GradleBuildRoot) {
+    ExternalSystemUtil.refreshProject(
+        root.pathPrefix,
+        ImportSpecBuilder(project, GradleConstants.SYSTEM_ID)
+            .projectResolverPolicy(
+                GradlePartialResolverPolicy { it is KotlinDslScriptModelResolver }
+            )
+    )
+}
+
 fun getMissingConfigurationActionText() = KotlinIdeaGradleBundle.message("action.text.load.script.configurations")
 
 fun autoReloadScriptConfigurations(project: Project, file: VirtualFile): Boolean {
-    val buildRoot = GradleBuildRootsManager.getInstance(project).getScriptInfo(file)?.buildRoot ?: return false
-    return GradleScriptDefinitionsContributor.getDefinitions(project, buildRoot.pathPrefix, buildRoot.data.gradleHome)?.any {
-        KotlinScriptingSettings.getInstance(project).autoReloadConfigurations(it)
-    } ?: return false
+    val definition = file.findScriptDefinition(project) ?: return false
+
+    return KotlinScriptingSettings.getInstance(project).autoReloadConfigurations(definition)
 }
 
 fun scriptConfigurationsNeedToBeUpdated(project: Project, file: VirtualFile) {
     if (autoReloadScriptConfigurations(project, file)) {
-        runPartialGradleImport(project)
+        GradleBuildRootsManager.getInstance(project).getScriptInfo(file)?.buildRoot?.let {
+            runPartialGradleImport(project, it)
+        }
     } else {
         // notification is shown in LoadConfigurationAction
     }
@@ -66,7 +73,11 @@ class LoadConfigurationAction : AnAction(
 ) {
     override fun actionPerformed(e: AnActionEvent) {
         val project = e.project ?: return
-        runPartialGradleImport(project)
+        val editor = e.getData(CommonDataKeys.EDITOR) ?: return
+        val file = getKotlinScriptFile(editor) ?: return
+        val root = GradleBuildRootsManager.getInstance(project).getScriptInfo(file)?.buildRoot ?: return
+
+        runPartialGradleImport(project, root)
     }
 
     override fun update(e: AnActionEvent) {

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

@@ -49,18 +49,22 @@ class GradleScriptNotificationProvider(private val project: Project) :
             wasNotImportedAfterCreation -> EditorNotificationPanel().apply {
                 text(KotlinIdeaGradleBundle.message("notification.wasNotImportedAfterCreation.text"))
                 createActionLabel(getMissingConfigurationActionText()) {
-                    runPartialGradleImport(project)
+                    val root = scriptUnderRoot.nearest
+                    if (root != null) {
+                        runPartialGradleImport(project, root)
+                    }
                 }
             }
             notEvaluatedInLastImport -> EditorNotificationPanel().apply {
                 text(KotlinIdeaGradleBundle.message("notification.notEvaluatedInLastImport.text"))
 
                 // suggest to reimport project if something changed after import
-                val importTs = (scriptUnderRoot.nearest as? Imported)?.data?.importTs
-                if (importTs != null && !scriptUnderRoot.nearest.areRelatedFilesChangedBefore(file, importTs)) {
+                val root = scriptUnderRoot.nearest as? Imported
+                val importTs = root?.data?.importTs
+                if (root != null && importTs != null && !root.areRelatedFilesChangedBefore(file, importTs)) {
                     createActionLabel(getMissingConfigurationActionText()) {
                         rootsManager.updateStandaloneScripts {
-                            runPartialGradleImport(project)
+                            runPartialGradleImport(project, root)
                         }
                     }
                 }