Rename ScriptDependenciesManager to ScriptConfigurationManager

2019-08-22 12:43:59 +03:00
parent fa6b5b567b
commit fb01f7be5e
27 changed files with 68 additions and 73 deletions
@@ -9,7 +9,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.projectRoots.Sdk
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.core.script.dependencies.ScriptAdditionalIdeaDependenciesProvider
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
 import org.jetbrains.kotlin.idea.stubindex.KotlinSourceFilterScope
@@ -90,13 +90,13 @@ sealed class ScriptDependenciesInfo(val project: Project) : IdeaModuleInfo, Bina
    ) : ScriptDependenciesInfo(project) {
        override val sdk: Sdk?
            get() {
-                return ScriptDependenciesManager.getInstance(project).getScriptSdk(scriptFile)
+                return ScriptConfigurationManager.getInstance(project).getScriptSdk(scriptFile)
            }

        override fun contentScope(): GlobalSearchScope {
            // TODO: this is not very efficient because KotlinSourceFilterScope already checks if the files are in scripts classpath
            return KotlinSourceFilterScope.libraryClassFiles(
-                ScriptDependenciesManager.getInstance(project).getScriptDependenciesClassFilesScope(scriptFile), project
+                ScriptConfigurationManager.getInstance(project).getScriptDependenciesClassFilesScope(scriptFile), project
            )
        }
    }
@@ -105,13 +105,13 @@ sealed class ScriptDependenciesInfo(val project: Project) : IdeaModuleInfo, Bina
    class ForProject(project: Project) : ScriptDependenciesInfo(project) {
        override val sdk: Sdk?
            get() {
-                return ScriptDependenciesManager.getInstance(project).getFirstScriptsSdk()
-                    ?: ScriptDependenciesManager.getScriptDefaultSdk(project)
+                return ScriptConfigurationManager.getInstance(project).getFirstScriptsSdk()
+                    ?: ScriptConfigurationManager.getScriptDefaultSdk(project)
            }

        override fun contentScope(): GlobalSearchScope {
            return KotlinSourceFilterScope.libraryClassFiles(
-                ScriptDependenciesManager.getInstance(project).getAllScriptsDependenciesClassFilesScope(), project
+                ScriptConfigurationManager.getInstance(project).getAllScriptsDependenciesClassFilesScope(), project
            )
        }
    }
@@ -124,7 +124,7 @@ sealed class ScriptDependenciesSourceInfo(val project: Project) : IdeaModuleInfo
        get() = ScriptDependenciesInfo.ForProject(project)

    override fun sourceScope(): GlobalSearchScope = KotlinSourceFilterScope.librarySources(
-        ScriptDependenciesManager.getInstance(project).getAllScriptDependenciesSourcesScope(), project
+        ScriptConfigurationManager.getInstance(project).getAllScriptDependenciesSourcesScope(), project
    )

    override fun hashCode() = project.hashCode()
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.asJava.elements.KtLightElement
 import org.jetbrains.kotlin.caches.project.cacheInvalidatingOnRootModifications
 import org.jetbrains.kotlin.idea.caches.lightClasses.KtLightClassForDecompiledDeclaration
 import org.jetbrains.kotlin.idea.core.isInTestSourceContentKotlinAware
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.core.script.scriptRelatedModuleName
 import org.jetbrains.kotlin.idea.highlighter.OutsidersPsiFileSupportUtils
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
@@ -240,7 +240,7 @@ private inline fun <T> collectInfosByVirtualFile(
    }

    val isBinary = virtualFile.fileType.isKotlinBinary()
