Rename PlatformDependentCompilerServices -> PlatformDependentAnalyzerServices

2019-04-29 16:02:37 +03:00
parent 3332cdfce8
commit 9d0f518d62
41 changed files with 139 additions and 143 deletions
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.idea.caches.resolve.PlatformAnalysisSettings
 import org.jetbrains.kotlin.idea.framework.JSLibraryKind
 import org.jetbrains.kotlin.js.resolve.JsResolverForModuleFactory
-import org.jetbrains.kotlin.js.resolve.JsPlatformCompilerServices
+import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
 import org.jetbrains.kotlin.platform.impl.JsIdePlatformKind

 class JsPlatformKindResolution : IdePlatformKindResolution {
@@ -30,6 +30,6 @@ class JsPlatformKindResolution : IdePlatformKindResolution {
        get() = JsResolverForModuleFactory

    override fun createBuiltIns(settings: PlatformAnalysisSettings, projectContext: ProjectContext): KotlinBuiltIns {
-        return JsPlatformCompilerServices.builtIns
+        return JsPlatformAnalyzerServices.builtIns
    }
 }
@@ -64,7 +64,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfoFactory
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
 import org.jetbrains.kotlin.resolve.calls.util.CallMaker
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformCompilerServices
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
 import org.jetbrains.kotlin.resolve.lazy.FileScopeProviderImpl
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
@@ -305,11 +305,11 @@ internal object IDELightClassContexts {
        moduleDescriptor.setDependencies(moduleDescriptor, moduleDescriptor.builtIns.builtInsModule)

        val moduleInfo = files.first().getModuleInfo()
-        val container = createContainer("LightClassStub", JvmPlatformCompilerServices) {
+        val container = createContainer("LightClassStub", JvmPlatformAnalyzerServices) {
            val jvmTarget = IDELanguageSettingsProvider.getTargetPlatform(moduleInfo, project) as? JvmTarget ?: JvmTarget.DEFAULT
            configureModule(
                ModuleContext(moduleDescriptor, project, "ad hoc resolve"), JvmPlatforms.jvmPlatformByTargetVersion(jvmTarget),
-                JvmPlatformCompilerServices, trace,
+                JvmPlatformAnalyzerServices, trace,
                IDELanguageSettingsProvider.getLanguageVersionSettings(moduleInfo, project)
            )

@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.idea.core.isInTestSourceContentKotlinAware
 import org.jetbrains.kotlin.idea.framework.getLibraryPlatform
 import org.jetbrains.kotlin.idea.project.KotlinModuleModificationTracker
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
-import org.jetbrains.kotlin.idea.project.findCompilerServices
+import org.jetbrains.kotlin.idea.project.findAnalyzerServices
 import org.jetbrains.kotlin.idea.project.getStableName
 import org.jetbrains.kotlin.idea.stubindex.KotlinSourceFilterScope
 import org.jetbrains.kotlin.idea.util.isInSourceContentWithoutInjected
@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.idea.util.rootManager
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.DefaultIdeTargetPlatformKindProvider
 import org.jetbrains.kotlin.platform.idePlatformKind
-import org.jetbrains.kotlin.resolve.PlatformDependentCompilerServices
+import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.platform.compat.toOldPlatform
@@ -53,7 +53,7 @@ import org.jetbrains.kotlin.platform.isCommon
 import org.jetbrains.kotlin.platform.js.isJs
 import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.platform.konan.isNative
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformCompilerServices
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
 import org.jetbrains.kotlin.utils.addIfNotNull
 import java.util.*

@@ -163,8 +163,8 @@ interface ModuleSourceInfo : IdeaModuleInfo, TrackableModuleInfo {
    )
    fun getPlatform(): org.jetbrains.kotlin.resolve.TargetPlatform = platform.toOldPlatform()

-    override val compilerServices: PlatformDependentCompilerServices
-        get() = platform.findCompilerServices
+    override val analyzerServices: PlatformDependentAnalyzerServices
+        get() = platform.findAnalyzerServices

    override fun createModificationTracker(): ModificationTracker =
        KotlinModuleModificationTracker(module)
@@ -308,8 +308,8 @@ open class LibraryInfo(val project: Project, val library: Library) : IdeaModuleI
    override val platform: TargetPlatform
        get() = getLibraryPlatform(project, library)

-    override val compilerServices: PlatformDependentCompilerServices
-        get() = platform.findCompilerServices
+    override val analyzerServices: PlatformDependentAnalyzerServices
+        get() = platform.findAnalyzerServices

    override val sourcesModuleInfo: SourceForBinaryModuleInfo
        get() = LibrarySourceInfo(project, library, this)
@@ -344,8 +344,8 @@ data class LibrarySourceInfo(val project: Project, val library: Library, overrid
    override val platform: TargetPlatform
        get() = binariesModuleInfo.platform

-    override val compilerServices: PlatformDependentCompilerServices
-        get() = binariesModuleInfo.compilerServices
+    override val analyzerServices: PlatformDependentAnalyzerServices
+        get() = binariesModuleInfo.analyzerServices

    override fun toString() = "LibrarySourceInfo(libraryName=${library.name})"
 }
@@ -364,8 +364,8 @@ data class SdkInfo(val project: Project, val sdk: Sdk) : IdeaModuleInfo {
    override val platform: TargetPlatform
        get() = JvmPlatforms.defaultJvmPlatform // TODO(dsavvinov): provide proper target version

-    override val compilerServices: PlatformDependentCompilerServices
-        get() = JvmPlatformCompilerServices
+    override val analyzerServices: PlatformDependentAnalyzerServices
+        get() = JvmPlatformAnalyzerServices
 }

 object NotUnderContentRootModuleInfo : IdeaModuleInfo {
@@ -382,8 +382,8 @@ object NotUnderContentRootModuleInfo : IdeaModuleInfo {
    override val platform: TargetPlatform
        get() = DefaultIdeTargetPlatformKindProvider.defaultPlatform

-    override val compilerServices: PlatformDependentCompilerServices
-        get() = platform.findCompilerServices
+    override val analyzerServices: PlatformDependentAnalyzerServices
+        get() = platform.findAnalyzerServices
 }

 private class LibraryWithoutSourceScope(project: Project, private val library: Library) :
@@ -473,8 +473,8 @@ data class PlatformModuleInfo(
    override val moduleOrigin: ModuleOrigin
        get() = platformModule.moduleOrigin

-    override val compilerServices: PlatformDependentCompilerServices
-        get() = platform.findCompilerServices
+    override val analyzerServices: PlatformDependentAnalyzerServices
+        get() = platform.findAnalyzerServices

    override fun dependencies() = platformModule.dependencies()

@@ -14,11 +14,10 @@ import org.jetbrains.kotlin.idea.core.script.dependencies.ScriptAdditionalIdeaDe
 import org.jetbrains.kotlin.idea.stubindex.KotlinSourceFilterScope
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.scripting.definitions.KotlinScriptDefinition
-import org.jetbrains.kotlin.resolve.PlatformDependentCompilerServices
+import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
 import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformCompilerServices
-
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices

 data class ScriptModuleInfo(
    val project: Project,
@@ -54,8 +53,8 @@ data class ScriptModuleInfo(
    override val platform: TargetPlatform
        get() = JvmPlatforms.defaultJvmPlatform // TODO(dsavvinov): choose proper target version

-    override val compilerServices: PlatformDependentCompilerServices
-        get() = JvmPlatformCompilerServices
+    override val analyzerServices: PlatformDependentAnalyzerServices
+        get() = JvmPlatformAnalyzerServices
 }

 sealed class ScriptDependenciesInfo(val project: Project) : IdeaModuleInfo, BinaryModuleInfo {
@@ -80,8 +79,8 @@ sealed class ScriptDependenciesInfo(val project: Project) : IdeaModuleInfo, Bina
    override val platform: TargetPlatform
        get() = JvmPlatforms.defaultJvmPlatform // TODO(dsavvinov): choose proper TargetVersion

-    override val compilerServices: PlatformDependentCompilerServices
-        get() = JvmPlatformCompilerServices
+    override val analyzerServices: PlatformDependentAnalyzerServices
+        get() = JvmPlatformAnalyzerServices

    class ForFile(
        project: Project,
@@ -135,8 +134,8 @@ sealed class ScriptDependenciesSourceInfo(val project: Project) : IdeaModuleInfo
    override val platform: TargetPlatform
        get() = JvmPlatforms.defaultJvmPlatform // TODO(dsavvinov): choose proper TargetVersion

-    override val compilerServices: PlatformDependentCompilerServices
-        get() = JvmPlatformCompilerServices
+    override val analyzerServices: PlatformDependentAnalyzerServices
+        get() = JvmPlatformAnalyzerServices

    class ForProject(project: Project) : ScriptDependenciesSourceInfo(project)
 }
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
 import org.jetbrains.kotlin.frontend.di.createContainerForLazyBodyResolve
 import org.jetbrains.kotlin.idea.caches.project.getModuleInfo
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
-import org.jetbrains.kotlin.idea.project.findCompilerServices
+import org.jetbrains.kotlin.idea.project.findAnalyzerServices
 import org.jetbrains.kotlin.idea.project.languageVersionSettings
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
@@ -197,7 +197,7 @@ private object KotlinResolveDataProvider {
                trace,
                targetPlatform,
                bodyResolveCache,
-                targetPlatform.findCompilerServices,
+                targetPlatform.findAnalyzerServices,
                analyzableElement.languageVersionSettings
            ).get<LazyTopDownAnalyzer>()

@@ -718,7 +718,7 @@ class ResolveElementCache(
            trace,
            targetPlatform,
            statementFilter,
-            targetPlatform.findCompilerServices,
+            targetPlatform.findAnalyzerServices,
            file.languageVersionSettings
        ).get()
    }
@@ -5,24 +5,24 @@

 package org.jetbrains.kotlin.idea.project

-import org.jetbrains.kotlin.analyzer.common.CommonPlatformCompilerServices
-import org.jetbrains.kotlin.js.resolve.JsPlatformCompilerServices
+import org.jetbrains.kotlin.analyzer.common.CommonPlatformAnalyzerServices
+import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
 import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.platform.isCommon
 import org.jetbrains.kotlin.platform.js.isJs
 import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.platform.konan.isNative
 import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformCompilerServices
-import org.jetbrains.kotlin.resolve.konan.platform.NativePlatformCompilerServices
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
+import org.jetbrains.kotlin.resolve.konan.platform.NativePlatformAnalyzerServices
 import java.lang.IllegalStateException

-val TargetPlatform.findCompilerServices: PlatformDependentCompilerServices
+val TargetPlatform.findAnalyzerServices: PlatformDependentAnalyzerServices
    get() =
        when {
-            isJvm() -> JvmPlatformCompilerServices
-            isJs() -> JsPlatformCompilerServices
-            isNative() -> NativePlatformCompilerServices
-            isCommon() -> CommonPlatformCompilerServices
+            isJvm() -> JvmPlatformAnalyzerServices
+            isJs() -> JsPlatformAnalyzerServices
+            isNative() -> NativePlatformAnalyzerServices
+            isCommon() -> CommonPlatformAnalyzerServices
            else -> throw IllegalStateException("Unknown platform $this")
        }
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.asJava.ImpreciseResolveResult.*
 import org.jetbrains.kotlin.idea.caches.project.getNullableModuleInfo
 import org.jetbrains.kotlin.idea.compiler.IDELanguageSettingsProvider
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
-import org.jetbrains.kotlin.idea.project.findCompilerServices
+import org.jetbrains.kotlin.idea.project.findAnalyzerServices
 import org.jetbrains.kotlin.idea.stubindex.KotlinTypeAliasShortNameIndex
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.name.FqName
@@ -259,7 +259,7 @@ class PsiBasedClassResolver @TestOnly constructor(private val targetClassFqName:

 private fun KtFile.getDefaultImports(): List<ImportPath> {
    val moduleInfo = getNullableModuleInfo() ?: return emptyList()
-    return TargetPlatformDetector.getPlatform(this).findCompilerServices.getDefaultImports(
+    return TargetPlatformDetector.getPlatform(this).findAnalyzerServices.getDefaultImports(
        IDELanguageSettingsProvider.getLanguageVersionSettings(moduleInfo, project),
        includeLowPriorityImports = true
    )
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.ide.konan.createPackageFragmentProvider
 import org.jetbrains.kotlin.platform.konan.KonanPlatforms
 import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
 import org.jetbrains.kotlin.resolve.TargetEnvironment
-import org.jetbrains.kotlin.resolve.konan.platform.NativePlatformCompilerServices
+import org.jetbrains.kotlin.resolve.konan.platform.NativePlatformAnalyzerServices
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService.Companion.createDeclarationProviderFactory

@@ -45,7 +45,7 @@ object NativeResolverForModuleFactory : ResolverForModuleFactory() {
            declarationProviderFactory,
            CodeAnalyzerInitializer.getInstance(moduleContext.project).createTrace(),
            KonanPlatforms.defaultKonanPlatform,
-            NativePlatformCompilerServices,
+            NativePlatformAnalyzerServices,
            targetEnvironment,
            languageVersionSettings
        )
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.idea.inspections.collections
 import com.intellij.codeInspection.ProblemHighlightType
 import com.intellij.codeInspection.ProblemsHolder
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.js.resolve.JsPlatformCompilerServices
+import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.psi.qualifiedExpressionVisitor
@@ -31,7 +31,7 @@ class SimplifiableCallChainInspection : AbstractCallChainChecker() {
                if (conversion.replacement.startsWith("joinTo")) {
                    // Function parameter in map must have String result type
                    if (!firstResolvedCall.hasLastFunctionalParameterWithResult(context) {
-                            it.isSubtypeOf(JsPlatformCompilerServices.builtIns.charSequence.defaultType)
+                            it.isSubtypeOf(JsPlatformAnalyzerServices.builtIns.charSequence.defaultType)
                        }
                    ) return@check false
                }
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.idea.analysis.analyzeInContext
 import org.jetbrains.kotlin.idea.caches.resolve.resolveImportReference
 import org.jetbrains.kotlin.idea.codeInliner.CodeToInline
 import org.jetbrains.kotlin.idea.codeInliner.CodeToInlineBuilder
-import org.jetbrains.kotlin.idea.project.findCompilerServices
+import org.jetbrains.kotlin.idea.project.findAnalyzerServices
 import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
@@ -144,7 +144,7 @@ object ReplaceWithAnnotationAnalyzer {
        languageVersionSettings: LanguageVersionSettings
    ): List<ImportingScope> {
        val allDefaultImports =
-            resolutionFacade.frontendService<TargetPlatform>().findCompilerServices.getDefaultImports(languageVersionSettings, includeLowPriorityImports = true)
+            resolutionFacade.frontendService<TargetPlatform>().findAnalyzerServices.getDefaultImports(languageVersionSettings, includeLowPriorityImports = true)
        val (allUnderImports, aliasImports) = allDefaultImports.partition { it.isAllUnder }
        // this solution doesn't support aliased default imports with a different alias
        // TODO: Create import directives from ImportPath, create ImportResolver, create LazyResolverScope, see FileScopeProviderImpl
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.idea.imports.ImportPathComparator
 import org.jetbrains.kotlin.idea.imports.getImportableTargets
 import org.jetbrains.kotlin.idea.imports.importableFqName
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
-import org.jetbrains.kotlin.idea.project.findCompilerServices
+import org.jetbrains.kotlin.idea.project.findAnalyzerServices
 import org.jetbrains.kotlin.idea.refactoring.fqName.isImported
 import org.jetbrains.kotlin.idea.resolve.frontendService
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
@@ -61,19 +61,19 @@ class ImportInsertHelperImpl(private val project: Project) : ImportInsertHelper(
    override fun isImportedWithDefault(importPath: ImportPath, contextFile: KtFile): Boolean {
        val languageVersionSettings = contextFile.getResolutionFacade().frontendService<LanguageVersionSettings>()
        val platform = TargetPlatformDetector.getPlatform(contextFile)
-        val allDefaultImports = platform.findCompilerServices.getDefaultImports(languageVersionSettings, includeLowPriorityImports = true)
+        val allDefaultImports = platform.findAnalyzerServices.getDefaultImports(languageVersionSettings, includeLowPriorityImports = true)

        val scriptExtraImports = contextFile.takeIf { it.isScript() }?.let { ktFile ->
            val scriptDependencies = ScriptDependenciesProvider.getInstance(ktFile.project)?.getScriptDependencies(ktFile.originalFile)
            scriptDependencies?.imports?.map { ImportPath.fromString(it) }
        }.orEmpty()

-        return importPath.isImported(allDefaultImports + scriptExtraImports, platform.findCompilerServices.excludedImports)
+        return importPath.isImported(allDefaultImports + scriptExtraImports, platform.findAnalyzerServices.excludedImports)
    }

    override fun isImportedWithLowPriorityDefaultImport(importPath: ImportPath, contextFile: KtFile): Boolean {
        val platform = TargetPlatformDetector.getPlatform(contextFile)
-        return importPath.isImported(platform.findCompilerServices.defaultLowPriorityImports, platform.findCompilerServices.excludedImports)
+        return importPath.isImported(platform.findAnalyzerServices.defaultLowPriorityImports, platform.findAnalyzerServices.excludedImports)
    }

    override fun mayImportOnShortenReferences(descriptor: DeclarationDescriptor): Boolean {