Extract module info & target platform to separate frontend.common

2018-04-05 15:53:04 +03:00
parent cd614b5bf8
commit e3aed04d96
32 changed files with 238 additions and 161 deletions
@@ -19,6 +19,7 @@ dependencies {
    compile(project(":compiler:backend"))
    compile(project(":compiler:cli-common"))
    compile(project(":compiler:frontend"))
+    compile(project(":compiler:frontend.common"))
    compile(project(":compiler:frontend.java"))
    compile(project(":compiler:frontend.script"))
    compile(project(":js:js.frontend"))
@@ -17,6 +17,7 @@ import com.intellij.psi.util.CachedValueProvider
 import com.intellij.psi.util.CachedValuesManager
 import com.intellij.util.containers.ContainerUtil
 import com.intellij.util.containers.MultiMap
+import org.jetbrains.kotlin.analyzer.common.CommonPlatform
 import org.jetbrains.kotlin.idea.core.util.CachedValue
 import org.jetbrains.kotlin.idea.core.util.getValue
 import org.jetbrains.kotlin.idea.framework.getLibraryPlatform
@@ -91,7 +92,7 @@ class LibraryDependenciesCacheImpl(private val project: Project) : LibraryDepend
     * @return true if it's OK to add a dependency from a library with platform [from] to a library with platform [to]
     */
    private fun compatiblePlatforms(from: TargetPlatform, to: TargetPlatform): Boolean {
-        return from == to || to == TargetPlatform.Common
+        return from == to || to is CommonPlatform
    }

    private fun getLibraryUsageIndex(): LibraryUsageIndex {
@@ -15,6 +15,7 @@ import com.intellij.openapi.roots.LibraryOrderEntry
 import com.intellij.openapi.roots.ModuleRootManager
 import com.intellij.openapi.roots.ProjectRootModificationTracker
 import com.intellij.psi.util.CachedValueProvider
+import org.jetbrains.kotlin.analyzer.common.CommonPlatform
 import org.jetbrains.kotlin.resolve.TargetPlatform
 import java.util.concurrent.ConcurrentHashMap

@@ -69,7 +70,7 @@ private fun mergePlatformModules(
    allModules: List<ModuleSourceInfo>,
    platform: TargetPlatform
 ): List<IdeaModuleInfo> {
-    if (platform == TargetPlatform.Common) return allModules
+    if (platform is CommonPlatform) return allModules

    val platformModules =
        allModules.flatMap { module ->
@@ -14,6 +14,7 @@ import com.intellij.openapi.roots.ProjectRootModificationTracker
 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.CachedValueProvider
 import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.analyzer.common.CommonPlatform
 import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.idea.caches.project.SourceType.PRODUCTION
@@ -118,10 +119,10 @@ private fun ModuleSourceInfo.toDescriptor() = KotlinCacheService.getInstance(mod
    .getResolutionFacadeByModuleInfo(this, platform)?.moduleDescriptor

 fun PsiElement.getPlatformModuleInfo(desiredPlatform: TargetPlatform): PlatformModuleInfo? {
-    assert(desiredPlatform != TargetPlatform.Common) { "Platform module cannot have Common platform" }
+    assert(desiredPlatform !is CommonPlatform) { "Platform module cannot have Common platform" }
    val moduleInfo = getNullableModuleInfo() as? ModuleSourceInfo ?: return null
    return when (moduleInfo.platform) {
-        TargetPlatform.Common -> {
+        is CommonPlatform -> {
            val correspondingImplementingModule = moduleInfo.module.implementingModules.map { it.toInfo(moduleInfo.sourceType) }
                .firstOrNull { it?.platform == desiredPlatform } ?: return null
            PlatformModuleInfo(correspondingImplementingModule, correspondingImplementingModule.expectedBy)
@@ -25,6 +25,7 @@ import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.util.containers.SLRUCache
 import org.jetbrains.kotlin.analyzer.*
 import org.jetbrains.kotlin.analyzer.common.CommonAnalysisParameters
+import org.jetbrains.kotlin.analyzer.common.CommonPlatform
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns
 import org.jetbrains.kotlin.caches.resolve.resolution
@@ -147,7 +148,7 @@ internal class ProjectResolutionFacade(
            platformParameters = { platform ->
                when (platform) {
                    is JvmPlatform -> jvmPlatformParameters
-                    is TargetPlatform.Common -> commonPlatformParameters
+                    is CommonPlatform -> commonPlatformParameters
                    else -> PlatformAnalysisParameters.Empty
                }
            },
@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.idea.decompiler.builtIns
 import com.intellij.ide.highlighter.JavaClassFileType
 import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.annotations.TestOnly
+import org.jetbrains.kotlin.analyzer.common.CommonPlatform
 import org.jetbrains.kotlin.idea.decompiler.common.FileWithMetadata
 import org.jetbrains.kotlin.idea.decompiler.common.KotlinMetadataDecompiler
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.builtins.BuiltInsBinaryVersion
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.psi.stubs.KotlinStubVersions
-import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.serialization.deserialization.FlexibleTypeDeserializer
 import org.jetbrains.kotlin.serialization.deserialization.MetadataPackageFragment
 import org.jetbrains.kotlin.serialization.deserialization.builtins.BuiltInSerializerProtocol
@@ -33,9 +33,9 @@ import org.jetbrains.kotlin.serialization.deserialization.getClassId
 import java.io.ByteArrayInputStream

 class KotlinBuiltInDecompiler : KotlinMetadataDecompiler<BuiltInsBinaryVersion>(
-        KotlinBuiltInFileType, TargetPlatform.Common, BuiltInSerializerProtocol,
-        FlexibleTypeDeserializer.ThrowException, BuiltInsBinaryVersion.INSTANCE, BuiltInsBinaryVersion.INVALID_VERSION,
-        KotlinStubVersions.BUILTIN_STUB_VERSION
+    KotlinBuiltInFileType, CommonPlatform, BuiltInSerializerProtocol,
+    FlexibleTypeDeserializer.ThrowException, BuiltInsBinaryVersion.INSTANCE, BuiltInsBinaryVersion.INVALID_VERSION,
+    KotlinStubVersions.BUILTIN_STUB_VERSION
 ) {
    override fun readFile(bytes: ByteArray, file: VirtualFile): FileWithMetadata? {
        return BuiltInDefinitionFile.read(bytes, file)
@@ -18,6 +18,7 @@ import com.intellij.psi.stubs.StringStubIndexExtension
 import com.intellij.util.containers.ContainerUtil
 import gnu.trove.THashSet
 import org.jetbrains.annotations.TestOnly
+import org.jetbrains.kotlin.analyzer.common.CommonPlatform
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.idea.caches.project.BinaryModuleInfo
 import org.jetbrains.kotlin.idea.caches.project.getBinaryLibrariesModuleInfos
@@ -75,10 +76,10 @@ object SourceNavigationHelper {

    private fun BinaryModuleInfo.associatedCommonLibraries(): List<BinaryModuleInfo> {
        val platform = platform
-        if (platform == null || platform == TargetPlatform.Common) return emptyList()
+        if (platform == null || platform is CommonPlatform) return emptyList()

        return dependencies().filterIsInstance<BinaryModuleInfo>().filter {
-            it.platform == TargetPlatform.Common
+            it.platform is CommonPlatform
        }
    }

@@ -24,6 +24,7 @@ import com.intellij.openapi.roots.libraries.Library
 import com.intellij.openapi.roots.libraries.PersistentLibraryKind
 import com.intellij.openapi.util.io.JarUtil
 import com.intellij.openapi.vfs.*
+import org.jetbrains.kotlin.analyzer.common.CommonPlatform
 import org.jetbrains.kotlin.caches.resolve.IdePlatformKindResolution
 import org.jetbrains.kotlin.caches.resolve.resolution
 import org.jetbrains.kotlin.idea.vfilefinder.KnownLibraryKindForIndex
@@ -49,7 +50,7 @@ object JSLibraryKind : PersistentLibraryKind<DummyLibraryProperties>("kotlin.js"

 object CommonLibraryKind : PersistentLibraryKind<DummyLibraryProperties>("kotlin.common"), KotlinLibraryKind {
    override val compilerPlatform: TargetPlatform
-        get() = TargetPlatform.Common
+        get() = CommonPlatform

    override fun createDefaultProperties() = DummyLibraryProperties.INSTANCE!!
 }
@@ -6,12 +6,12 @@
@file:JvmName("CommonIdePlatformUtil")
 package org.jetbrains.kotlin.platform.impl

+import org.jetbrains.kotlin.analyzer.common.CommonPlatform
 import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.K2MetadataCompilerArguments
 import org.jetbrains.kotlin.config.TargetPlatformVersion
 import org.jetbrains.kotlin.platform.IdePlatform
 import org.jetbrains.kotlin.platform.IdePlatformKind
-import org.jetbrains.kotlin.resolve.TargetPlatform

 object CommonIdePlatformKind : IdePlatformKind<CommonIdePlatformKind>() {

@@ -20,7 +20,7 @@ object CommonIdePlatformKind : IdePlatformKind<CommonIdePlatformKind>() {
        else null
    }

-    override val compilerPlatform get() = TargetPlatform.Common
+    override val compilerPlatform get() = CommonPlatform

    override val platforms get() = listOf(Platform)
    override val defaultPlatform get() = Platform
@@ -21,6 +21,7 @@ import com.intellij.openapi.util.Pair
 import com.intellij.openapi.util.text.StringUtil
 import com.intellij.openapi.wm.ToolWindow
 import com.intellij.util.Alarm
+import org.jetbrains.kotlin.analyzer.common.CommonPlatform
 import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
 import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
 import org.jetbrains.kotlin.codegen.ClassBuilderFactories
@@ -39,7 +40,6 @@ import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtScript
-import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.utils.join
 import java.awt.BorderLayout
@@ -277,7 +277,7 @@ class KotlinBytecodeToolWindow(private val myProject: Project, private val toolW
            configuration: CompilerConfiguration
        ): GenerationState? {
            val platform = ktFile.platform
-            if (platform != TargetPlatform.Common && platform != JvmPlatform) return null
+            if (platform !is CommonPlatform && platform !is JvmPlatform) return null

            val resolutionFacade = KotlinCacheService.getInstance(ktFile.project)
                .getResolutionFacadeByFile(ktFile, JvmPlatform)
@@ -23,6 +23,7 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiNameIdentifierOwner
 import com.intellij.util.IncorrectOperationException
+import org.jetbrains.kotlin.analyzer.common.CommonPlatform
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.config.ApiVersion
 import org.jetbrains.kotlin.config.LanguageFeature
@@ -44,7 +45,6 @@ import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.psi.psiUtil.hasExpectModifier
 import org.jetbrains.kotlin.psi.psiUtil.quoteIfNeeded
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassOrAny
 import org.jetbrains.kotlin.resolve.source.getPsi
@@ -133,7 +133,7 @@ class KotlinGenerateEqualsAndHashcodeAction : KotlinGenerateMemberActionBase<Kot
        if (!targetClass.languageVersionSettings.supportsFeature(LanguageFeature.BoundCallableReferences)) return defaultExpression
        return when (targetClass.platform) {
            is JsPlatform -> "other == null || this::class.js != $paramName::class.js"
-            is TargetPlatform.Common -> "other == null || this::class != $paramName::class"
+            is CommonPlatform -> "other == null || this::class != $paramName::class"
            else -> defaultExpression
        }
    }
@@ -143,7 +143,7 @@ class KotlinGenerateEqualsAndHashcodeAction : KotlinGenerateMemberActionBase<Kot
        if (!targetClass.languageVersionSettings.supportsFeature(LanguageFeature.BoundCallableReferences)) return defaultExpression
        return when (targetClass.platform) {
            is JsPlatform -> "this::class.js"
-            is TargetPlatform.Common -> "this::class"
+            is CommonPlatform -> "this::class"
            else -> defaultExpression
        }
    }
@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.idea.highlighter
 import com.intellij.lang.annotation.AnnotationHolder
 import com.intellij.lang.annotation.Annotator
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analyzer.common.CommonPlatform
 import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
 import org.jetbrains.kotlin.descriptors.MemberDescriptor
 import org.jetbrains.kotlin.idea.caches.project.implementingDescriptors
@@ -32,7 +33,6 @@ import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.psi.KtPsiUtil
 import org.jetbrains.kotlin.psi.psiUtil.hasExpectModifier
 import org.jetbrains.kotlin.resolve.BindingTraceContext
-import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker
 import org.jetbrains.kotlin.resolve.diagnostics.SimpleDiagnostics
 import org.jetbrains.kotlin.resolve.jvm.multiplatform.JavaActualAnnotationArgumentExtractor
@@ -42,7 +42,7 @@ class PlatformExpectedAnnotator : Annotator {
        val declaration = element as? KtNamedDeclaration ?: return
        if (!isExpectedDeclaration(declaration)) return

-        if (TargetPlatformDetector.getPlatform(declaration.containingKtFile) !is TargetPlatform.Common) return
+        if (TargetPlatformDetector.getPlatform(declaration.containingKtFile) !is CommonPlatform) return

        val implementingModules = declaration.findModuleDescriptor().implementingDescriptors
        if (implementingModules.isEmpty()) return
@@ -27,13 +27,13 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiDocumentManager
 import com.intellij.refactoring.rename.RenameProcessor
+import org.jetbrains.kotlin.analyzer.common.CommonPlatform
 import org.jetbrains.kotlin.asJava.toLightMethods
 import org.jetbrains.kotlin.idea.project.platform
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.js.resolve.JsPlatform
 import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.psiUtil.quoteIfNeeded
-import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.decapitalizeSmart
 import org.jetbrains.kotlin.utils.SmartList

@@ -42,7 +42,7 @@ class ConvertCamelCaseTestFunctionToSpacedIntention : SelfTargetingRangeIntentio
 ) {
    override fun applicabilityRange(element: KtNamedFunction): TextRange? {
        val platform = element.platform
-        if (platform == TargetPlatform.Common || platform == JsPlatform) return null
+        if (platform is CommonPlatform || platform is JsPlatform) return null
        val range = element.nameIdentifier?.textRange ?: return null

        val name = element.name ?: return null
@@ -32,6 +32,7 @@ import org.jetbrains.jps.model.module.JpsTypedModuleSourceRoot
 import org.jetbrains.jps.model.serialization.facet.JpsFacetSerializer
 import org.jetbrains.jps.model.serialization.module.JpsModuleRootModelSerializer
 import org.jetbrains.jps.model.serialization.module.JpsModuleRootModelSerializer.*
+import org.jetbrains.kotlin.analyzer.common.CommonPlatform
 import org.jetbrains.kotlin.config.getFacetPlatformByConfigurationElement
 import org.jetbrains.kotlin.idea.facet.KotlinFacetType
 import org.jetbrains.kotlin.idea.framework.*
@@ -54,7 +55,7 @@ class KotlinNonJvmSourceRootConverterProvider : ConverterProvider("kotlin-non-jv
            get() = when (this) {
                is JvmPlatform -> { roots -> JavaRuntimeDetectionUtil.getRuntimeJar(roots.toList()) != null }
                is JsPlatform -> { roots -> JsLibraryStdDetectionUtil.getJsStdLibJar(roots.toList()) != null }
-                is TargetPlatform.Common -> { roots -> getLibraryJar(roots, PathUtil.KOTLIN_STDLIB_COMMON_JAR_PATTERN) != null }
+                is CommonPlatform -> { roots -> getLibraryJar(roots, PathUtil.KOTLIN_STDLIB_COMMON_JAR_PATTERN) != null }
                else -> null
            }
    }
@@ -148,7 +149,7 @@ class KotlinNonJvmSourceRootConverterProvider : ConverterProvider("kotlin-non-jv
                        .forEach {
                            val platform = it.platform
                            when (platform) {
-                                is TargetPlatform.Common -> {
+                                is CommonPlatform -> {
                                    if (!hasCommonStdlib && it.isStdlib) {
                                        hasCommonStdlib = true
                                    }
@@ -160,7 +161,7 @@ class KotlinNonJvmSourceRootConverterProvider : ConverterProvider("kotlin-non-jv
                            }
                        }

-                    return if (hasCommonStdlib) TargetPlatform.Common else null
+                    return if (hasCommonStdlib) CommonPlatform else null
                }

                private fun ModuleSettings.detectPlatform(): TargetPlatform {
@@ -25,6 +25,7 @@ import com.intellij.testFramework.PlatformTestUtil
 import com.intellij.testFramework.TestActionEvent
 import junit.framework.ComparisonFailure
 import junit.framework.TestCase
+import org.jetbrains.kotlin.analyzer.common.CommonPlatform
 import org.jetbrains.kotlin.idea.project.forcedTargetPlatform
 import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
@@ -91,7 +92,7 @@ abstract class AbstractCodeInsightActionTest : KotlinLightCodeInsightFixtureTest
                val targetPlatform = when (targetPlatformName) {
                    "JVM" -> JvmPlatform
                    "JavaScript" -> JsPlatform
-                    "Common" -> TargetPlatform.Common
+                    "Common" -> CommonPlatform
                    else -> error("Unexpected platform name: $targetPlatformName")
                }
                mainPsiFile.forcedTargetPlatform = targetPlatform