-    val scriptConfigurationManager = ScriptDependenciesManager.getInstance(project)
+    val scriptConfigurationManager = ScriptConfigurationManager.getInstance(project)
    if (isBinary && virtualFile in scriptConfigurationManager.getAllScriptsDependenciesClassFilesScope()) {
        if (treatAsLibrarySource) {
            onOccurrence(ScriptDependenciesSourceInfo.ForProject(project))
@@ -21,8 +21,8 @@ import com.intellij.psi.PsiManager
 import org.jetbrains.kotlin.idea.caches.project.NotUnderContentRootModuleInfo
 import org.jetbrains.kotlin.idea.caches.project.getModuleInfo
 import org.jetbrains.kotlin.idea.core.script.IdeScriptReportSink
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.core.script.ScriptDefinitionsManager
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
 import org.jetbrains.kotlin.idea.util.isRunningInCidrIde
 import org.jetbrains.kotlin.psi.KtCodeFragment
@@ -70,7 +70,7 @@ object KotlinHighlightingUtil {
    @Suppress("DEPRECATION")
    private fun shouldHighlightScript(ktFile: KtFile): Boolean {
        if (isRunningInCidrIde) return false // There is no Java support in CIDR. So do not highlight errors in KTS if running in CIDR.
-        if (!ScriptDependenciesManager.getInstance(ktFile.project).isConfigurationCached(ktFile)) return false
+        if (!ScriptConfigurationManager.getInstance(ktFile.project).isConfigurationCached(ktFile)) return false
        if (IdeScriptReportSink.getReports(ktFile).any { it.severity == ScriptDiagnostic.Severity.FATAL }) {
            return false
        }
@@ -25,7 +25,7 @@ import com.intellij.psi.PsiDirectory
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFileSystemItem
 import org.jetbrains.kotlin.idea.KotlinModuleFileType
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.decompiler.builtIns.KotlinBuiltInFileType
 import org.jetbrains.kotlin.idea.decompiler.js.KotlinJavaScriptMetaFileType
 import org.jetbrains.kotlin.idea.util.application.runReadAction
@@ -131,7 +131,7 @@ object ProjectRootsUtil {
        val canContainClassFiles = fileType == ArchiveFileType.INSTANCE || file.isDirectory
        val isBinary = fileType.isKotlinBinary()

-        val scriptConfigurationManager = if (includeScriptDependencies) ScriptDependenciesManager.getInstance(project) else null
+        val scriptConfigurationManager = if (includeScriptDependencies) ScriptConfigurationManager.getInstance(project) else null

        if (includeLibraryClasses && (isBinary || canContainClassFiles)) {
            if (fileIndex.isInLibraryClasses(file)) return true
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.resolve.jvm.KotlinSafeClassFinder
 class KotlinScriptDependenciesClassFinder(
    private val project: Project
 ) : NonClasspathClassFinder(project), KotlinSafeClassFinder {
-    override fun calcClassRoots(): List<VirtualFile> = ScriptDependenciesManager.getInstance(project)
+    override fun calcClassRoots(): List<VirtualFile> = ScriptConfigurationManager.getInstance(project)
        .getAllScriptsDependenciesClassFiles().toList()

    override fun findClass(qualifiedName: String, scope: GlobalSearchScope): PsiClass? {
@@ -39,7 +39,7 @@ import kotlin.script.experimental.api.makeFailureResult
 // NOTE: this service exists exclusively because ScriptDependencyManager
 // cannot be registered as implementing two services (state would be duplicated)
 class IdeScriptDependenciesProvider(
-    private val scriptDependenciesManager: ScriptDependenciesManager,
+    private val scriptConfigurationManager: ScriptConfigurationManager,
    project: Project
 ) : ScriptDependenciesProvider(project) {
    override fun getScriptConfigurationResult(file: KtFile): ScriptCompilationConfigurationResult? {
@@ -52,7 +52,7 @@ class IdeScriptDependenciesProvider(
    }

    override fun getScriptConfiguration(file: KtFile): ScriptCompilationConfigurationWrapper? {
-        return scriptDependenciesManager.getConfiguration(file)
+        return scriptConfigurationManager.getConfiguration(file)
    }

 }
@@ -106,14 +106,11 @@ interface ScriptConfigurationManager {
    fun getAllScriptDependenciesSourcesScope(): GlobalSearchScope
    fun getAllScriptsDependenciesClassFiles(): List<VirtualFile>
    fun getAllScriptDependenciesSources(): List<VirtualFile>
-}

-@Deprecated("Use ScriptConfigurationManager instead")
-interface ScriptDependenciesManager : ScriptConfigurationManager {
    companion object {
        @JvmStatic
-        fun getInstance(project: Project): ScriptDependenciesManager =
-            ServiceManager.getService(project, ScriptDependenciesManager::class.java)
+        fun getInstance(project: Project): ScriptConfigurationManager =
+            ServiceManager.getService(project, ScriptConfigurationManager::class.java)

        fun getScriptDefaultSdk(project: Project): Sdk? {
            val projectSdk = ProjectRootManager.getInstance(project).projectSdk?.takeIf { it.canBeUsedForScript() }
@@ -19,7 +19,7 @@ import com.intellij.ui.EditorNotifications
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
 import org.jetbrains.annotations.TestOnly
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager.Companion.toVfsRoots
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager.Companion.toVfsRoots
 import org.jetbrains.kotlin.idea.core.script.dependencies.*
 import org.jetbrains.kotlin.idea.core.script.settings.KotlinScriptingSettings
 import org.jetbrains.kotlin.idea.core.util.EDT
@@ -32,9 +32,7 @@ import org.jetbrains.kotlin.scripting.resolve.ScriptReportSink
 import kotlin.script.experimental.api.ScriptDiagnostic
 import kotlin.script.experimental.api.valueOrNull

-class ScriptConfigurationManagerImpl internal constructor(
-    private val project: Project
-) : ScriptConfigurationManager, ScriptDependenciesManager {
+class ScriptConfigurationManagerImpl internal constructor(private val project: Project) : ScriptConfigurationManager {
    private val rootsManager = ScriptClassRootsManager(project)

    private val memoryCache = ScriptConfigurationMemoryCache(project)
@@ -206,7 +204,7 @@ class ScriptConfigurationManagerImpl internal constructor(
     * @param skipNotification forces loading new configuration even if auto reload is disabled.
     * @param skipSaveToAttributes skips saving to FileAttributes (used in [ScriptConfigurationFileAttributeCache] only).
     *
-     * @sample ScriptDependenciesManager.getConfiguration
+     * @sample ScriptConfigurationManager.getConfiguration
     */
    private fun saveConfiguration(
        file: VirtualFile,
@@ -78,19 +78,19 @@ class ScriptConfigurationMemoryCache internal constructor(private val project: P

            @Suppress("FoldInitializerAndIfToElvis")
            if (sdk == null) {
-                return@createWeakMap NonClasspathDirectoriesScope.compose(ScriptDependenciesManager.toVfsRoots(roots))
+                return@createWeakMap NonClasspathDirectoriesScope.compose(ScriptConfigurationManager.toVfsRoots(roots))
            }

            return@createWeakMap NonClasspathDirectoriesScope.compose(
                sdk.rootProvider.getFiles(OrderRootType.CLASSES).toList() +
-                        ScriptDependenciesManager.toVfsRoots(roots)
+                        ScriptConfigurationManager.toVfsRoots(roots)
            )
        }

    val scriptsSdksCache: MutableMap<VirtualFile, Sdk?> =
        ConcurrentFactoryMap.createWeakMap { file ->
            val compilationConfiguration = getConfiguration(file)
-            return@createWeakMap getScriptSdk(compilationConfiguration) ?: ScriptDependenciesManager.getScriptDefaultSdk(project)
+            return@createWeakMap getScriptSdk(compilationConfiguration) ?: ScriptConfigurationManager.getScriptDefaultSdk(project)
        }

    private fun getConfiguration(file: VirtualFile): ScriptCompilationConfigurationWrapper? {
@@ -99,7 +99,7 @@ class ScriptConfigurationMemoryCache internal constructor(private val project: P
        if (configuration != null) return configuration

        val ktFile = runReadAction { PsiManager.getInstance(project).findFile(file) as? KtFile } ?: return null
-        return ScriptDependenciesManager.getInstance(project).getConfiguration(ktFile)
+        return ScriptConfigurationManager.getInstance(project).getConfiguration(ktFile)
    }

    private fun getScriptSdk(compilationConfiguration: ScriptCompilationConfigurationWrapper?): Sdk? {
@@ -139,7 +139,7 @@ class ScriptConfigurationMemoryCache internal constructor(private val project: P
        val scriptDependenciesClasspath = scriptDependenciesCache.getAll()
            .flatMap { it.value.dependenciesClassPath }.distinct()

-        sdkFiles + ScriptDependenciesManager.toVfsRoots(scriptDependenciesClasspath)
+        sdkFiles + ScriptConfigurationManager.toVfsRoots(scriptDependenciesClasspath)
    }

    val allDependenciesSources by ClearableLazyValue(cacheLock) {
@@ -148,7 +148,7 @@ class ScriptConfigurationMemoryCache internal constructor(private val project: P

        val scriptDependenciesSources = scriptDependenciesCache.getAll()
            .flatMap { it.value.dependenciesSources }.distinct()
-        sdkSources + ScriptDependenciesManager.toVfsRoots(scriptDependenciesSources)
+        sdkSources + ScriptConfigurationManager.toVfsRoots(scriptDependenciesSources)
    }

    val allDependenciesClassFilesScope by ClearableLazyValue(cacheLock) {
@@ -201,14 +201,14 @@ class ScriptConfigurationMemoryCache internal constructor(private val project: P
    }

    fun hasNotCachedRoots(compilationConfiguration: ScriptCompilationConfigurationWrapper): Boolean {
-        val scriptSdk = getScriptSdk(compilationConfiguration) ?: ScriptDependenciesManager.getScriptDefaultSdk(project)
+        val scriptSdk = getScriptSdk(compilationConfiguration) ?: ScriptConfigurationManager.getScriptDefaultSdk(project)
        val wasSdkChanged = scriptSdk != null && !allSdks.contains(scriptSdk)
        if (wasSdkChanged) {
            debug { "sdk was changed: $compilationConfiguration" }
            return true
        }

-        val newClassRoots = ScriptDependenciesManager.toVfsRoots(compilationConfiguration.dependenciesClassPath)
+        val newClassRoots = ScriptConfigurationManager.toVfsRoots(compilationConfiguration.dependenciesClassPath)
        for (newClassRoot in newClassRoots) {
            if (!allDependenciesClassFiles.contains(newClassRoot)) {
                debug { "class root was changed: $newClassRoot" }
@@ -216,7 +216,7 @@ class ScriptConfigurationMemoryCache internal constructor(private val project: P
            }
        }

-        val newSourceRoots = ScriptDependenciesManager.toVfsRoots(compilationConfiguration.dependenciesSources)
+        val newSourceRoots = ScriptConfigurationManager.toVfsRoots(compilationConfiguration.dependenciesSources)
        for (newSourceRoot in newSourceRoots) {
            if (!allDependenciesSources.contains(newSourceRoot)) {
                debug { "source root was changed: $newSourceRoot" }
@@ -190,7 +190,7 @@ class ScriptDefinitionsManager(private val project: Project) : LazyScriptDefinit
        scriptDefinitionsCacheLock.write { scriptDefinitionsCache.clear() }

        // TODO: clear by script type/definition
-        ScriptDependenciesManager.getInstance(project).clearConfigurationCachesAndRehighlight()
+        ScriptConfigurationManager.getInstance(project).clearConfigurationCachesAndRehighlight()
    }

    private fun ScriptDefinitionsSource.safeGetDefinitions(): List<ScriptDefinition> {
@@ -29,7 +29,7 @@ class ScriptTrafficLightRendererContributor : TrafficLightRendererContributor {
            if (!ScriptDefinitionsManager.getInstance(file.project).isReady()) {
                status.reasonWhySuspended = "Loading kotlin script definitions"
                status.errorAnalyzingFinished = false
-            } else if (!ScriptDependenciesManager.getInstance(project).isConfigurationCached(file)) {
+            } else if (!ScriptConfigurationManager.getInstance(project).isConfigurationCached(file)) {
                status.reasonWhySuspended = "Loading kotlin script dependencies"
                status.errorAnalyzingFinished = false
            }
@@ -26,7 +26,7 @@ import com.intellij.psi.search.PsiShortNamesCache
 import com.intellij.psi.stubs.StubIndex
 import com.intellij.util.Processor
 import com.intellij.util.containers.HashSet
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager

 // Allow searching java classes in jars in script dependencies, this is needed for stuff like completion and autoimport
 class JavaClassesInScriptDependenciesShortNameCache(private val project: Project) : PsiShortNamesCache() {
@@ -35,7 +35,7 @@ class JavaClassesInScriptDependenciesShortNameCache(private val project: Project
    override fun getAllClassNames(dest: HashSet<String>) {}

    override fun getClassesByName(name: String, scope: GlobalSearchScope): Array<out PsiClass> {
-        val classpathScope = ScriptDependenciesManager.getInstance(project).getAllScriptsDependenciesClassFilesScope()
+        val classpathScope = ScriptConfigurationManager.getInstance(project).getAllScriptsDependenciesClassFilesScope()
        val classes = StubIndex.getElements(
                JavaShortClassNameIndex.getInstance().key, name, project, classpathScope.intersectWith(scope), PsiClass::class.java
        )
@@ -19,12 +19,12 @@ package org.jetbrains.kotlin.idea.core.script.dependencies
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.util.indexing.IndexableSetContributor
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager

 class KotlinScriptDependenciesIndexableSetContributor : IndexableSetContributor() {

    override fun getAdditionalProjectRootsToIndex(project: Project): Set<VirtualFile> {
-        val manager = ScriptDependenciesManager.getInstance(project)
+        val manager = ScriptConfigurationManager.getInstance(project)
        return (manager.getAllScriptsDependenciesClassFiles() + manager.getAllScriptDependenciesSources()).filterTo(LinkedHashSet()) { it.isValid }
    }

@@ -22,7 +22,7 @@ import com.intellij.psi.PsiManager
 import com.intellij.psi.ResolveScopeProvider
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.idea.KotlinFileType
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.core.script.StandardIdeScriptDefinition
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.scripting.definitions.ScriptDefinition
@@ -47,7 +47,7 @@ class KotlinScriptResolveScopeProvider : ResolveScopeProvider() {
            scriptDefinition.asLegacyOrNull<StandardIdeScriptDefinition>() != null -> null
            scriptDefinition is ScriptDefinition.FromConfigurations || scriptDefinition.asLegacyOrNull<KotlinScriptDefinitionFromAnnotatedTemplate>() != null -> {
                GlobalSearchScope.fileScope(project, file)
-                    .union(ScriptDependenciesManager.getInstance(project).getScriptDependenciesClassFilesScope(file))
+                    .union(ScriptConfigurationManager.getInstance(project).getScriptDependenciesClassFilesScope(file))
            }
            else -> null
        }
@@ -23,11 +23,11 @@ import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.idea.caches.project.ScriptDependenciesInfo
 import org.jetbrains.kotlin.idea.caches.project.ScriptDependenciesSourceInfo
 import org.jetbrains.kotlin.idea.caches.project.getModuleInfoByVirtualFile
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager

 class ScriptDependenciesResolveScopeProvider : ResolveScopeProvider() {
    override fun getResolveScope(file: VirtualFile, project: Project): GlobalSearchScope? {
-        if (ScriptDependenciesManager.getInstance(project).getAllScriptsDependenciesClassFiles().isEmpty()) return null
+        if (ScriptConfigurationManager.getInstance(project).getAllScriptsDependenciesClassFiles().isEmpty()) return null

        val moduleInfo = getModuleInfoByVirtualFile(project, file) ?: return null
        val scriptDependenciesModuleInfo = (moduleInfo as? ScriptDependenciesInfo)
@@ -21,7 +21,7 @@ import com.intellij.psi.PsiClassOwner
 import com.intellij.psi.PsiElement
 import com.intellij.psi.impl.compiled.*
 import com.intellij.psi.util.MethodSignatureUtil
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager

 class ScriptDependencySourceNavigationPolicyForJavaClasses : ClsCustomNavigationPolicyEx() {
    override fun getNavigationElement(clsClass: ClsClassImpl): PsiClass? {
@@ -49,7 +49,7 @@ class ScriptDependencySourceNavigationPolicyForJavaClasses : ClsCustomNavigation
        val virtualFile = file.virtualFile
        val project = file.project

-        val kotlinScriptConfigurationManager = ScriptDependenciesManager.getInstance(project)
+        val kotlinScriptConfigurationManager = ScriptConfigurationManager.getInstance(project)
        if (virtualFile !in kotlinScriptConfigurationManager.getAllScriptsDependenciesClassFilesScope()) return null

        val sourceFileName = (file.classes.first() as ClsClassImpl).sourceFileName
@@ -10,7 +10,7 @@ import com.intellij.psi.PsiManager
 import org.jetbrains.kotlin.diagnostics.Severity
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeWithContent
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.plugins.gradle.tooling.annotation.TargetVersions
@@ -48,7 +48,7 @@ class GradleBuildFileHighlightingTest : GradleImportingTestCase() {
            val psiFile = PsiManager.getInstance(myProject).findFile(file) as? KtFile
                ?: error("Couldn't find psiFile for virtual file: ${file.canonicalPath}")

-            ScriptDependenciesManager.updateScriptDependenciesSynchronously(psiFile, myProject)
+            ScriptConfigurationManager.updateScriptDependenciesSynchronously(psiFile, myProject)

            val bindingContext = psiFile.analyzeWithContent()

@@ -38,7 +38,7 @@ import com.intellij.psi.PsiElement
 import com.intellij.refactoring.listeners.RefactoringElementAdapter
 import com.intellij.refactoring.listeners.RefactoringElementListener
 import org.jdom.Element
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.run.JavaRunConfigurationExtensionManagerUtil
 import org.jetbrains.kotlin.idea.run.KotlinRunConfiguration
 import org.jetbrains.kotlin.idea.run.script.standalone.KotlinStandaloneScriptRunConfigurationProducer.Companion.pathFromPsiElement
@@ -206,7 +206,7 @@ private class ScriptCommandLineState(

        params.classPath.add(PathUtil.kotlinPathsForIdeaPlugin.compilerPath)

-        val scriptClasspath = ScriptDependenciesManager.getInstance(environment.project).getScriptClasspath(scriptVFile)
+        val scriptClasspath = ScriptConfigurationManager.getInstance(environment.project).getScriptClasspath(scriptVFile)
        scriptClasspath.forEach {
            params.classPath.add(it.presentableUrl)
        }
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.codegen.filterClassFiles
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.debugger.DebuggerUtils
 import org.jetbrains.kotlin.idea.scratch.LOG
 import org.jetbrains.kotlin.idea.scratch.ScratchExpression
@@ -164,7 +164,7 @@ class KtScratchExecutionSession(
            javaParameters.classPath.addAll(JavaParametersBuilder.getModuleDependencies(module))
        }

-        ScriptDependenciesManager.getInstance(originalFile.project)
+        ScriptConfigurationManager.getInstance(originalFile.project)
            .getConfiguration(originalFile)?.let {
                javaParameters.classPath.addAll(it.dependenciesClassPath.map { f -> f.absolutePath })
            }
@@ -65,8 +65,8 @@ import com.intellij.util.io.exists
 import com.intellij.xml.XmlSchemaProvider
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.idea.configuration.getModulesWithKotlinFiles
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.core.script.ScriptDefinitionsManager
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
 import org.jetbrains.kotlin.idea.core.script.settings.KotlinScriptingSettings
 import org.jetbrains.kotlin.idea.core.util.toPsiFile
 import org.jetbrains.kotlin.idea.framework.KotlinSdkType
@@ -327,7 +327,7 @@ abstract class AbstractPerformanceProjectsTest : UsefulTestCase() {
        val initialText = editor.document.text
        try {
            if (isAKotlinScriptFile(fileName)) {
-                ScriptDependenciesManager.updateScriptDependenciesSynchronously(virtualFile, project)
+                ScriptConfigurationManager.updateScriptDependenciesSynchronously(fileInEditor.psiFile, project)
            }

            val tasksIdx = fileInEditor.document.text.indexOf(marker)
@@ -402,7 +402,7 @@ abstract class AbstractPerformanceProjectsTest : UsefulTestCase() {
                val initialText = editor.document.text
                if (isAKotlinScriptFile(fileName)) {
                    runAndMeasure("update script dependencies for $fileName") {
-                        ScriptDependenciesManager.updateScriptDependenciesSynchronously(virtualFile, project)
+                        ScriptConfigurationManager.updateScriptDependenciesSynchronously(file, project)
                    }
                }

@@ -588,7 +588,7 @@ abstract class AbstractPerformanceProjectsTest : UsefulTestCase() {
            testName = "updateScriptDependencies ${notePrefix(note)}${simpleFilename(fileName)}",
            setUp = { it.setUpValue = openFileInEditor(project, fileName) },
            test = {
-                ScriptDependenciesManager.updateScriptDependenciesSynchronously(it.setUpValue!!.psiFile.virtualFile, project)
+                ScriptConfigurationManager.updateScriptDependenciesSynchronously(it.setUpValue!!.psiFile, project)
                it.value = it.setUpValue
            },
            tearDown = {
@@ -12,7 +12,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Disposer
 import com.intellij.psi.PsiElement
 import com.intellij.testFramework.propertyBased.MadTestingUtil
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.highlighter.KotlinPsiChecker
 import org.jetbrains.kotlin.idea.highlighter.KotlinPsiCheckerAndHighlightingUpdater
 import org.jetbrains.kotlin.idea.testFramework.Fixture
@@ -260,7 +260,7 @@ class PerformanceProjectsTest : AbstractPerformanceProjectsTest() {

            // Note: Kotlin scripts require dependencies to be loaded
            if (isAKotlinScriptFile(fileName)) {
-                ScriptDependenciesManager.updateScriptDependenciesSynchronously(fileInEditor.psiFile.virtualFile, project)
+                ScriptConfigurationManager.updateScriptDependenciesSynchronously(fileInEditor.psiFile, project)
            }

            resetTimestamp()
@@ -296,7 +296,7 @@
    <projectService serviceInterface="org.jetbrains.kotlin.scripting.definitions.ScriptDependenciesProvider"
                    serviceImplementation="org.jetbrains.kotlin.idea.core.script.IdeScriptDependenciesProvider"/>

-    <projectService serviceInterface="org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager"
+    <projectService serviceInterface="org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager"
                    serviceImplementation="org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManagerImpl"/>

    <projectService serviceInterface="org.jetbrains.kotlin.scripting.resolve.ScriptReportSink"
@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.findModuleDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
 import org.jetbrains.kotlin.idea.core.isInheritable
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.core.toDescriptor
 import org.jetbrains.kotlin.idea.findUsages.KotlinFindUsagesHandlerFactory
 import org.jetbrains.kotlin.idea.findUsages.handlers.KotlinFindClassUsagesHandler
@@ -136,7 +136,7 @@ class UnusedSymbolInspection : AbstractKotlinInspection() {

            val usedScripts = findScriptsWithUsages(declaration)
            if (usedScripts.isNotEmpty()) {
-                if (ScriptDependenciesManager.getInstance(declaration.project).updateConfigurationsIfNotCached(usedScripts)) {
+                if (ScriptConfigurationManager.getInstance(declaration.project).updateConfigurationsIfNotCached(usedScripts)) {
                    return TOO_MANY_OCCURRENCES
                }
            }
@@ -29,7 +29,7 @@ import com.intellij.testFramework.fixtures.CodeInsightTestFixture
 import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.KotlinFileType
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.core.util.CodeInsightUtils
 import org.jetbrains.kotlin.idea.refactoring.checkConflictsInteractively
 import org.jetbrains.kotlin.idea.refactoring.chooseMembers
@@ -324,7 +324,7 @@ abstract class AbstractExtractionTest : KotlinLightCodeInsightFixtureTestCase()
        if (mainFile.extension == KotlinParserDefinition.STD_SCRIPT_SUFFIX) {
            val virtualFile = VfsUtil.findFileByIoFile(mainFile, true)!!
            val ktFile = PsiManager.getInstance(project).findFile(virtualFile)!!
-            ScriptDependenciesManager.updateScriptDependenciesSynchronously(ktFile, project)
+            ScriptConfigurationManager.updateScriptDependenciesSynchronously(ktFile, project)
        }

        fixture.testDataPath = "${KotlinTestUtils.getHomeDirectory()}/${mainFile.parent}"
@@ -11,7 +11,7 @@ import com.intellij.psi.PsiFile
 import com.intellij.refactoring.RefactoringFactory
 import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectoriesProcessor
 import com.intellij.util.ActionRunner
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.run.script.standalone.KotlinStandaloneScriptRunConfiguration
 import org.jetbrains.kotlin.idea.search.allScope
 import org.jetbrains.kotlin.idea.stubindex.KotlinScriptFqnIndex
@@ -71,7 +71,7 @@ class StandaloneScriptRunConfigurationTest : KotlinCodeInsightTestCase() {
    fun testOnFileMoveWithDefaultWorkingDir() {
        configureByFile("move/script.kts")

-        ScriptDependenciesManager.updateScriptDependenciesSynchronously(myFile, project)
+        ScriptConfigurationManager.updateScriptDependenciesSynchronously(myFile, project)

        val script = KotlinScriptFqnIndex.instance.get("foo.Script", project, project.allScope()).single()
        val runConfiguration = createConfigurationFromElement(script, save = true) as KotlinStandaloneScriptRunConfiguration
@@ -98,7 +98,7 @@ class StandaloneScriptRunConfigurationTest : KotlinCodeInsightTestCase() {
    fun testOnFileMoveWithNonDefaultWorkingDir() {
        configureByFile("move/script.kts")

-        ScriptDependenciesManager.updateScriptDependenciesSynchronously(myFile, project)
+        ScriptConfigurationManager.updateScriptDependenciesSynchronously(myFile, project)

        val script = KotlinScriptFqnIndex.instance.get("foo.Script", project, project.allScope()).single()
        val runConfiguration = createConfigurationFromElement(script, save = true) as KotlinStandaloneScriptRunConfiguration
@@ -23,7 +23,7 @@ import com.intellij.util.ui.UIUtil
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.idea.actions.KOTLIN_WORKSHEET_EXTENSION
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.highlighter.KotlinHighlightingUtil
 import org.jetbrains.kotlin.idea.scratch.actions.ClearScratchAction
 import org.jetbrains.kotlin.idea.scratch.actions.RunScratchAction
@@ -204,7 +204,7 @@ abstract class AbstractScratchRunActionTest : FileEditorManagerTestCase() {

        myFixture.openFileInEditor(scratchVirtualFile)

-        ScriptDependenciesManager.updateScriptDependenciesSynchronously(myFixture.file, project)
+        ScriptConfigurationManager.updateScriptDependenciesSynchronously(myFixture.file, project)

        val scratchFileEditor = getScratchEditorForSelectedFile(myManager, myFixture.file.virtualFile)
            ?: error("Couldn't find scratch file")
@@ -217,7 +217,7 @@ abstract class AbstractScratchRunActionTest : FileEditorManagerTestCase() {
    protected fun configureWorksheetByText(name: String, text: String): ScratchFile {
        val worksheetFile = myFixture.configureByText(name, text).virtualFile

-        ScriptDependenciesManager.updateScriptDependenciesSynchronously(myFixture.file, project)
+        ScriptConfigurationManager.updateScriptDependenciesSynchronously(myFixture.file, project)

        val scratchFileEditor = getScratchEditorForSelectedFile(myManager, myFixture.file.virtualFile)
            ?: error("Couldn't find scratch panel")
@@ -17,7 +17,7 @@ import com.intellij.testFramework.ExpectedHighlightingData
 import com.intellij.testFramework.FileEditorManagerTestCase
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.idea.codeInsight.AbstractLineMarkersTest
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.scratch.AbstractScratchRunActionTest.Companion.configureOptions
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.psi.KtFile
@@ -37,7 +37,7 @@ abstract class AbstractScratchLineMarkersTest : FileEditorManagerTestCase() {

        myFixture.openFileInEditor(scratchVirtualFile)

-        ScriptDependenciesManager.updateScriptDependenciesSynchronously(myFixture.file, project)
+        ScriptConfigurationManager.updateScriptDependenciesSynchronously(myFixture.file, project)

        val scratchFileEditor = getScratchEditorForSelectedFile(FileEditorManager.getInstance(project), myFixture.file.virtualFile)
            ?: error("Couldn't find scratch panel")
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.idea.completion.test.KotlinCompletionTestCase
 import org.jetbrains.kotlin.idea.core.script.IdeScriptReportSink
 import org.jetbrains.kotlin.idea.core.script.ScriptDefinitionContributor
 import org.jetbrains.kotlin.idea.core.script.ScriptDefinitionsManager
-import org.jetbrains.kotlin.idea.core.script.ScriptDependenciesManager.Companion.updateScriptDependenciesSynchronously
+import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager.Companion.updateScriptDependenciesSynchronously
 import org.jetbrains.kotlin.idea.core.script.isScriptDependenciesUpdaterDisabled
 import org.jetbrains.kotlin.idea.core.script.settings.KotlinScriptingSettings
 import org.jetbrains.kotlin.idea.highlighter.KotlinHighlightingUtil