diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptConfigurationManager.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptConfigurationManager.kt index c73f686c678..544a8cec4fd 100644 --- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptConfigurationManager.kt +++ b/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 @@ -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("MANUAL_CONFIGURATION_LOADING")) } } diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptTrafficLightRendererContributor.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptTrafficLightRendererContributor.kt index a1444ea1911..5eb43876742 100644 --- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptTrafficLightRendererContributor.kt +++ b/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 } diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/configuration/AbstractScriptConfigurationManager.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/configuration/AbstractScriptConfigurationManager.kt index 90b895e2157..316e2695873 100644 --- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/configuration/AbstractScriptConfigurationManager.kt +++ b/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 { 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) diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/configuration/DefaultScriptConfigurationManager.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/configuration/DefaultScriptConfigurationManager.kt index 092eb5c86ef..b9fb22daaad 100644 --- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/configuration/DefaultScriptConfigurationManager.kt +++ b/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. diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/configuration/listener/ScriptChangesNotifier.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/configuration/listener/ScriptChangesNotifier.kt index 618b3a6f24d..152459c1d59 100644 --- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/configuration/listener/ScriptChangesNotifier.kt +++ b/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) } } diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/configuration/loader/DefaultScriptConfigurationLoader.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/configuration/loader/DefaultScriptConfigurationLoader.kt index 4e282057d2c..98feb9a2265 100644 --- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/configuration/loader/DefaultScriptConfigurationLoader.kt +++ b/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(ktFile) { "finish dependencies loading" } - - return true + debug(file) { "finish dependencies loading" } + return result } protected open fun getInputsStamp(virtualFile: VirtualFile, file: KtFile): CachedConfigurationInputs { diff --git a/idea/idea-gradle/src/org/jetbrains/kotlin/idea/scripting/gradle/GradleScriptConfigurationLoader.kt b/idea/idea-gradle/src/org/jetbrains/kotlin/idea/scripting/gradle/GradleScriptConfigurationLoader.kt index 4cd806916ff..4f4f0810268 100644 --- a/idea/idea-gradle/src/org/jetbrains/kotlin/idea/scripting/gradle/GradleScriptConfigurationLoader.kt +++ b/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)) { - // 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 diff --git a/idea/idea-gradle/src/org/jetbrains/kotlin/idea/scripting/gradle/GradleScriptOutOfSourceNotificationProvider.kt b/idea/idea-gradle/src/org/jetbrains/kotlin/idea/scripting/gradle/GradleScriptOutOfSourceNotificationProvider.kt new file mode 100644 index 00000000000..16dc9d157be --- /dev/null +++ b/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() { + override fun getKey(): Key = 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("GradleScriptOutOfSourceNotification") + } +} \ No newline at end of file diff --git a/idea/idea-gradle/tests/org/jetbrains/kotlin/idea/scripting/gradle/GradleScriptInputsWatcherTest.kt b/idea/idea-gradle/tests/org/jetbrains/kotlin/idea/scripting/gradle/GradleScriptInputsWatcherTest.kt index 948e2fb1f42..bb7c8c4814c 100644 --- a/idea/idea-gradle/tests/org/jetbrains/kotlin/idea/scripting/gradle/GradleScriptInputsWatcherTest.kt +++ b/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" -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) diff --git a/idea/idea-gradle/tests/org/jetbrains/kotlin/idea/scripting/gradle/GradleScriptOutOfProjectTest.kt b/idea/idea-gradle/tests/org/jetbrains/kotlin/idea/scripting/gradle/GradleScriptOutOfProjectTest.kt new file mode 100644 index 00000000000..fb27c31dd66 --- /dev/null +++ b/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) +} \ No newline at end of file diff --git a/idea/resources/META-INF/gradle-java.xml b/idea/resources/META-INF/gradle-java.xml index e690bde27e3..4933fa29e8d 100644 --- a/idea/resources/META-INF/gradle-java.xml +++ b/idea/resources/META-INF/gradle-java.xml @@ -27,6 +27,7 @@ + diff --git a/idea/resources/META-INF/gradle-java.xml.191 b/idea/resources/META-INF/gradle-java.xml.191 index eae7985f054..c95d93cae39 100644 --- a/idea/resources/META-INF/gradle-java.xml.191 +++ b/idea/resources/META-INF/gradle-java.xml.191 @@ -24,6 +24,7 @@ +