scripting: drop ManualConfigurationLoading and kotlin.gradle.scripts.useIdeaProjectImport registry flag

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

@@ -396,7 +396,7 @@ abstract class DefaultScriptingSupportBase(val manager: CompositeScriptConfigura
         getAppliedConfiguration(file.originalFile.virtualFile) != null
 
     fun isConfigurationLoadingInProgress(file: KtFile): Boolean {
-        return !hasCachedConfiguration(file) && !ScriptConfigurationManager.isManualConfigurationLoading(file.originalFile.virtualFile)
+        return !hasCachedConfiguration(file)
     }
 
     fun getOrLoadConfiguration(

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

@@ -91,8 +91,6 @@ 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

@@ -40,8 +40,6 @@ open class DefaultScriptConfigurationLoader(val project: Project) : ScriptConfig
     ): Boolean {
         val virtualFile = ktFile.originalFile.virtualFile
 
-        if (ScriptConfigurationManager.isManualConfigurationLoading(virtualFile)) return false
-
         val result = getConfigurationThroughScriptingApi(ktFile, virtualFile, scriptDefinition)
 
         if (KotlinScriptingSettings.getInstance(project).autoReloadConfigurations(scriptDefinition)) {

idea/idea-gradle/src/org/jetbrains/kotlin/idea/scripting/gradle/legacy/GradleLegacyScriptConfigurationLoader.kt

@@ -18,40 +18,10 @@ import org.jetbrains.kotlin.idea.core.util.EDT
 import org.jetbrains.kotlin.idea.scripting.gradle.getGradleScriptInputsStamp
 import org.jetbrains.kotlin.idea.scripting.gradle.isGradleKotlinScript
 import org.jetbrains.kotlin.idea.scripting.gradle.roots.GradleBuildRootsManager
-import org.jetbrains.kotlin.idea.scripting.gradle.useScriptConfigurationFromImportOnly
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.scripting.definitions.ScriptDefinition
 
-/**
- * Loader that performs loading for .gralde.kts scripts configuration through the [DefaultScriptingSupport]
- *
- * TODO(gradle6): remove
- */
-class GradleLegacyScriptConfigurationLoaderForOutOfProjectScripts(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
-    }
-}
-
 /**
  * Loader that performs loading for .gralde.kts scripts configuration through the [DefaultScriptingSupport]
  *
@@ -60,10 +30,6 @@ class GradleLegacyScriptConfigurationLoaderForOutOfProjectScripts(project: Proje
 class GradleLegacyScriptConfigurationLoader(project: Project) : DefaultScriptConfigurationLoader(project) {
     private val buildRootsManager = GradleBuildRootsManager.getInstance(project)
 
-    override fun shouldRunInBackground(scriptDefinition: ScriptDefinition): Boolean {
-        return if (useScriptConfigurationFromImportOnly()) false else super.shouldRunInBackground(scriptDefinition)
-    }
-
     override fun loadDependencies(
         isFirstLoad: Boolean,
         ktFile: KtFile,
@@ -74,19 +40,12 @@ class GradleLegacyScriptConfigurationLoader(project: Project) : DefaultScriptCon
 
         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
-            return true
-        }
-
         if (!buildRootsManager.isAffectedGradleProjectFile(vFile.path)) {
-            ScriptConfigurationManager.markFileWithManualConfigurationLoading(vFile)
+            // not known gradle file and not configured as standalone script
+            // skip
             return true
         }
 
-        ScriptConfigurationManager.clearManualConfigurationLoadingIfNeeded(vFile)
-
         // Gradle read files from FS
         GlobalScope.launch(EDT(project)) {
             runWriteAction {

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

@@ -76,10 +76,6 @@ fun kotlinDslScriptsModelImportSupported(currentGradleVersion: String): Boolean
     return GradleVersion.version(currentGradleVersion) >= GradleVersion.version(minimal_gradle_version_supported)
 }
 
-fun useScriptConfigurationFromImportOnly(): Boolean {
-    return Registry.`is`("kotlin.gradle.scripts.useIdeaProjectImport", false)
-}
-
 fun getGradleProjectSettings(project: Project): Collection<GradleProjectSettings> =
     (ExternalSystemApiUtil.getSettings(project, GradleConstants.SYSTEM_ID) as GradleSettings).linkedProjectsSettings
 

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

@@ -1,107 +0,0 @@
-/*
- * 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 org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
-import org.jetbrains.kotlin.idea.script.AbstractScriptConfigurationLoadingTest
-import org.jetbrains.kotlin.idea.scripting.gradle.legacy.GradleLegacyScriptConfigurationLoaderForOutOfProjectScripts
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner
-import org.jetbrains.plugins.gradle.util.GradleConstants
-import org.junit.runner.RunWith
-import java.io.File
-
-@RunWith(JUnit3WithIdeaConfigurationRunner::class)
-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)
-
-        testAffectedGradleProjectFiles = true
-    }
-
-    override fun tearDown() {
-        super.tearDown()
-
-        testAffectedGradleProjectFiles = false
-    }
-
-    private val loaderForOutOfProjectScripts by lazy {
-        GradleLegacyScriptConfigurationLoaderForOutOfProjectScripts(
-            project
-        )
-    }
-
-    fun testManualLoadingForUpToDate() {
-        assertConfigurationShouldBeLoadedManually()
-
-        scriptConfigurationManager.default.forceReloadConfiguration(myFile as KtFile, loaderForOutOfProjectScripts)
-
-        assertConfigurationWasLoaded()
-    }
-
-    fun testManualLoadingForOutOfDate() {
-        assertConfigurationShouldBeLoadedManually()
-
-        makeChangesInsideSections()
-
-        assertNoBackgroundTasks()
-        assertNoLoading()
-
-        scriptConfigurationManager.default.forceReloadConfiguration(myFile as KtFile, loaderForOutOfProjectScripts)
-
-        assertConfigurationWasLoaded()
-    }
-
-    fun testFileAttributesForManualLoading() {
-        assertConfigurationShouldBeLoadedManually()
-
-        scriptConfigurationManager.default.forceReloadConfiguration(myFile as KtFile, loaderForOutOfProjectScripts)
-
-        assertConfigurationWasLoaded()
-
-        ScriptConfigurationManager.clearCaches(project)
-
-        assertNotNull(getConfiguration())
-    }
-
-    fun testNoNotificationAfterForReload() {
-        assertConfigurationShouldBeLoadedManually()
-
-        scriptConfigurationManager.default.forceReloadConfiguration(myFile as KtFile, loaderForOutOfProjectScripts)
-        assertConfigurationWasLoaded()
-
-        makeChangesInsideSections()
-
-        scriptConfigurationManager.default.forceReloadConfiguration(myFile as KtFile, loaderForOutOfProjectScripts)
-        assertConfigurationWasLoaded()
-
-    }
-
-    private fun makeChangesInsideSections() {
-        changeContents(myFile.text.replace(GradleScriptListenerTest.insidePlaceholder, "application"), myFile)
-    }
-
-    private fun assertConfigurationShouldBeLoadedManually() {
-        assertNull(getConfiguration())
-        assertNoLoading()
-    }
-
-    private fun assertConfigurationWasLoaded() {
-        assertAndDoAllBackgroundTasks()
-        assertSingleLoading()
-        assertNoSuggestedConfiguration()
-        assertNotNull(getConfiguration())
-    }
-
-    private fun getConfiguration() =
-        scriptConfigurationManager.getConfiguration(myFile as KtFile)
-}

idea/resources/META-INF/extensions/ide.xml

@@ -116,11 +116,6 @@
                      description="Add all transitive dependencies on MPP modules when Android project is imported"
                      defaultValue="true"
                      restartRequired="false"/>
-
-        <registryKey key="kotlin.gradle.scripts.useIdeaProjectImport"
-                     description="Use IDEA project import mechanics to load Kotlin Gradle scripts configuration"
-                     defaultValue="false"
-                     restartRequired="false"/>
         <registryKey key="kotlin.formatter.allowTrailingCommaInAnyProject"
                      description="Allow a trailing comma regardless of plugin version"
                      defaultValue="false"