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
@@ -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