[Platform API] Introduce fundamental abstraction of Platform

This is a large commit, which introduces general API for working with abstraction of Platform. - Add new abstraction to 'core' - SimplePlatform - which represents exactly one platform - Clients are strongly prohibited to create instances of SimplePlatform by hand, instead, corresponding *Platforms abstraction should be used (e.g. JvmPlatforms, JsPlatforms, KonanPlatforms) - Move TargetPlatform to 'core', it represents now a collection of SimplePlatforms - Clients are strongly encouraged to use TargetPlatform (not SimplePlatform) in API, to enforce checks for multiplatform - Provide a helper-extensions to work with TargetPlatform (in particular, for getting a specific component platform) - Remove MultiTargetPlatform in favour of TargetPlatform - Notably, this commit leaves another widely used duplicated abstraction, namely, IdePlatform. For the sake sanity, removal of IdePlatform is extracted in the separate commit.
2019-04-24 11:59:07 +03:00
parent 451d14e504
commit d5fbe59a3e
162 changed files with 832 additions and 711 deletions
@@ -22,7 +22,7 @@ import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.psi.KtElement
-import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.resolve.diagnostics.KotlinSuppressCache

 interface KotlinCacheService {
@@ -51,6 +51,7 @@ import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.resolve.*
@@ -63,7 +64,6 @@ 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.JvmPlatform
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformCompilerServices
 import org.jetbrains.kotlin.resolve.lazy.FileScopeProviderImpl
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
@@ -306,10 +306,10 @@ internal object IDELightClassContexts {

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

            useInstance(GlobalSearchScope.EMPTY_SCOPE)
@@ -45,8 +45,7 @@ import org.jetbrains.kotlin.idea.util.rootManager
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.idePlatformKind
 import org.jetbrains.kotlin.resolve.PlatformDependentCompilerServices
-import org.jetbrains.kotlin.resolve.TargetPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.utils.addIfNotNull
 import java.util.*

@@ -17,11 +17,11 @@ 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
-import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.isCommon
 import org.jetbrains.kotlin.utils.addIfNotNull
 import java.util.*

@@ -92,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 is CommonPlatform
+        return from == to || to.isCommon()
    }

    private fun getLibraryUsageIndex(): LibraryUsageIndex {
@@ -15,7 +15,7 @@ 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.TargetPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform

 data class ScriptModuleInfo(
    val project: Project,
@@ -15,8 +15,8 @@ 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 org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.isCommon
 import java.util.concurrent.ConcurrentHashMap

 fun getModuleInfosFromIdeaModel(project: Project, platform: TargetPlatform): List<IdeaModuleInfo> {
@@ -70,7 +70,7 @@ private fun mergePlatformModules(
    allModules: List<ModuleSourceInfo>,
    platform: TargetPlatform
 ): List<IdeaModuleInfo> {
-    if (platform is CommonPlatform) return allModules
+    if (platform.isCommon()) return allModules

    val platformModules =
        allModules.flatMap { module ->
@@ -14,7 +14,6 @@ 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
@@ -26,7 +25,8 @@ import org.jetbrains.kotlin.idea.project.platform
 import org.jetbrains.kotlin.idea.util.rootManager
 import org.jetbrains.kotlin.platform.impl.CommonIdePlatformKind
 import org.jetbrains.kotlin.platform.impl.isCommon
-import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.isCommon

 val Module.isNewMPPModule: Boolean
    get() = facetSettings?.kind?.isNewMPP ?: false
@@ -119,15 +119,16 @@ private fun ModuleSourceInfo.toDescriptor() = KotlinCacheService.getInstance(mod
    .getResolutionFacadeByModuleInfo(this, platform)?.moduleDescriptor

 fun PsiElement.getPlatformModuleInfo(desiredPlatform: TargetPlatform): PlatformModuleInfo? {
-    assert(desiredPlatform !is CommonPlatform) { "Platform module cannot have Common platform" }
+    assert(!desiredPlatform.isCommon()) { "Platform module cannot have Common platform" }
    val moduleInfo = getNullableModuleInfo() as? ModuleSourceInfo ?: return null
-    return when (moduleInfo.platform) {
-        is CommonPlatform -> {
+    val platform = moduleInfo.platform
+    return when {
+        platform.isCommon() -> {
            val correspondingImplementingModule = moduleInfo.module.implementingModules.map { it.toInfo(moduleInfo.sourceType) }
                .firstOrNull { it?.platform == desiredPlatform } ?: return null
            PlatformModuleInfo(correspondingImplementingModule, correspondingImplementingModule.expectedBy)
        }
-        desiredPlatform -> {
+        platform == desiredPlatform -> {
            val expectedBy = moduleInfo.expectedBy.takeIf { it.isNotEmpty() } ?: return null
            PlatformModuleInfo(moduleInfo, expectedBy)
        }
@@ -29,7 +29,8 @@ import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.utils.sure
 import java.util.*
@@ -240,7 +241,7 @@ class IDEKotlinAsJavaSupport(private val project: Project) : KotlinAsJavaSupport
    // thus we need to ensure that resolver will be built by the file from platform part of the module
    // (resolver built by a file from the common part will have no knowledge of the platform part)
    // the actual of order of files that resolver receives is controlled by *findFilesForFacade* method
-    private fun Collection<KtFile>.platformSourcesFirst() = sortedByDescending { it.platform == JvmPlatform }
+    private fun Collection<KtFile>.platformSourcesFirst() = sortedByDescending { it.platform.isJvm() }

    private fun getLightClassForDecompiledClassOrObject(decompiledClassOrObject: KtClassOrObject): KtLightClassForDecompiledDeclaration? {
        if (decompiledClassOrObject is KtEnumEntry) {
@@ -331,5 +332,5 @@ class IDEKotlinAsJavaSupport(private val project: Project) : KotlinAsJavaSupport
 }

 internal fun PsiElement.getModuleInfoPreferringJvmPlatform(): IdeaModuleInfo {
-    return getPlatformModuleInfo(JvmPlatform) ?: getModuleInfo()
+    return getPlatformModuleInfo(JvmPlatforms.defaultJvmPlatform) ?: getModuleInfo()
 }
@@ -54,7 +54,7 @@ import org.jetbrains.kotlin.platform.DefaultIdeTargetPlatformKindProvider
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.contains
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.resolve.diagnostics.KotlinSuppressCache
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtFileClassProvider
 import org.jetbrains.kotlin.psi.analysisContext
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.isJvm

 class KtFileClassProviderImpl(val kotlinAsJavaSupport: KotlinAsJavaSupport) :
    KtFileClassProvider {
@@ -40,7 +40,7 @@ class KtFileClassProviderImpl(val kotlinAsJavaSupport: KotlinAsJavaSupport) :
        // common files might be in fact compiled to jvm and thus correspond to a PsiClass
        // this API does not provide context (like GSS) to be able to determine if this file is in fact seen through a jvm module
        // this also fixes a problem where a Java JUnit run configuration producer would produce run configurations for a common file
-        if (moduleInfo.platform !is JvmPlatform) return emptyArray()
+        if (!moduleInfo.platform.isJvm()) return emptyArray()

        val jvmClassInfo = JvmFileClassUtil.getFileClassInfoNoResolve(file)
        val fileClassFqName = file.javaFileFacadeFqName
@@ -23,7 +23,6 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.analyzer.AnalysisResult
-import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.GlobalContext
@@ -33,14 +32,12 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 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.compiler.IDELanguageSettingsProvider
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
 import org.jetbrains.kotlin.idea.project.findCompilerServices
 import org.jetbrains.kotlin.idea.project.languageVersionSettings
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
 import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import java.util.*
@@ -190,10 +187,8 @@ private object KotlinResolveDataProvider {

            val moduleInfo = analyzableElement.containingKtFile.getModuleInfo()

+            // TODO: should return proper platform!
            val targetPlatform = moduleInfo.platform ?: TargetPlatformDetector.getPlatform(analyzableElement.containingKtFile)
-            val targetPlatformVersion = IDELanguageSettingsProvider.getTargetPlatform(moduleInfo, project).let {
-                if (targetPlatform == JvmPlatform && it !is JvmTarget) JvmTarget.DEFAULT else it
-            }

            val lazyTopDownAnalyzer = createContainerForLazyBodyResolve(
                //TODO: should get ModuleContext
@@ -202,7 +197,6 @@ private object KotlinResolveDataProvider {
                trace,
                targetPlatform,
                bodyResolveCache,
-                targetPlatformVersion,
                targetPlatform.findCompilerServices,
                analyzableElement.languageVersionSettings
            ).get<LazyTopDownAnalyzer>()
@@ -25,7 +25,6 @@ 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
@@ -41,11 +40,13 @@ import org.jetbrains.kotlin.idea.project.IdeaEnvironment
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
 import org.jetbrains.kotlin.platform.idePlatformKind
+import org.jetbrains.kotlin.platform.isCommon
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CompositeBindingContext
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult

 internal class ProjectResolutionFacade(
@@ -125,7 +126,7 @@ internal class ProjectResolutionFacade(
            packagePartProviderFactory = { IDEPackagePartProvider(it.moduleContentScope) },
            moduleByJavaClass = { javaClass: JavaClass ->
                val psiClass = (javaClass as JavaClassImpl).psi
-                psiClass.getPlatformModuleInfo(JvmPlatform)?.platformModule ?: psiClass.getNullableModuleInfo()
+                psiClass.getPlatformModuleInfo(JvmPlatforms.defaultJvmPlatform)?.platformModule ?: psiClass.getNullableModuleInfo()
            }
        )

@@ -144,9 +145,9 @@ internal class ProjectResolutionFacade(
                platform.idePlatformKind.resolution.resolverForModuleFactory
            },
            platformParameters = { platform ->
-                when (platform) {
-                    is JvmPlatform -> jvmPlatformParameters
-                    is CommonPlatform -> commonPlatformParameters
+                when {
+                    platform.isJvm() -> jvmPlatformParameters
+                    platform.isCommon() -> commonPlatformParameters
                    else -> PlatformAnalysisParameters.Empty
                }
            },
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.utils.KotlinExceptionWithAttachments

@@ -28,14 +28,14 @@ import org.jetbrains.kotlin.idea.caches.project.projectSourceModules
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.isSubpackageOf
 import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.isJvm

 class IdePackageOracleFactory(val project: Project) : PackageOracleFactory {
    override fun createOracle(moduleInfo: ModuleInfo): PackageOracle {
        if (moduleInfo !is IdeaModuleInfo) return PackageOracle.Optimistic

-        return when (moduleInfo.platform) {
-            JvmPlatform -> when (moduleInfo.moduleOrigin) {
+        return when {
+            moduleInfo.platform.isJvm() -> when (moduleInfo.moduleOrigin) {
                ModuleOrigin.LIBRARY -> JavaPackagesOracle(moduleInfo, project)
                ModuleOrigin.MODULE -> JvmSourceOracle(moduleInfo, project)
                ModuleOrigin.OTHER -> PackageOracle.Optimistic
@@ -34,8 +34,8 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.psiUtil.parameterIndex
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.resolve.scopes.MemberScope

 fun PsiMethod.getJavaMethodDescriptor(): FunctionDescriptor? = javaResolutionFacade()?.let { getJavaMethodDescriptor(it) }
@@ -154,7 +154,7 @@ fun PsiElement.hasJavaResolutionFacade(): Boolean = this.originalElement.contain
 fun PsiElement.javaResolutionFacade() =
    KotlinCacheService.getInstance(project).getResolutionFacadeByFile(
        this.originalElement.containingFile ?: reportCouldNotCreateJavaFacade(),
-        JvmPlatform
+        JvmPlatforms.defaultJvmPlatform
    )

 private fun PsiElement.reportCouldNotCreateJavaFacade(): Nothing =
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.config.KotlinFacetSettingsProvider
 import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.config.TargetPlatformVersion
+import org.jetbrains.kotlin.platform.TargetPlatformVersion
 import org.jetbrains.kotlin.idea.caches.project.*
 import org.jetbrains.kotlin.idea.project.getLanguageVersionSettings
 import org.jetbrains.kotlin.idea.project.languageVersionSettings
@@ -72,6 +72,7 @@ object IDELanguageSettingsProvider : LanguageSettingsProvider {
        return result
    }

+    // TODO(dsavvinov): get rid of this method; instead store proper instance of TargetPlatformVersion in platform-instance
    override fun getTargetPlatform(moduleInfo: ModuleInfo, project: Project): TargetPlatformVersion =
        when (moduleInfo) {
            is ModuleSourceInfo -> moduleInfo.module.platform?.version ?: TargetPlatformVersion.NoVersion
@@ -19,7 +19,6 @@ 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
@@ -35,8 +35,6 @@ import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder.Result.KotlinClass
 import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.resolve.TargetPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.serialization.deserialization.ClassData
 import org.jetbrains.kotlin.serialization.deserialization.ClassDataFinder
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationComponents
@@ -29,7 +29,6 @@ import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
 import org.jetbrains.kotlin.metadata.deserialization.NameResolver
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.serialization.SerializerExtensionProtocol
 import org.jetbrains.kotlin.serialization.deserialization.*
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPackageMemberScope
@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.idea.decompiler.js
 import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.kotlin.idea.decompiler.common.FileWithMetadata
 import org.jetbrains.kotlin.idea.decompiler.common.KotlinMetadataDecompiler
-import org.jetbrains.kotlin.js.resolve.JsPlatform
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.js.JsProtoBuf
 import org.jetbrains.kotlin.psi.stubs.KotlinStubVersions
@@ -18,7 +18,6 @@ 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
@@ -35,6 +34,7 @@ import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.debugText.getDebugText
+import org.jetbrains.kotlin.platform.isCommon
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult

 object SourceNavigationHelper {
@@ -75,10 +75,10 @@ object SourceNavigationHelper {

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

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

@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.descriptors.impl.MutablePackageFragmentDescriptor
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationComponents
 import org.jetbrains.kotlin.serialization.deserialization.LocalClassifierTypeSettings
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
@@ -24,15 +24,14 @@ 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
 import org.jetbrains.kotlin.idea.vfilefinder.getLibraryKindForJar
-import org.jetbrains.kotlin.js.resolve.JsPlatform
+import org.jetbrains.kotlin.platform.CommonPlatforms
 import org.jetbrains.kotlin.platform.DefaultIdeTargetPlatformKindProvider
-import org.jetbrains.kotlin.resolve.TargetPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.js.JsPlatforms
 import org.jetbrains.kotlin.utils.PathUtil
 import java.util.jar.Attributes
 import java.util.regex.Pattern
@@ -43,14 +42,14 @@ interface KotlinLibraryKind {

 object JSLibraryKind : PersistentLibraryKind<DummyLibraryProperties>("kotlin.js"), KotlinLibraryKind {
    override val compilerPlatform: TargetPlatform
-        get() = JsPlatform
+        get() = JsPlatforms.defaultJsPlatform

    override fun createDefaultProperties() = DummyLibraryProperties.INSTANCE!!
 }

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

    override fun createDefaultProperties() = DummyLibraryProperties.INSTANCE!!
 }
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.isJvm

 class DuplicateJvmSignatureAnnotator : Annotator {
    override fun annotate(element: PsiElement, holder: AnnotationHolder) {
@@ -34,7 +34,7 @@ class DuplicateJvmSignatureAnnotator : Annotator {
        if (!ProjectRootsUtil.isInProjectSource(element)) return

        val file = element.containingFile
-        if (file !is KtFile || TargetPlatformDetector.getPlatform(file) !== JvmPlatform) return
+        if (file !is KtFile || !TargetPlatformDetector.getPlatform(file).isJvm()) return

        val otherDiagnostics = when (element) {
            is KtDeclaration -> element.analyzeWithContent()
@@ -49,7 +49,8 @@ import org.jetbrains.kotlin.platform.impl.isCommon
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.UserDataProperty
-import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.config.JvmTarget
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.utils.Jsr305State
 import java.io.File

@@ -212,6 +213,7 @@ private fun Module.computeLanguageVersionSettings(): LanguageVersionSettings {
 val Module.platform: IdePlatform<*, *>?
    get() = KotlinFacetSettingsProvider.getInstance(project).getInitializedSettings(this).platform ?: project.platform

+// FIXME(dsavvinov): this logic is clearly wrong in MPP environment; review and fix
 val Project.platform: IdePlatform<*, *>?
    get() {
        val jvmTarget = Kotlin2JvmCompilerArgumentsHolder.getInstance(this).settings.jvmTarget ?: return null
@@ -265,12 +267,4 @@ val PsiElement.languageVersionSettings: LanguageVersionSettings
            return LanguageVersionSettingsImpl.DEFAULT
        }
        return IDELanguageSettingsProvider.getLanguageVersionSettings(this.getModuleInfo(), project)
-    }
-
-val KtElement.jvmTarget: JvmTarget
-    get() {
-        if (ServiceManager.getService(project, ProjectFileIndex::class.java) == null) {
-            return JvmTarget.DEFAULT
-        }
-        return IDELanguageSettingsProvider.getTargetPlatform(this.getModuleInfo(), project) as? JvmTarget ?: JvmTarget.DEFAULT
-    }
+    }
@@ -25,7 +25,7 @@ import com.intellij.psi.util.CachedValuesManager;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.platform.IdePlatform;
 import org.jetbrains.kotlin.platform.IdePlatformKindUtil;
-import org.jetbrains.kotlin.resolve.TargetPlatform;
+import org.jetbrains.kotlin.platform.TargetPlatform;

 public class ProjectStructureUtil {
    private static final Key<CachedValue<TargetPlatform>> PLATFORM_FOR_MODULE = Key.create("PLATFORM_FOR_MODULE");
@@ -22,6 +22,7 @@ import com.intellij.psi.util.CachedValueProvider
 import com.intellij.psi.util.CachedValuesManager
 import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.util.containers.ContainerUtil
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.cfg.ControlFlowInformationProvider
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.SimpleGlobalContext
@@ -717,7 +718,6 @@ class ResolveElementCache(
            trace,
            targetPlatform,
            statementFilter,
-            file.jvmTarget,
            targetPlatform.findCompilerServices,
            file.languageVersionSettings
        ).get()
@@ -22,15 +22,17 @@ import com.intellij.openapi.roots.ProjectFileIndex;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
+import kotlin.collections.CollectionsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.platform.DefaultIdeTargetPlatformKindProvider;
 import org.jetbrains.kotlin.platform.IdePlatform;
 import org.jetbrains.kotlin.platform.IdePlatformKind;
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms;
 import org.jetbrains.kotlin.psi.KtCodeFragment;
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
-import org.jetbrains.kotlin.resolve.TargetPlatform;
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
+import org.jetbrains.kotlin.platform.TargetPlatform;
+import org.jetbrains.kotlin.platform.SimplePlatform;
 import org.jetbrains.kotlin.scripting.definitions.DefinitionsKt;
 import org.jetbrains.kotlin.scripting.definitions.KotlinScriptDefinition;

@@ -56,7 +58,8 @@ public class TargetPlatformDetector {
        PsiElement context = KtPsiFactoryKt.getAnalysisContext(file);
        if (context != null) {
            PsiFile contextFile = context.getContainingFile();
-            return contextFile instanceof KtFile ? getPlatform((KtFile) contextFile) : JvmPlatform.INSTANCE;
+            // TODO(dsavvinov): Get default platform with proper target
+            return contextFile instanceof KtFile ? getPlatform((KtFile) contextFile) : JvmPlatforms.INSTANCE.getDefaultJvmPlatform();
        }

        if (file.isScript()) {
@@ -65,7 +68,9 @@ public class TargetPlatformDetector {
                String platformNameFromScriptDefinition = scriptDefinition.getPlatform();
                for (IdePlatform platform : IdePlatformKind.Companion.getAll_PLATFORMS()) {
                    TargetPlatform compilerPlatform = platform.getKind().getCompilerPlatform();
-                    if (compilerPlatform.getPlatformName().equals(platformNameFromScriptDefinition)) {
+                    // FIXME(dsavvinov): get rid of matching by name
+                    SimplePlatform simplePlatform = CollectionsKt.single(compilerPlatform);
+                    if (simplePlatform.getPlatformName().equals(platformNameFromScriptDefinition)) {
                        return compilerPlatform;
                    }
                }
@@ -5,24 +5,24 @@

 package org.jetbrains.kotlin.idea.project

-import org.jetbrains.kotlin.analyzer.common.CommonPlatform
 import org.jetbrains.kotlin.analyzer.common.CommonPlatformCompilerServices
-import org.jetbrains.kotlin.js.resolve.JsPlatform
 import org.jetbrains.kotlin.js.resolve.JsPlatformCompilerServices
-import org.jetbrains.kotlin.resolve.PlatformDependentCompilerServices
-import org.jetbrains.kotlin.resolve.TargetPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+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.KonanPlatform
 import org.jetbrains.kotlin.resolve.konan.platform.NativePlatformCompilerServices
 import java.lang.IllegalStateException

 val TargetPlatform.findCompilerServices: PlatformDependentCompilerServices
    get() =
-        when (this) {
-            is JvmPlatform -> JvmPlatformCompilerServices
-            is JsPlatform -> JsPlatformCompilerServices
-            is KonanPlatform -> NativePlatformCompilerServices
-            is CommonPlatform -> CommonPlatformCompilerServices
+        when {
+            isJvm() -> JvmPlatformCompilerServices
+            isJs() -> JsPlatformCompilerServices
+            isNative() -> NativePlatformCompilerServices
+            isCommon() -> CommonPlatformCompilerServices
            else -> throw IllegalStateException("Unknown platform $this")
        }
@@ -17,14 +17,14 @@ import org.jetbrains.kotlin.idea.configuration.getBuildSystemType
 import org.jetbrains.kotlin.idea.util.projectStructure.version
 import org.jetbrains.kotlin.idea.versions.MAVEN_STDLIB_ID_JDK7
 import org.jetbrains.kotlin.idea.versions.hasJreSpecificRuntime
-import org.jetbrains.kotlin.resolve.TargetPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
+import org.jetbrains.kotlin.platform.TargetPlatform

 class KotlinAndroidGradleModuleConfigurator internal constructor() : KotlinWithGradleConfigurator() {

    override val name: String = NAME

-    override val targetPlatform: TargetPlatform = JvmPlatform
+    override val targetPlatform: TargetPlatform = JvmPlatforms.defaultJvmPlatform

    override val presentableText: String = "Android with Gradle"

@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.resolve.scopes.getDescriptorsFiltered
@@ -68,7 +68,7 @@ class AllClassesCompletion(private val parameters: CompletionParameters,
                    .forEach { classifierDescriptorCollector(it) }
        }

-        if (TargetPlatformDetector.getPlatform(parameters.originalFile as KtFile) == JvmPlatform) {
+        if (TargetPlatformDetector.getPlatform(parameters.originalFile as KtFile).isJvm()) {
            addAdaptedJavaCompletion(javaClassCollector)
        }
    }
@@ -60,7 +60,7 @@ import org.jetbrains.kotlin.psi.psiUtil.*
 import org.jetbrains.kotlin.renderer.render
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.descriptorUtil.*
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindExclude
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
@@ -270,7 +270,7 @@ class BasicCompletionSession(
                val packageNames = PackageIndexUtil.getSubPackageFqNames(FqName.ROOT, searchScope, project, prefixMatcher.asNameFilter())
                    .toMutableSet()

-                if (TargetPlatformDetector.getPlatform(parameters.originalFile as KtFile) == JvmPlatform) {
+                if (TargetPlatformDetector.getPlatform(parameters.originalFile as KtFile).isJvm()) {
                    JavaPsiFacade.getInstance(project).findPackage("")?.getSubPackages(searchScope)?.forEach { psiPackage ->
                        val name = psiPackage.name
                        if (Name.isValidIdentifier(name!!)) {
@@ -28,7 +28,6 @@ import com.intellij.patterns.PatternCondition
 import com.intellij.patterns.StandardPatterns
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.util.ProcessingContext
-import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.caches.project.ModuleOrigin
 import org.jetbrains.kotlin.idea.caches.project.OriginCapability
@@ -38,15 +37,13 @@ import org.jetbrains.kotlin.idea.codeInsight.ReferenceVariantsHelper
 import org.jetbrains.kotlin.idea.core.*
 import org.jetbrains.kotlin.idea.imports.importableFqName
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
-import org.jetbrains.kotlin.idea.project.languageVersionSettings
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.*
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.MultiTargetPlatform
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
-import org.jetbrains.kotlin.resolve.getMultiTargetPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.isCommon
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
 import org.jetbrains.kotlin.types.TypeUtils
@@ -88,7 +85,7 @@ abstract class CompletionSession(
    protected val resolutionFacade = file.getResolutionFacade()
    protected val moduleDescriptor = resolutionFacade.moduleDescriptor
    protected val project = position.project
-    protected val isJvmModule = TargetPlatformDetector.getPlatform(parameters.originalFile as KtFile) == JvmPlatform
+    protected val isJvmModule = TargetPlatformDetector.getPlatform(parameters.originalFile as KtFile).isJvm()
    protected val isDebuggerContext = file is KtCodeFragment

    protected val nameExpression: KtSimpleNameExpression?
@@ -149,7 +146,7 @@ abstract class CompletionSession(
            { CompletionBenchmarkSink.instance.onFlush(this) },
            prefixMatcher, parameters, resultSet,
            createSorter(), (file as? KtCodeFragment)?.extraCompletionFilter,
-            moduleDescriptor.getMultiTargetPlatform() === MultiTargetPlatform.Common
+            moduleDescriptor.platform.isCommon()
        )
    }

@@ -7,10 +7,10 @@ package org.jetbrains.kotlin.idea.completion.test

 import com.intellij.codeInsight.completion.CompletionType
 import org.jetbrains.kotlin.idea.test.SdkAndMockLibraryProjectDescriptor
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms

 abstract class AbstractCompiledKotlinInJavaCompletionTest : KotlinFixtureCompletionBaseTestCase() {
-    override fun getPlatform() = JvmPlatform
+    override fun getPlatform() = JvmPlatforms.defaultJvmPlatform

    override fun getProjectDescriptor() =
        SdkAndMockLibraryProjectDescriptor(COMPLETION_TEST_DATA_BASE_PATH + "/injava/mockLib", false)
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.idea.completion.CompletionBindingContextProvider
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import java.io.File
@@ -82,7 +82,7 @@ abstract class AbstractCompletionIncrementalResolveTest : KotlinLightCodeInsight
            }

            testCompletion(FileUtil.loadFile(file, true),
-                           JvmPlatform,
+                           JvmPlatforms.defaultJvmPlatform,
                           { completionType, count -> myFixture.complete(completionType, count) },
                           additionalValidDirectives = listOf(TYPE_DIRECTIVE_PREFIX, BACKSPACES_DIRECTIVE_PREFIX))

@@ -9,8 +9,8 @@ import com.intellij.codeInsight.completion.CompletionType;
 import com.intellij.testFramework.LightProjectDescriptor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.test.KotlinStdJSProjectDescriptor;
-import org.jetbrains.kotlin.js.resolve.JsPlatform;
-import org.jetbrains.kotlin.resolve.TargetPlatform;
+import org.jetbrains.kotlin.platform.TargetPlatform;
+import org.jetbrains.kotlin.platform.js.JsPlatforms;

 public abstract class AbstractJSBasicCompletionTest extends KotlinFixtureCompletionBaseTestCase {
    @NotNull
@@ -22,7 +22,7 @@ public abstract class AbstractJSBasicCompletionTest extends KotlinFixtureComplet
    @NotNull
    @Override
    public TargetPlatform getPlatform() {
-        return JsPlatform.INSTANCE;
+        return JsPlatforms.INSTANCE.getDefaultJsPlatform();
    }

    @NotNull
@@ -9,8 +9,8 @@ import com.intellij.codeInsight.completion.CompletionType;
 import com.intellij.testFramework.LightProjectDescriptor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor;
-import org.jetbrains.kotlin.resolve.TargetPlatform;
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
+import org.jetbrains.kotlin.platform.TargetPlatform;
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms;

 public abstract class AbstractJvmBasicCompletionTest extends KotlinFixtureCompletionBaseTestCase {
    @NotNull
@@ -22,7 +22,7 @@ public abstract class AbstractJvmBasicCompletionTest extends KotlinFixtureComple
    @NotNull
    @Override
    public TargetPlatform getPlatform() {
-        return JvmPlatform.INSTANCE;
+        return JvmPlatforms.INSTANCE.getDefaultJvmPlatform();
    }

    @NotNull
@@ -9,8 +9,8 @@ import com.intellij.codeInsight.completion.CompletionType;
 import com.intellij.testFramework.LightProjectDescriptor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor;
-import org.jetbrains.kotlin.resolve.TargetPlatform;
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
+import org.jetbrains.kotlin.platform.TargetPlatform;
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms;

 public abstract class AbstractJvmSmartCompletionTest extends KotlinFixtureCompletionBaseTestCase {
    @NotNull
@@ -22,7 +22,7 @@ public abstract class AbstractJvmSmartCompletionTest extends KotlinFixtureComple
    @NotNull
    @Override
    public TargetPlatform getPlatform() {
-        return JvmPlatform.INSTANCE;
+        return JvmPlatforms.INSTANCE.getDefaultJvmPlatform();
    }

    @NotNull
@@ -9,7 +9,7 @@ import com.intellij.codeInsight.completion.CompletionType
 import com.intellij.testFramework.LightProjectDescriptor
 import org.jetbrains.kotlin.idea.test.SdkAndMockLibraryProjectDescriptor
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms

 abstract class AbstractJvmWithLibBasicCompletionTest : KotlinFixtureCompletionBaseTestCase() {
    private val TEST_PATH = COMPLETION_TEST_DATA_BASE_PATH + "/basic/withLib"
@@ -21,6 +21,6 @@ abstract class AbstractJvmWithLibBasicCompletionTest : KotlinFixtureCompletionBa
        return SdkAndMockLibraryProjectDescriptor(TEST_PATH + "/" + getTestName(false) + "Src", false)
    }

-    override fun getPlatform() = JvmPlatform
+    override fun getPlatform() = JvmPlatforms.defaultJvmPlatform
    override fun defaultCompletionType() = CompletionType.BASIC
 }
@@ -10,10 +10,10 @@ import com.intellij.codeInsight.lookup.LookupElement
 import org.jetbrains.kotlin.idea.completion.KeywordLookupObject
 import org.jetbrains.kotlin.idea.test.KotlinLightProjectDescriptor
 import org.jetbrains.kotlin.idea.test.KotlinProjectDescriptorWithFacet
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms

 abstract class AbstractKeywordCompletionTest : KotlinFixtureCompletionBaseTestCase() {
-    override fun getPlatform() = JvmPlatform
+    override fun getPlatform() = JvmPlatforms.defaultJvmPlatform

    override fun defaultCompletionType() = CompletionType.BASIC

@@ -7,14 +7,12 @@ package org.jetbrains.kotlin.idea.completion.test

 import com.intellij.codeInsight.completion.CompletionType
 import com.intellij.openapi.util.io.FileUtil
-import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
-import org.apache.commons.io.FileUtils
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import java.io.File

 abstract class AbstractKotlinSourceInJavaCompletionTest : KotlinFixtureCompletionBaseTestCase() {
-    override fun getPlatform() = JvmPlatform
+    override fun getPlatform() = JvmPlatforms.defaultJvmPlatform

    override fun doTest(testPath: String) {
        val mockPath = RELATIVE_COMPLETION_TEST_DATA_BASE_PATH + "/injava/mockLib"
@@ -7,10 +7,10 @@ package org.jetbrains.kotlin.idea.completion.test

 import com.intellij.codeInsight.completion.CompletionType
 import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms

 abstract class AbstractKotlinStdLibInJavaCompletionTest : KotlinFixtureCompletionBaseTestCase() {
-    override fun getPlatform() = JvmPlatform
+    override fun getPlatform() = JvmPlatforms.defaultJvmPlatform
    override fun getProjectDescriptor() = KotlinWithJdkAndRuntimeLightProjectDescriptor.INSTANCE
    override fun defaultCompletionType() = CompletionType.BASIC
 }
@@ -7,14 +7,14 @@ package org.jetbrains.kotlin.idea.completion.test

 import com.intellij.codeInsight.completion.CompletionType
 import org.jetbrains.kotlin.idea.test.AstAccessControl
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms

 abstract class AbstractMultiFileJvmBasicCompletionTest : KotlinCompletionTestCase() {
    protected fun doTest(testPath: String) {
        configureByFile(getTestName(false) + ".kt", "")
        val shouldFail = testPath.contains("NoSpecifiedType")
        AstAccessControl.testWithControlledAccessToAst(shouldFail, getFile().getVirtualFile(), getProject(), getTestRootDisposable(), {
-            testCompletion(file.text, JvmPlatform, { completionType, invocationCount ->
+            testCompletion(file.text, JvmPlatforms.defaultJvmPlatform, { completionType, invocationCount ->
                setType(completionType)
                complete(invocationCount)
                myItems
@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.idea.completion.test

 import com.intellij.codeInsight.completion.CompletionType
 import org.jetbrains.kotlin.idea.test.AstAccessControl
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms

 abstract class AbstractMultiFileSmartCompletionTest : KotlinCompletionTestCase() {
    override fun setUp() {
@@ -18,7 +18,7 @@ abstract class AbstractMultiFileSmartCompletionTest : KotlinCompletionTestCase()
    protected fun doTest(testPath: String) {
        configureByFile(getTestName(false) + ".kt", "")
        AstAccessControl.testWithControlledAccessToAst(false, getFile().getVirtualFile(), getProject(), getTestRootDisposable(), {
-            testCompletion(file.text, JvmPlatform, { completionType, invocationCount ->
+            testCompletion(file.text, JvmPlatforms.defaultJvmPlatform, { completionType, invocationCount ->
                setType(completionType)
                complete(invocationCount)
                myItems
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test
 import com.intellij.codeInsight.CodeInsightSettings
 import com.intellij.codeInsight.completion.CompletionType
 import com.intellij.codeInsight.lookup.LookupElement
-import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.junit.Assert

@@ -17,12 +17,12 @@ val RELATIVE_COMPLETION_TEST_DATA_BASE_PATH = "idea/idea-completion/testData"
 val COMPLETION_TEST_DATA_BASE_PATH = KotlinTestUtils.getHomeDirectory() + "/" + RELATIVE_COMPLETION_TEST_DATA_BASE_PATH

 fun testCompletion(
-        fileText: String,
-        platform: TargetPlatform?,
-        complete: (CompletionType, Int) -> Array<LookupElement>?,
-        defaultCompletionType: CompletionType = CompletionType.BASIC,
-        defaultInvocationCount: Int = 0,
-        additionalValidDirectives: Collection<String> = emptyList()
+    fileText: String,
+    platform: TargetPlatform?,
+    complete: (CompletionType, Int) -> Array<LookupElement>?,
+    defaultCompletionType: CompletionType = CompletionType.BASIC,
+    defaultInvocationCount: Int = 0,
+    additionalValidDirectives: Collection<String> = emptyList()
 ) {
    testWithAutoCompleteSetting(fileText) {
        val completionType = ExpectedCompletionUtils.getCompletionType(fileText) ?: defaultCompletionType
@@ -19,9 +19,11 @@ import org.jetbrains.kotlin.idea.completion.LookupElementFactory
 import org.jetbrains.kotlin.idea.core.completion.DeclarationLookupObject
 import org.jetbrains.kotlin.idea.test.AstAccessControl
 import org.jetbrains.kotlin.idea.util.module
-import org.jetbrains.kotlin.js.resolve.JsPlatform
-import org.jetbrains.kotlin.resolve.TargetPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.js.JsPlatforms
+import org.jetbrains.kotlin.platform.js.isJs
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.junit.Assert
 import java.util.*
@@ -87,7 +89,7 @@ object ExpectedCompletionUtils {
        }
    }

-    private val UNSUPPORTED_PLATFORM_MESSAGE = "Only $JvmPlatform and $JsPlatform platforms are supported"
+    private val UNSUPPORTED_PLATFORM_MESSAGE = "Only ${JvmPlatforms.defaultJvmPlatform} and ${JsPlatforms.defaultJsPlatform} platforms are supported"

    private val EXIST_LINE_PREFIX = "EXIST:"

@@ -135,19 +137,19 @@ object ExpectedCompletionUtils {
            AstAccessControl.ALLOW_AST_ACCESS_DIRECTIVE)

    fun itemsShouldExist(fileText: String, platform: TargetPlatform?): Array<CompletionProposal> {
-        return when (platform) {
-            is JvmPlatform -> processProposalAssertions(fileText, EXIST_LINE_PREFIX, EXIST_JAVA_ONLY_LINE_PREFIX)
-            JsPlatform -> processProposalAssertions(fileText, EXIST_LINE_PREFIX, EXIST_JS_ONLY_LINE_PREFIX)
-            null -> processProposalAssertions(fileText, EXIST_LINE_PREFIX)
+        return when {
+            platform.isJvm() -> processProposalAssertions(fileText, EXIST_LINE_PREFIX, EXIST_JAVA_ONLY_LINE_PREFIX)
+            platform.isJs() -> processProposalAssertions(fileText, EXIST_LINE_PREFIX, EXIST_JS_ONLY_LINE_PREFIX)
+            platform == null -> processProposalAssertions(fileText, EXIST_LINE_PREFIX)
            else -> throw IllegalArgumentException(UNSUPPORTED_PLATFORM_MESSAGE)
        }
    }

    fun itemsShouldAbsent(fileText: String, platform: TargetPlatform?): Array<CompletionProposal> {
-        return when (platform) {
-            is JvmPlatform -> processProposalAssertions(fileText, ABSENT_LINE_PREFIX, ABSENT_JAVA_LINE_PREFIX, EXIST_JS_ONLY_LINE_PREFIX)
-            JsPlatform -> processProposalAssertions(fileText, ABSENT_LINE_PREFIX, ABSENT_JS_LINE_PREFIX, EXIST_JAVA_ONLY_LINE_PREFIX)
-            null -> processProposalAssertions(fileText, ABSENT_LINE_PREFIX)
+        return when {
+            platform.isJvm() -> processProposalAssertions(fileText, ABSENT_LINE_PREFIX, ABSENT_JAVA_LINE_PREFIX, EXIST_JS_ONLY_LINE_PREFIX)
+            platform.isJs() -> processProposalAssertions(fileText, ABSENT_LINE_PREFIX, ABSENT_JS_LINE_PREFIX, EXIST_JAVA_ONLY_LINE_PREFIX)
+            platform == null -> processProposalAssertions(fileText, ABSENT_LINE_PREFIX)
            else -> throw IllegalArgumentException(UNSUPPORTED_PLATFORM_MESSAGE)
        }
    }
@@ -179,10 +181,10 @@ object ExpectedCompletionUtils {
    }

    fun getExpectedNumber(fileText: String, platform: TargetPlatform?): Int? {
-        return when (platform) {
-            null -> InTextDirectivesUtils.getPrefixedInt(fileText, NUMBER_LINE_PREFIX)
-            is JvmPlatform -> getPlatformExpectedNumber(fileText, NUMBER_JAVA_LINE_PREFIX)
-            JsPlatform -> getPlatformExpectedNumber(fileText, NUMBER_JS_LINE_PREFIX)
+        return when {
+            platform == null -> InTextDirectivesUtils.getPrefixedInt(fileText, NUMBER_LINE_PREFIX)
+            platform.isJvm() -> getPlatformExpectedNumber(fileText, NUMBER_JAVA_LINE_PREFIX)
+            platform.isJs() -> getPlatformExpectedNumber(fileText, NUMBER_JS_LINE_PREFIX)
            else -> throw IllegalArgumentException(UNSUPPORTED_PLATFORM_MESSAGE)
        }
    }
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.idea.test.CompilerTestDirectives
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.configureCompilerOptions
 import org.jetbrains.kotlin.idea.test.rollbackCompilerOptions
-import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
 import java.io.File

 abstract class KotlinFixtureCompletionBaseTestCase : KotlinLightCodeInsightFixtureTestCase() {
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.ide.konan.hasKotlinNativeRuntimeInScope
 import org.jetbrains.kotlin.idea.configuration.ConfigureKotlinStatus
 import org.jetbrains.kotlin.idea.configuration.KotlinWithGradleConfigurator
 import org.jetbrains.kotlin.idea.configuration.ModuleSourceRootGroup
-import org.jetbrains.kotlin.resolve.konan.platform.KonanPlatform
+import org.jetbrains.kotlin.platform.konan.KonanPlatforms

 open class KotlinNativeGradleConfigurator : KotlinWithGradleConfigurator() {
    override fun getKotlinPluginExpression(forKotlinDsl: Boolean): String = ""
@@ -28,7 +28,7 @@ open class KotlinNativeGradleConfigurator : KotlinWithGradleConfigurator() {

    override val name: String get() = NAME

-    override val targetPlatform get() = KonanPlatform
+    override val targetPlatform get() = KonanPlatforms.defaultKonanPlatform

    override val presentableText get() = PRESENTABLE_TEXT

@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.idea.project.platform
 import org.jetbrains.kotlin.idea.util.projectStructure.allModules
 import org.jetbrains.kotlin.konan.library.konanCommonLibraryPath
 import org.jetbrains.kotlin.konan.library.konanPlatformLibraryPath
-import org.jetbrains.kotlin.platform.impl.isKotlinNative
+import org.jetbrains.kotlin.platform.konan.isNative
 import org.jetbrains.plugins.gradle.util.GradleConstants
 import org.junit.Assert.*
 import org.junit.Test
@@ -111,7 +111,7 @@ private fun assertValidModule(module: Module, projectRoot: String) {
        detectLibraryKind(library.getFiles(OrderRootType.CLASSES)) == NativeLibraryKind
    }

-    if (module.platform.isKotlinNative) {
+    if (module.platform.isNative()) {
        assertFalse("No Kotlin/Native libraries in $module", nativeLibraries.isEmpty())
        nativeLibraries.forEach { assertValidNativeLibrary(it, projectRoot) }

@@ -16,14 +16,13 @@

 package org.jetbrains.kotlin.idea.configuration

-import com.intellij.facet.FacetManager
 import com.intellij.openapi.module.Module
 import com.intellij.openapi.projectRoots.Sdk
 import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.idea.core.isAndroidModule
 import org.jetbrains.kotlin.idea.versions.getDefaultJvmTarget
-import org.jetbrains.kotlin.resolve.TargetPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms

 class KotlinGradleModuleConfigurator : KotlinWithGradleConfigurator() {

@@ -31,7 +30,7 @@ class KotlinGradleModuleConfigurator : KotlinWithGradleConfigurator() {
        get() = NAME

    override val targetPlatform: TargetPlatform
-        get() = JvmPlatform
+        get() = JvmPlatforms.defaultJvmPlatform

    override val presentableText: String
        get() = "Java with Gradle"
@@ -20,13 +20,13 @@ import com.intellij.openapi.projectRoots.Sdk
 import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.idea.util.module
 import org.jetbrains.kotlin.idea.versions.MAVEN_JS_STDLIB_ID
-import org.jetbrains.kotlin.js.resolve.JsPlatform
-import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.js.JsPlatforms

 class KotlinJsGradleModuleConfigurator : KotlinWithGradleConfigurator() {
    override val name: String = "gradle-js"
    override val presentableText: String = "JavaScript with Gradle"
-    override val targetPlatform: TargetPlatform = JsPlatform
+    override val targetPlatform: TargetPlatform = JsPlatforms.defaultJsPlatform
    override val kotlinPluginName: String = KOTLIN_JS
    override fun getKotlinPluginExpression(forKotlinDsl: Boolean): String =
        if (forKotlinDsl) "id(\"kotlin2js\")" else "id 'kotlin2js'"
@@ -47,12 +47,12 @@ import org.jetbrains.kotlin.idea.framework.KotlinSdkType
 import org.jetbrains.kotlin.idea.project.languageVersionSettings
 import org.jetbrains.kotlin.idea.util.projectStructure.allModules
 import org.jetbrains.kotlin.idea.util.projectStructure.sdk
-import org.jetbrains.kotlin.js.resolve.JsPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.platform.impl.JvmIdePlatformKind
 import org.jetbrains.kotlin.platform.impl.isCommon
 import org.jetbrains.kotlin.platform.impl.isJavaScript
-import org.jetbrains.kotlin.resolve.TargetPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.js.JsPlatforms
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.junit.Assert
 import org.junit.Ignore
@@ -933,9 +933,9 @@ class GradleFacetImportTest : GradleImportingTestCase() {
        configureByFiles()
        importProject()

-        checkStableModuleName("project_main", "project", JsPlatform, isProduction = true)
+        checkStableModuleName("project_main", "project", JsPlatforms.defaultJsPlatform, isProduction = true)
        // Note "_test" suffix: this is current behavior of K2JS Compiler
-        checkStableModuleName("project_test", "project_test", JsPlatform, isProduction = false)
+        checkStableModuleName("project_test", "project_test", JsPlatforms.defaultJsPlatform, isProduction = false)

        assertAllModulesConfigured()
    }
@@ -945,8 +945,8 @@ class GradleFacetImportTest : GradleImportingTestCase() {
        configureByFiles()
        importProject()

-        checkStableModuleName("project_main", "project", JvmPlatform, isProduction = true)
-        checkStableModuleName("project_test", "project", JvmPlatform, isProduction = false)
+        checkStableModuleName("project_main", "project", JvmPlatforms.defaultJvmPlatform, isProduction = true)
+        checkStableModuleName("project_test", "project", JvmPlatforms.defaultJvmPlatform, isProduction = false)

        assertAllModulesConfigured()
    }
@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.cli.common.arguments.copyBean
 import org.jetbrains.kotlin.cli.common.arguments.parseCommandLineArguments
 import org.jetbrains.kotlin.platform.IdePlatform
 import org.jetbrains.kotlin.platform.IdePlatformKind
+import org.jetbrains.kotlin.platform.TargetPlatformVersion
 import org.jetbrains.kotlin.utils.DescriptionAware

@Deprecated("Use IdePlatformKind instead.", level = DeprecationLevel.ERROR)
@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.platform
 import com.intellij.openapi.components.ServiceManager
 import org.jetbrains.kotlin.config.isJps
 import org.jetbrains.kotlin.platform.impl.JvmIdePlatformKind
-import org.jetbrains.kotlin.resolve.TargetPlatform

 interface DefaultIdeTargetPlatformKindProvider {
    val defaultPlatform: IdePlatform<*, *>
@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.platform

 import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
-import org.jetbrains.kotlin.config.TargetPlatformVersion
 import org.jetbrains.kotlin.utils.DescriptionAware

 abstract class IdePlatform<Kind : IdePlatformKind<Kind>, out Arguments : CommonCompilerArguments> : DescriptionAware {
@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.platform.impl.CommonIdePlatformKind
 import org.jetbrains.kotlin.platform.impl.JsIdePlatformKind
 import org.jetbrains.kotlin.platform.impl.JvmIdePlatformKind
 import org.jetbrains.kotlin.platform.impl.NativeIdePlatformKind
-import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult

 abstract class IdePlatformKind<Kind : IdePlatformKind<Kind>> {
@@ -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.CommonPlatforms
 import org.jetbrains.kotlin.platform.IdePlatform
 import org.jetbrains.kotlin.platform.IdePlatformKind
+import org.jetbrains.kotlin.platform.TargetPlatformVersion

 object CommonIdePlatformKind : IdePlatformKind<CommonIdePlatformKind>() {

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

-    override val compilerPlatform get() = CommonPlatform
+    override val compilerPlatform get() = CommonPlatforms.defaultCommonPlatform

    override val platforms get() = listOf(Platform)
    override val defaultPlatform get() = Platform
@@ -8,10 +8,10 @@ package org.jetbrains.kotlin.platform.impl

 import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments
-import org.jetbrains.kotlin.config.TargetPlatformVersion
-import org.jetbrains.kotlin.js.resolve.JsPlatform
+import org.jetbrains.kotlin.platform.TargetPlatformVersion
 import org.jetbrains.kotlin.platform.IdePlatform
 import org.jetbrains.kotlin.platform.IdePlatformKind
+import org.jetbrains.kotlin.platform.js.JsPlatforms

 object JsIdePlatformKind : IdePlatformKind<JsIdePlatformKind>() {

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

-    override val compilerPlatform get() = JsPlatform
+    override val compilerPlatform get() = JsPlatforms.defaultJsPlatform

    override val platforms get() = listOf(Platform)
    override val defaultPlatform get() = Platform
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
 import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.platform.IdePlatform
 import org.jetbrains.kotlin.platform.IdePlatformKind
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms

 object JvmIdePlatformKind : IdePlatformKind<JvmIdePlatformKind>() {

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

-    override val compilerPlatform get() = JvmPlatform
+    override val compilerPlatform get() = JvmPlatforms.defaultJvmPlatform

    override val platforms = JvmTarget.values().map { ver -> Platform(ver) }
    override val defaultPlatform get() = Platform(JvmTarget.DEFAULT)
@@ -7,10 +7,10 @@
 package org.jetbrains.kotlin.platform.impl

 import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
-import org.jetbrains.kotlin.config.TargetPlatformVersion
+import org.jetbrains.kotlin.platform.TargetPlatformVersion
 import org.jetbrains.kotlin.platform.IdePlatform
 import org.jetbrains.kotlin.platform.IdePlatformKind
-import org.jetbrains.kotlin.resolve.konan.platform.KonanPlatform
+import org.jetbrains.kotlin.platform.konan.KonanPlatforms

 object NativeIdePlatformKind : IdePlatformKind<NativeIdePlatformKind>() {

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

-    override val compilerPlatform get() = KonanPlatform
+    override val compilerPlatform get() = KonanPlatforms.defaultKonanPlatform

    override val platforms get() = listOf(Platform)
    override val defaultPlatform get() = Platform
@@ -12,8 +12,8 @@ import com.intellij.openapi.ui.Messages
 import com.intellij.util.PlatformUtils
 import org.jetbrains.kotlin.idea.configuration.*
 import org.jetbrains.kotlin.idea.util.projectStructure.allModules
-import org.jetbrains.kotlin.js.resolve.JsPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.js.isJs
+import org.jetbrains.kotlin.platform.jvm.isJvm

 abstract class ConfigureKotlinInProjectAction : AnAction() {

@@ -44,7 +44,7 @@ abstract class ConfigureKotlinInProjectAction : AnAction() {

 class ConfigureKotlinJsInProjectAction: ConfigureKotlinInProjectAction() {
    override fun getApplicableConfigurators(project: Project) = getAbleToRunConfigurators(project).filter {
-        it.targetPlatform == JsPlatform
+        it.targetPlatform.isJs()
    }

    override fun update(e: AnActionEvent) {
@@ -57,6 +57,6 @@ class ConfigureKotlinJsInProjectAction: ConfigureKotlinInProjectAction() {

 class ConfigureKotlinJavaInProjectAction: ConfigureKotlinInProjectAction() {
    override fun getApplicableConfigurators(project: Project) = getAbleToRunConfigurators(project).filter {
-        it.targetPlatform is JvmPlatform
+        it.targetPlatform.isJvm()
    }
 }
@@ -40,8 +40,8 @@ import org.jetbrains.kotlin.idea.util.projectStructure.sdk
 import org.jetbrains.kotlin.idea.util.projectStructure.version
 import org.jetbrains.kotlin.idea.versions.LibraryJarDescriptor
 import org.jetbrains.kotlin.platform.impl.JvmIdePlatformKind
-import org.jetbrains.kotlin.resolve.TargetPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms

 open class KotlinJavaModuleConfigurator protected constructor() : KotlinWithLibraryConfigurator() {
    override fun isApplicable(module: Module): Boolean {
@@ -71,7 +71,7 @@ open class KotlinJavaModuleConfigurator protected constructor() : KotlinWithLibr
        get() = NAME

    override val targetPlatform: TargetPlatform
-        get() = JvmPlatform
+        get() = JvmPlatforms.defaultJvmPlatform

    override fun getLibraryJarDescriptors(sdk: Sdk?): List<LibraryJarDescriptor> {
        var result = listOf(
@@ -32,15 +32,15 @@ import org.jetbrains.kotlin.idea.framework.JsLibraryStdDetectionUtil
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.idea.versions.LibraryJarDescriptor
 import org.jetbrains.kotlin.js.JavaScript
-import org.jetbrains.kotlin.js.resolve.JsPlatform
-import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.js.JsPlatforms

 open class KotlinJsModuleConfigurator : KotlinWithLibraryConfigurator() {
    override val name: String
        get() = NAME

    override val targetPlatform: TargetPlatform
-        get() = JsPlatform
+        get() = JsPlatforms.defaultJsPlatform

    override val presentableText: String
        get() = JavaScript.FULL_NAME
@@ -24,7 +24,7 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.config.ApiVersion
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.idea.versions.LibraryJarDescriptor
-import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform

 enum class ConfigureKotlinStatus {
    /** Kotlin is correctly configured using this configurator. */
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.idea.versions.SuppressNotificationState
 import org.jetbrains.kotlin.idea.versions.UnsupportedAbiVersionNotificationPanelProvider
 import org.jetbrains.kotlin.idea.versions.createComponentActionLabel
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.isJvm

 // Code is partially copied from com.intellij.codeInsight.daemon.impl.SetupSDKNotificationProvider
 class KotlinSetupEnvironmentNotificationProvider(
@@ -68,7 +68,8 @@ class KotlinSetupEnvironmentNotificationProvider(
        }

        if (ModuleRootManager.getInstance(module).sdk == null &&
-            TargetPlatformDetector.getPlatform(psiFile) == JvmPlatform) {
+            TargetPlatformDetector.getPlatform(psiFile).isJvm()
+        ) {
            return createSetupSdkPanel(myProject, psiFile)
        }

@@ -5,7 +5,6 @@

 package org.jetbrains.kotlin.idea.debugger.evaluate

-import org.jetbrains.kotlin.analyzer.common.CommonPlatform
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
@@ -27,7 +26,8 @@ import org.jetbrains.kotlin.psi.KtCodeFragment
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.DescriptorFactory
 import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassNotAny
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.isCommon
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.SyntheticScope
 import org.jetbrains.kotlin.resolve.scopes.getDescriptorsFiltered
@@ -78,7 +78,7 @@ class DebuggerFieldSyntheticScope(val javaSyntheticPropertiesScope: JavaSyntheti
        val containingFile = element.containingFile?.takeIf { it.isValid } as? KtFile ?: return false

        val platform = containingFile.platform
-        if (platform !is JvmPlatform && platform !is CommonPlatform) {
+        if (!platform.isJvm() && !platform.isCommon()) {
            return false
        }

@@ -28,6 +28,8 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtCodeFragment
 import org.jetbrains.kotlin.psi.externalDescriptors
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.Variance
@@ -176,6 +178,9 @@ private object DebugLabelModuleDescriptor
        }
    }

+    override val platform: TargetPlatform?
+        get() = JvmPlatforms.defaultJvmPlatform
+
    override fun getSubPackagesOf(fqName: FqName, nameFilter: (Name) -> Boolean): Collection<FqName> {
        return emptyList()
    }
@@ -24,14 +24,14 @@ import com.intellij.openapi.projectRoots.SdkTypeId
 import com.intellij.openapi.roots.ModifiableRootModel
 import com.intellij.openapi.roots.ui.configuration.ModulesProvider
 import org.jetbrains.kotlin.idea.roots.migrateNonJvmSourceFolders
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.idea.statistics.FUSEventGroups
 import org.jetbrains.kotlin.idea.statistics.KotlinFUSLogger
-import org.jetbrains.kotlin.resolve.TargetPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import javax.swing.Icon

 class KotlinModuleBuilder(
-        val targetPlatform: TargetPlatform, val builderName: String, val builderDescription: String, val icon: Icon
+    val targetPlatform: TargetPlatform, val builderName: String, val builderDescription: String, val icon: Icon
 ) : JavaModuleBuilder() {
    private var wizardContext: WizardContext? = null

@@ -51,15 +51,15 @@ class KotlinModuleBuilder(
        return KotlinModuleSettingStep(targetPlatform, this, settingsStep, wizardContext)
    }

-    override fun isSuitableSdkType(sdkType: SdkTypeId?) = when (targetPlatform) {
-        is JvmPlatform -> super.isSuitableSdkType(sdkType)
+    override fun isSuitableSdkType(sdkType: SdkTypeId?) = when  {
+        targetPlatform.isJvm() -> super.isSuitableSdkType(sdkType)
        else -> sdkType is KotlinSdkType
    }

    override fun setupRootModel(rootModel: ModifiableRootModel) {
        KotlinFUSLogger.log(FUSEventGroups.NPWizards, this.javaClass.simpleName + ": ${this.targetPlatform}")
        super.setupRootModel(rootModel)
-        if (targetPlatform !is JvmPlatform) {
+        if (!targetPlatform.isJvm()) {
            migrateNonJvmSourceFolders(rootModel)
        }
    }
@@ -46,9 +46,10 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.formatter.KotlinStyleGuideCodeStyle;
 import org.jetbrains.kotlin.idea.formatter.ProjectCodeStyleImporter;
-import org.jetbrains.kotlin.js.resolve.JsPlatform;
-import org.jetbrains.kotlin.resolve.TargetPlatform;
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
+import org.jetbrains.kotlin.platform.TargetPlatform;
+import org.jetbrains.kotlin.platform.TargetPlatformKt;
+import org.jetbrains.kotlin.platform.js.JsPlatformKt;
+import org.jetbrains.kotlin.platform.jvm.JvmPlatformKt;

 import javax.swing.*;
 import java.lang.reflect.Field;
@@ -83,7 +84,7 @@ public class KotlinModuleSettingStep extends ModuleWizardStep {
    ) {
        isNewProject = wizardContext != null && wizardContext.isCreatingNewProject();

-        if (!(targetPlatform instanceof JvmPlatform)) {
+        if (!(JvmPlatformKt.isJvm(targetPlatform))) {
            KotlinSdkType.Companion.setUpIfNeeded();
        }

@@ -139,15 +140,15 @@ public class KotlinModuleSettingStep extends ModuleWizardStep {

    @NotNull
    protected String getLibraryLabelText() {
-        if (targetPlatform == JvmPlatform.INSTANCE) return "Kotlin runtime";
-        if (targetPlatform == JsPlatform.INSTANCE) return "Kotlin JS library";
+        if (JvmPlatformKt.isJvm(targetPlatform)) return "Kotlin runtime";
+        if (JsPlatformKt.isJs(targetPlatform)) return "Kotlin JS library";
        throw new IllegalStateException("Only JS and JVM target are supported");
    }

    @NotNull
    protected CustomLibraryDescription getCustomLibraryDescription(@Nullable Project project) {
-        if (targetPlatform == JvmPlatform.INSTANCE) return new JavaRuntimeLibraryDescription(project);
-        if (targetPlatform == JsPlatform.INSTANCE) return new JSLibraryStdDescription(project);
+        if (JvmPlatformKt.isJvm(targetPlatform)) return new JavaRuntimeLibraryDescription(project);
+        if (JsPlatformKt.isJs(targetPlatform)) return new JSLibraryStdDescription(project);
        throw new IllegalStateException("Only JS and JVM target are supported");
    }

@@ -24,8 +24,8 @@ import com.intellij.platform.ProjectTemplate
 import com.intellij.platform.ProjectTemplatesFactory
 import com.intellij.platform.templates.BuilderBasedTemplate
 import org.jetbrains.kotlin.idea.KotlinIcons
-import org.jetbrains.kotlin.js.resolve.JsPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.js.JsPlatforms
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms

 class KotlinTemplatesFactory : ProjectTemplatesFactory() {
    companion object {
@@ -39,15 +39,22 @@ class KotlinTemplatesFactory : ProjectTemplatesFactory() {

    override fun createTemplates(group: String?, context: WizardContext?): Array<out ProjectTemplate> {
        val result = mutableListOf<ProjectTemplate>(
-                BuilderBasedTemplate(KotlinModuleBuilder(JvmPlatform,
-                                                         "JVM | IDEA",
-                                                         "Kotlin project with a JVM target based on the IntelliJ IDEA build system",
-                                                         KotlinIcons.SMALL_LOGO)),
-
-                BuilderBasedTemplate(KotlinModuleBuilder(JsPlatform, "JS | IDEA",
-                                                         "Kotlin project with a JavaScript target based on the IntelliJ IDEA build system",
-                                                         KotlinIcons.JS)
+            BuilderBasedTemplate(
+                KotlinModuleBuilder(
+                    JvmPlatforms.defaultJvmPlatform,
+                    "JVM | IDEA",
+                    "Kotlin project with a JVM target based on the IntelliJ IDEA build system",
+                    KotlinIcons.SMALL_LOGO
                )
+            ),
+
+            BuilderBasedTemplate(
+                KotlinModuleBuilder(
+                    JsPlatforms.defaultJsPlatform, "JS | IDEA",
+                    "Kotlin project with a JavaScript target based on the IntelliJ IDEA build system",
+                    KotlinIcons.JS
+                )
+            )
        )
        result.addAll(Extensions.getExtensions(EP_NAME).map { BuilderBasedTemplate(it) })
        return result.toTypedArray()
@@ -21,7 +21,6 @@ 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.common.phaser.PhaseConfig
 import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
 import org.jetbrains.kotlin.backend.jvm.jvmPhases
@@ -43,7 +42,10 @@ import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtCodeFragment
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtScript
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.config.JvmTarget
+import org.jetbrains.kotlin.platform.isCommon
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.utils.join
 import java.awt.BorderLayout
 import java.awt.FlowLayout
@@ -281,10 +283,10 @@ class KotlinBytecodeToolWindow(private val myProject: Project, private val toolW
            configuration: CompilerConfiguration
        ): GenerationState? {
            val platform = ktFile.platform
-            if (platform !is CommonPlatform && platform !is JvmPlatform) return null
+            if (!platform.isCommon() && !platform.isJvm()) return null

            val resolutionFacade = KotlinCacheService.getInstance(ktFile.project)
-                .getResolutionFacadeByFile(ktFile, JvmPlatform)
+                .getResolutionFacadeByFile(ktFile, JvmPlatforms.defaultJvmPlatform)
                    ?: return null

            val bindingContextForFile = resolutionFacade.analyzeWithAllCompilerChecks(listOf(ktFile)).bindingContext
@@ -41,7 +41,7 @@ import org.jetbrains.kotlin.asJava.LightClassUtilsKt;
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector;
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
+import org.jetbrains.kotlin.platform.jvm.JvmPlatformKt;

 import java.util.List;

@@ -116,7 +116,7 @@ public class KotlinTestNgConfigurationProducer extends TestNGConfigurationProduc

        KtFile ktFile = (KtFile) leaf.getContainingFile();

-        if (TargetPlatformDetector.getPlatform(ktFile) != JvmPlatform.INSTANCE) {
+        if (!JvmPlatformKt.isJvm(TargetPlatformDetector.getPlatform(ktFile))) {
            return false;
        }

@@ -37,9 +37,9 @@ import org.jetbrains.kotlin.idea.KotlinPluginUpdater
 import org.jetbrains.kotlin.idea.KotlinPluginUtil
 import org.jetbrains.kotlin.idea.PluginUpdateStatus
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
-import org.jetbrains.kotlin.js.resolve.JsPlatform
 import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.js.isJs
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import java.awt.event.ComponentAdapter
 import java.awt.event.ComponentEvent
 import java.text.MessageFormat
@@ -325,9 +325,10 @@ class UnsupportedAbiVersionNotificationPanelProvider(private val project: Projec
        }

        fun collectBadRoots(module: Module): Collection<BinaryVersionedFile<BinaryVersion>> {
-            val badRoots = when (TargetPlatformDetector.getPlatform(module)) {
-                JvmPlatform -> getLibraryRootsWithAbiIncompatibleKotlinClasses(module)
-                JsPlatform -> getLibraryRootsWithAbiIncompatibleForKotlinJs(module)
+            val platform = TargetPlatformDetector.getPlatform(module)
+            val badRoots = when {
+                platform.isJvm() -> getLibraryRootsWithAbiIncompatibleKotlinClasses(module)
+                platform.isJs() -> getLibraryRootsWithAbiIncompatibleForKotlinJs(module)
                else -> return emptyList()
            }

@@ -26,8 +26,8 @@ import org.jetbrains.kotlin.idea.configuration.hasKotlinJvmRuntimeInScope
 import org.jetbrains.kotlin.idea.maven.PomFile
 import org.jetbrains.kotlin.idea.versions.getDefaultJvmTarget
 import org.jetbrains.kotlin.idea.versions.getStdlibArtifactId
-import org.jetbrains.kotlin.resolve.TargetPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms

 class KotlinJavaMavenConfigurator : KotlinMavenConfigurator(
    KotlinJavaMavenConfigurator.TEST_LIB_ID,
@@ -68,7 +68,7 @@ class KotlinJavaMavenConfigurator : KotlinMavenConfigurator(
    }

    override val targetPlatform: TargetPlatform
-        get() = JvmPlatform
+        get() = JvmPlatforms.defaultJvmPlatform

    companion object {
        private const val NAME = "maven"
@@ -21,8 +21,8 @@ import org.jetbrains.idea.maven.dom.model.MavenDomPlugin
 import org.jetbrains.kotlin.idea.configuration.hasKotlinJsRuntimeInScope
 import org.jetbrains.kotlin.idea.maven.PomFile
 import org.jetbrains.kotlin.idea.versions.MAVEN_JS_STDLIB_ID
-import org.jetbrains.kotlin.js.resolve.JsPlatform
-import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.js.JsPlatforms

 class KotlinJavascriptMavenConfigurator :
    KotlinMavenConfigurator(null, false, KotlinJavascriptMavenConfigurator.NAME, KotlinJavascriptMavenConfigurator.PRESENTABLE_TEXT) {
@@ -43,7 +43,7 @@ class KotlinJavascriptMavenConfigurator :
    }

    override val targetPlatform: TargetPlatform
-        get() = JsPlatform
+        get() = JsPlatforms.defaultJsPlatform

    override fun getMinimumSupportedVersion() = "1.1.0"

@@ -46,13 +46,13 @@ import org.jetbrains.kotlin.idea.framework.JSLibraryKind
 import org.jetbrains.kotlin.idea.framework.KotlinSdkType
 import org.jetbrains.kotlin.idea.project.languageVersionSettings
 import org.jetbrains.kotlin.idea.refactoring.toPsiFile
-import org.jetbrains.kotlin.js.resolve.JsPlatform
 import org.jetbrains.kotlin.platform.impl.*
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.TargetPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.test.JUnit3RunnerWithInners
 import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.js.JsPlatforms
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.junit.Assert
 import org.junit.runner.RunWith
 import java.io.File
@@ -2970,8 +2970,8 @@ class KotlinMavenImporterTest : MavenImportingTestCase() {

        assertImporterStatePresent()

-        checkStableModuleName("project", "project", JvmPlatform, isProduction = true)
-        checkStableModuleName("project", "project", JvmPlatform, isProduction = false)
+        checkStableModuleName("project", "project", JvmPlatforms.defaultJvmPlatform, isProduction = true)
+        checkStableModuleName("project", "project", JvmPlatforms.defaultJvmPlatform, isProduction = false)
    }

    fun testStableModuleNameWhileUsngMaven_JS() {
@@ -3031,8 +3031,8 @@ class KotlinMavenImporterTest : MavenImportingTestCase() {

        // Note that we check name induced by '-output-file' -- may be it's not the best
        // decision, but we don't have a better one
-        checkStableModuleName("project", "test", JsPlatform, isProduction = true)
-        checkStableModuleName("project", "test", JsPlatform, isProduction = false)
+        checkStableModuleName("project", "test", JsPlatforms.defaultJsPlatform, isProduction = true)
+        checkStableModuleName("project", "test", JsPlatforms.defaultJsPlatform, isProduction = false)
    }

    private fun checkStableModuleName(projectName: String, expectedName: String, platform: TargetPlatform, isProduction: Boolean) {
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.idea.platform.IdePlatformKindTooling
 import org.jetbrains.kotlin.platform.impl.NativeIdePlatformKind
 import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.psi.KtNamedDeclaration
-import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
 import javax.swing.Icon

 class NativeIdePlatformKindTooling : IdePlatformKindTooling() {
@@ -29,11 +29,10 @@ import org.jetbrains.kotlin.idea.compiler.IDELanguageSettingsProvider
 import org.jetbrains.kotlin.konan.file.File
 import org.jetbrains.kotlin.konan.library.*
 import org.jetbrains.kotlin.konan.util.KonanFactories
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.platform.impl.NativeIdePlatformKind
-import org.jetbrains.kotlin.resolve.CompilerDeserializationConfiguration
-import org.jetbrains.kotlin.resolve.ImplicitIntegerCoercion
-import org.jetbrains.kotlin.resolve.TargetPlatform
-import org.jetbrains.kotlin.resolve.konan.platform.KonanPlatform
+import org.jetbrains.kotlin.platform.konan.KonanPlatforms
+import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult

 class NativePlatformKindResolution : IdePlatformKindResolution {
@@ -122,7 +121,7 @@ private fun createKotlinNativeBuiltIns(settings: PlatformAnalysisSettings, proje
 }

 // TODO: It depends on a random module's stdlib, propagate the actual module here.
-private fun findNativeStdlib(project: Project): NativeLibraryInfo? = getModuleInfosFromIdeaModel(project, KonanPlatform)
+private fun findNativeStdlib(project: Project): NativeLibraryInfo? = getModuleInfosFromIdeaModel(project, KonanPlatforms.defaultKonanPlatform)
    .firstNotNullResult { it.asNativeStdlib() }

 private fun IdeaModuleInfo.asNativeStdlib(): NativeLibraryInfo? = if ((this as? NativeLibraryInfo)?.isStdlib == true) this else null
@@ -149,7 +148,7 @@ class NativeLibraryInfo(project: Project, library: Library, root: File) : Librar
                )

    override val platform: TargetPlatform
-        get() = KonanPlatform
+        get() = KonanPlatforms.defaultKonanPlatform

    override fun toString() = "Native" + super.toString()

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.ide.konan.analyzer

 import org.jetbrains.kotlin.analyzer.*
 import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.config.TargetPlatformVersion
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
@@ -15,10 +14,9 @@ import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.frontend.di.createContainerForLazyResolve
 import org.jetbrains.kotlin.ide.konan.NativeLibraryInfo
 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.TargetPlatform
-import org.jetbrains.kotlin.resolve.konan.platform.KonanPlatform
 import org.jetbrains.kotlin.resolve.konan.platform.NativePlatformCompilerServices
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService.Companion.createDeclarationProviderFactory
@@ -31,8 +29,7 @@ object NativeResolverForModuleFactory : ResolverForModuleFactory() {
        platformParameters: PlatformAnalysisParameters,
        targetEnvironment: TargetEnvironment,
        resolverForProject: ResolverForProject<M>,
-        languageVersionSettings: LanguageVersionSettings,
-        targetPlatformVersion: TargetPlatformVersion
+        languageVersionSettings: LanguageVersionSettings
    ): ResolverForModule {

        val declarationProviderFactory = createDeclarationProviderFactory(
@@ -47,8 +44,7 @@ object NativeResolverForModuleFactory : ResolverForModuleFactory() {
            moduleContext,
            declarationProviderFactory,
            CodeAnalyzerInitializer.getInstance(moduleContext.project).createTrace(),
-            KonanPlatform,
-            TargetPlatformVersion.NoVersion,
+            KonanPlatforms.defaultKonanPlatform,
            NativePlatformCompilerServices,
            targetEnvironment,
            languageVersionSettings
@@ -23,7 +23,6 @@ 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
@@ -39,12 +38,13 @@ import org.jetbrains.kotlin.idea.project.languageVersionSettings
 import org.jetbrains.kotlin.idea.project.platform
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
-import org.jetbrains.kotlin.js.resolve.JsPlatform
+import org.jetbrains.kotlin.platform.isCommon
+import org.jetbrains.kotlin.platform.js.isJs
 import org.jetbrains.kotlin.psi.*
 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.*
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassOrAny
 import org.jetbrains.kotlin.resolve.source.getPsi
@@ -131,9 +131,9 @@ class KotlinGenerateEqualsAndHashcodeAction : KotlinGenerateMemberActionBase<Kot
    private fun generateClassLiteralsNotEqual(paramName: String, targetClass: KtClassOrObject): String {
        val defaultExpression = "javaClass != $paramName?.javaClass"
        if (!targetClass.languageVersionSettings.supportsFeature(LanguageFeature.BoundCallableReferences)) return defaultExpression
-        return when (targetClass.platform) {
-            is JsPlatform -> "other == null || this::class.js != $paramName::class.js"
-            is CommonPlatform -> "other == null || this::class != $paramName::class"
+        return when {
+            targetClass.platform.isJs() -> "other == null || this::class.js != $paramName::class.js"
+            targetClass.platform.isCommon() -> "other == null || this::class != $paramName::class"
            else -> defaultExpression
        }
    }
@@ -141,9 +141,9 @@ class KotlinGenerateEqualsAndHashcodeAction : KotlinGenerateMemberActionBase<Kot
    private fun generateClassLiteral(targetClass: KtClassOrObject): String {
        val defaultExpression = "javaClass"
        if (!targetClass.languageVersionSettings.supportsFeature(LanguageFeature.BoundCallableReferences)) return defaultExpression
-        return when (targetClass.platform) {
-            is JsPlatform -> "this::class.js"
-            is CommonPlatform -> "this::class"
+        return when {
+            targetClass.platform.isJs() -> "this::class.js"
+            targetClass.platform.isCommon() -> "this::class"
            else -> defaultExpression
        }
    }
@@ -19,7 +19,6 @@ 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
@@ -35,6 +34,7 @@ import org.jetbrains.kotlin.psi.psiUtil.hasExpectModifier
 import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker
 import org.jetbrains.kotlin.resolve.diagnostics.SimpleDiagnostics
+import org.jetbrains.kotlin.platform.isCommon
 import org.jetbrains.kotlin.resolve.jvm.multiplatform.JavaActualAnnotationArgumentExtractor

 class PlatformExpectedAnnotator : Annotator {
@@ -42,7 +42,7 @@ class PlatformExpectedAnnotator : Annotator {
        val declaration = element as? KtNamedDeclaration ?: return
        if (!isExpectedDeclaration(declaration)) return

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

        val implementingModules = declaration.findModuleDescriptor().implementingDescriptors
        if (implementingModules.isEmpty()) return
@@ -25,22 +25,21 @@ import org.jetbrains.kotlin.idea.core.isAndroidModule
 import org.jetbrains.kotlin.idea.core.toDescriptor
 import org.jetbrains.kotlin.idea.util.actualsForExpected
 import org.jetbrains.kotlin.psi.KtDeclaration
-import org.jetbrains.kotlin.resolve.MultiTargetPlatform
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
-import org.jetbrains.kotlin.resolve.getMultiTargetPlatform
+import org.jetbrains.kotlin.platform.isCommon

-private fun ModuleDescriptor?.getMultiTargetPlatformName(): String? {
+private fun ModuleDescriptor?.getPlatformName(): String? {
    if (this == null) return null
    val moduleInfo = getCapability(ModuleInfo.Capability) as? ModuleSourceInfo
    if (moduleInfo != null && moduleInfo.module.isAndroidModule()) {
        return "Android"
    }
-    val platform = getMultiTargetPlatform() ?: return null
-    return when (platform) {
-        is MultiTargetPlatform.Specific ->
-            platform.platform
-        MultiTargetPlatform.Common ->
-            "common"
+    val platform = platform ?: return null
+
+    // TODO(dsavvinov): use better description
+    return when {
+        platform.isCommon() -> "common"
+        else -> platform.single().platformName
    }
 }

@@ -50,7 +49,7 @@ fun getPlatformActualTooltip(declaration: KtDeclaration): String? {

    return actualDeclarations.asSequence()
        .mapNotNull { it.toDescriptor()?.module }
-        .groupBy { it.getMultiTargetPlatformName() }
+        .groupBy { it.getPlatformName() }
        .filter { (platform, _) -> platform != null }
        .entries
        .joinToString(prefix = "Has actuals in ") { (platform, modules) ->
@@ -15,16 +15,16 @@ import org.jetbrains.kotlin.idea.caches.project.implementingDescriptors
 import org.jetbrains.kotlin.idea.caches.resolve.findModuleDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
 import org.jetbrains.kotlin.idea.quickfix.expectactual.CreateActualClassFix
+import org.jetbrains.kotlin.platform.isCommon
 import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.classOrObjectVisitor
 import org.jetbrains.kotlin.psi.psiUtil.hasExpectModifier
-import org.jetbrains.kotlin.resolve.MultiTargetPlatform
 import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker
 import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker.Companion.allStrongIncompatibilities
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
-import org.jetbrains.kotlin.resolve.getMultiTargetPlatform
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectedActualResolver
+import org.jetbrains.kotlin.platform.oldFashionedDescription

 class OptionalExpectationInspection : AbstractKotlinInspection() {
    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean, session: LocalInspectionToolSession) =
@@ -49,12 +49,14 @@ class OptionalExpectationInspection : AbstractKotlinInspection() {
                                expectedOnes != null && ExpectedActualResolver.Compatibility.Compatible in expectedOnes.keys
                            })
                ) continue
-                val platform = (actualModuleDescriptor.getMultiTargetPlatform() as? MultiTargetPlatform.Specific) ?: continue
+                val platform = actualModuleDescriptor.platform ?: continue
+                if (platform.isCommon()) continue
+
                val displayedName = actualModuleDescriptor.getCapability(ModuleInfo.Capability)?.displayedName ?: ""
                val actualModule = (actualModuleDescriptor.getCapability(ModuleInfo.Capability) as? ModuleSourceInfo)?.module ?: continue
                holder.registerProblem(
                    classOrObject.nameIdentifier ?: classOrObject,
-                    "Optionally expected annotation has no actual annotation in module $displayedName for platform ${platform.platform}",
+                    "Optionally expected annotation has no actual annotation in module $displayedName for platform ${platform.oldFashionedDescription}",
                    // NB: some highlighting is not suggested for this inspection
                    ProblemHighlightType.INFORMATION,
                    IntentionWrapper(CreateActualClassFix(classOrObject, actualModule, platform), classOrObject.containingFile)
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.psi.createExpressionByPattern
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.types.typeUtil.isEnum

 private val hashMapCreationFqNames = setOf(
@@ -34,7 +34,7 @@ private val hashMapCreationFqNames = setOf(
 class ReplaceWithEnumMapInspection : AbstractKotlinInspection() {
    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
        return callExpressionVisitor(fun(element: KtCallExpression) {
-            if (element.platform !is JvmPlatform) return
+            if (!element.platform.isJvm()) return
            val context = element.analyze()
            val fqName = element.getResolvedCall(context)?.resultingDescriptor?.fqNameUnsafe?.asString() ?: return
            if (!hashMapCreationFqNames.contains(fqName)) return
@@ -12,16 +12,16 @@ import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.idea.intentions.getCallableDescriptor
 import org.jetbrains.kotlin.idea.project.platform
-import org.jetbrains.kotlin.js.resolve.JsPlatform
 import org.jetbrains.kotlin.psi.KtCallExpression
 import org.jetbrains.kotlin.psi.callExpressionVisitor
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForSelector
+import org.jetbrains.kotlin.platform.js.isJs
 import org.jetbrains.kotlin.types.DynamicType

 class SuspiciousAsDynamicInspection : AbstractKotlinInspection() {
    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean) =
        callExpressionVisitor(fun(call) {
-            if (call.platform != JsPlatform) return
+            if (!call.platform.isJs()) return
            if (call.calleeExpression?.text != "asDynamic") return
            if (call.getQualifiedExpressionForSelector()?.receiverExpression?.getCallableDescriptor()?.returnType !is DynamicType) return
            holder.registerProblem(
@@ -35,7 +35,6 @@ import org.jetbrains.kotlin.idea.intentions.isReceiverExpressionWithValue
 import org.jetbrains.kotlin.idea.intentions.toResolvedCall
 import org.jetbrains.kotlin.idea.project.languageVersionSettings
 import org.jetbrains.kotlin.idea.project.platform
-import org.jetbrains.kotlin.js.resolve.JsPlatform
 import org.jetbrains.kotlin.lexer.KtSingleValueToken
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
@@ -48,6 +47,7 @@ import org.jetbrains.kotlin.resolve.calls.model.ArgumentMatch
 import org.jetbrains.kotlin.resolve.calls.model.isReallySuccess
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
 import org.jetbrains.kotlin.resolve.calls.smartcasts.getKotlinTypeWithPossibleSmartCastToFP
+import org.jetbrains.kotlin.platform.js.isJs
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
@@ -87,7 +87,7 @@ class ReplaceCallWithBinaryOperatorInspection : AbstractApplicabilityBasedInspec
    override fun inspectionHighlightType(element: KtDotQualifiedExpression): ProblemHighlightType {
        val calleeExpression = element.callExpression?.calleeExpression as? KtSimpleNameExpression
        val identifier = calleeExpression?.getReferencedNameAsName()
-        if (element.platform == JsPlatform && identifier == OperatorNameConventions.EQUALS) {
+        if (element.platform.isJs() && identifier == OperatorNameConventions.EQUALS) {
            val context = element.analyze(BodyResolveMode.PARTIAL)
            if (element.receiverExpression.getType(context)?.isDynamic() == true) {
                return ProblemHighlightType.INFORMATION
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.isJvm

 private val annotationFqName = FqName("kotlin.jvm.JvmOverloads")

@@ -69,7 +69,7 @@ class AddJvmOverloadsIntention : SelfTargetingIntention<KtModifierListOwner>(

        text = "Add '@JvmOverloads' annotation to $targetName"

-        return TargetPlatformDetector.getPlatform(element.containingKtFile) == JvmPlatform
+        return TargetPlatformDetector.getPlatform(element.containingKtFile).isJvm()
               && parameters.any { it.hasDefaultValue() }
               && element.findAnnotation(annotationFqName) == null
    }
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.psi.psiUtil.getParentOfTypesAndPredicate
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.calls.callUtil.getType
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.getAbbreviatedType
@@ -30,7 +30,7 @@ class AddThrowsAnnotationIntention : SelfTargetingIntention<KtThrowExpression>(
 ) {

    override fun isApplicableTo(element: KtThrowExpression, caretOffset: Int): Boolean {
-        if (element.platform != JvmPlatform) return false
+        if (!element.platform.isJvm()) return false
        val containingDeclaration = element.getContainingDeclaration() ?: return false

        val type = element.thrownExpression?.resolveToCall()?.resultingDescriptor?.returnType ?: return false
@@ -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.platform.isCommon
+import org.jetbrains.kotlin.platform.js.isJs
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.decapitalizeSmart
 import org.jetbrains.kotlin.utils.SmartList

@@ -54,7 +54,7 @@ sealed class ConvertTestFunctionToSpacedIntention(case: String) : SelfTargetingR

    override fun applicabilityRange(element: KtNamedFunction): TextRange? {
        val platform = element.platform
-        if (platform is CommonPlatform || platform is JsPlatform) return null
+        if (platform.isCommon() || platform.isJs()) return null
        val range = element.nameIdentifier?.textRange ?: return null

        val name = element.name ?: return null
@@ -8,19 +8,19 @@ package org.jetbrains.kotlin.idea.intentions
 import com.intellij.openapi.editor.Editor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.idea.project.platform
-import org.jetbrains.kotlin.js.resolve.JsPlatform
 import org.jetbrains.kotlin.psi.KtCallExpression
 import org.jetbrains.kotlin.psi.KtDotQualifiedExpression
 import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.createExpressionByPattern
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameOrNull
+import org.jetbrains.kotlin.platform.js.isJs

 class ConvertUnsafeCastCallToUnsafeCastIntention : SelfTargetingIntention<KtDotQualifiedExpression>(
    KtDotQualifiedExpression::class.java, "Convert to unsafe cast"
 ) {

    override fun isApplicableTo(element: KtDotQualifiedExpression, caretOffset: Int): Boolean {
-        if (element.platform != JsPlatform) return false
+        if (!element.platform.isJs()) return false
        if ((element.selectorExpression as? KtCallExpression)?.calleeExpression?.text != "unsafeCast") return false

        val fqName = element.resolveToCall()?.resultingDescriptor?.fqNameOrNull()?.asString() ?: return false
@@ -8,12 +8,12 @@ package org.jetbrains.kotlin.idea.intentions
 import com.intellij.openapi.editor.Editor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.project.platform
-import org.jetbrains.kotlin.js.resolve.JsPlatform
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtBinaryExpressionWithTypeRHS
 import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.createExpressionByPattern
 import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.platform.js.isJs
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.types.TypeUtils

@@ -22,7 +22,7 @@ class ConvertUnsafeCastToUnsafeCastCallIntention : SelfTargetingIntention<KtBina
 ) {

    override fun isApplicableTo(element: KtBinaryExpressionWithTypeRHS, caretOffset: Int): Boolean {
-        if (element.platform != JsPlatform) return false
+        if (!element.platform.isJs()) return false

        if (element.operationReference.getReferencedNameElementType() != KtTokens.AS_KEYWORD) return false

@@ -67,7 +67,7 @@ import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfoBefore
 import org.jetbrains.kotlin.resolve.calls.callUtil.getParentCall
 import org.jetbrains.kotlin.resolve.calls.context.ContextDependency
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.scopes.ExplicitImportsScope
 import org.jetbrains.kotlin.resolve.scopes.utils.addImportingScope
@@ -334,7 +334,7 @@ internal class ImportFix(expression: KtSimpleNameExpression) : OrdinaryImportFix
            processor = processor
        )

-        if (TargetPlatformDetector.getPlatform(element.containingKtFile) == JvmPlatform) {
+        if (TargetPlatformDetector.getPlatform(element.containingKtFile).isJvm()) {
            indicesHelper.processJvmCallablesByName(
                name,
                filter = { it.hasModifierProperty(PsiModifier.STATIC) },
@@ -641,14 +641,16 @@ internal object ImportForMissingOperatorFactory : ImportFixBase.Factory() {
 }


-private fun KotlinIndicesHelper.getClassesByName(expressionForPlatform: KtExpression, name: String) =
-    when (TargetPlatformDetector.getPlatform(expressionForPlatform.containingKtFile)) {
-        JvmPlatform -> getJvmClassesByName(name)
+private fun KotlinIndicesHelper.getClassesByName(expressionForPlatform: KtExpression, name: String): Collection<ClassDescriptor> {
+    val platform = TargetPlatformDetector.getPlatform(expressionForPlatform.containingKtFile)
+    return when {
+        platform.isJvm() -> getJvmClassesByName(name)
        else -> getKotlinClasses({ it == name },
            // Enum entries should be contributes with members import fix
                                 psiFilter = { ktDeclaration -> ktDeclaration !is KtEnumEntry },
                                 kindFilter = { kind -> kind != ClassKind.ENUM_ENTRY })
    }
+}

 private fun CallTypeAndReceiver<*, *>.toFilter() = { descriptor: DeclarationDescriptor ->
    callType.descriptorKindFilter.accepts(descriptor)
@@ -73,9 +73,9 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.createSmartPointer
 import org.jetbrains.kotlin.psi.psiUtil.visibilityModifierType
 import org.jetbrains.kotlin.resolve.AnnotationChecker
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.resolve.annotations.JVM_STATIC_ANNOTATION_FQ_NAME
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.Variance
@@ -365,7 +365,7 @@ class KotlinElementActionsFactory : JvmElementActionsFactory() {
        if (!modifierBuilder.isValid) return emptyList()

        val resolutionFacade = KotlinCacheService.getInstance(targetContainer.project)
-            .getResolutionFacadeByFile(targetContainer.containingFile, JvmPlatform) ?: return emptyList()
+            .getResolutionFacadeByFile(targetContainer.containingFile, JvmPlatforms.defaultJvmPlatform) ?: return emptyList()
        val returnTypeInfo = request.returnType.toKotlinTypeInfo(resolutionFacade)
        val parameters = request.parameters as List<Pair<SuggestedNameInfo, List<ExpectedType>>>
        val parameterInfos = parameters.map { (suggestedNames, expectedTypes) ->
@@ -73,9 +73,9 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.createSmartPointer
 import org.jetbrains.kotlin.psi.psiUtil.visibilityModifierType
 import org.jetbrains.kotlin.resolve.AnnotationChecker
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.resolve.annotations.JVM_STATIC_ANNOTATION_FQ_NAME
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.Variance
@@ -409,7 +409,7 @@ class KotlinElementActionsFactory : JvmElementActionsFactory() {
        if (!modifierBuilder.isValid) return emptyList()

        val resolutionFacade = KotlinCacheService.getInstance(targetContainer.project)
-            .getResolutionFacadeByFile(targetContainer.containingFile, JvmPlatform) ?: return emptyList()
+            .getResolutionFacadeByFile(targetContainer.containingFile, JvmPlatforms.defaultJvmPlatform) ?: return emptyList()
        val returnTypeInfo = request.returnType.toKotlinTypeInfo(resolutionFacade)
        val parameters = request.parameters as List<Pair<SuggestedNameInfo, List<ExpectedType>>>
        val parameterInfos = parameters.map { (suggestedNames, expectedTypes) ->
@@ -32,17 +32,17 @@ import org.jetbrains.kotlin.idea.quickfix.KotlinSingleIntentionActionFactory
 import org.jetbrains.kotlin.idea.util.actualsForExpected
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.hasExpectModifier
-import org.jetbrains.kotlin.resolve.MultiTargetPlatform
-import org.jetbrains.kotlin.resolve.getMultiTargetPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform

 sealed class CreateActualFix<D : KtNamedDeclaration>(
    declaration: D,
    actualModule: Module,
-    private val actualPlatform: MultiTargetPlatform.Specific,
+    private val actualPlatform: TargetPlatform,
    generateIt: KtPsiFactory.(Project, D) -> D?
 ) : AbstractCreateDeclarationFix<D>(declaration, actualModule, generateIt) {

-    override fun getText() = "Create actual $elementType for module ${module.name} (${actualPlatform.platform})"
+    override fun getText() =
+        "Create actual $elementType for module ${module.name} (${actualPlatform.singleOrNull()?.platformName ?: actualPlatform})"

    final override fun invoke(project: Project, editor: Editor?, file: KtFile) {
        val actualFile = getOrCreateImplementationFile() ?: return
@@ -71,7 +71,7 @@ sealed class CreateActualFix<D : KtNamedDeclaration>(
            if (compatibility.isNotEmpty() && declaration !is KtFunction) return null
            val actualModuleDescriptor = d.b
            val actualModule = (actualModuleDescriptor.getCapability(ModuleInfo.Capability) as? ModuleSourceInfo)?.module ?: return null
-            val actualPlatform = actualModuleDescriptor.getMultiTargetPlatform() as? MultiTargetPlatform.Specific ?: return null
+            val actualPlatform = actualModuleDescriptor.platform ?: return null
            return when (declaration) {
                is KtClassOrObject -> CreateActualClassFix(declaration, actualModule, actualPlatform)
                is KtFunction -> CreateActualFunctionFix(declaration, actualModule, actualPlatform)
@@ -85,7 +85,7 @@ sealed class CreateActualFix<D : KtNamedDeclaration>(
 class CreateActualClassFix(
    klass: KtClassOrObject,
    actualModule: Module,
-    actualPlatform: MultiTargetPlatform.Specific
+    actualPlatform: TargetPlatform
 ) : CreateActualFix<KtClassOrObject>(klass, actualModule, actualPlatform, { project, element ->
    generateClassOrObject(project, false, element)
 })
@@ -93,7 +93,7 @@ class CreateActualClassFix(
 class CreateActualPropertyFix(
    property: KtProperty,
    actualModule: Module,
-    actualPlatform: MultiTargetPlatform.Specific
+    actualPlatform: TargetPlatform
 ) : CreateActualFix<KtProperty>(property, actualModule, actualPlatform, { project, element ->
    val descriptor = element.toDescriptor() as? PropertyDescriptor
    descriptor?.let { generateProperty(project, false, element, descriptor) }
@@ -102,7 +102,7 @@ class CreateActualPropertyFix(
 class CreateActualFunctionFix(
    function: KtFunction,
    actualModule: Module,
-    actualPlatform: MultiTargetPlatform.Specific
+    actualPlatform: TargetPlatform
 ) : CreateActualFix<KtFunction>(function, actualModule, actualPlatform, { project, element ->
    val descriptor = element.toDescriptor() as? FunctionDescriptor
    descriptor?.let { generateFunction(project, false, element, descriptor) }
@@ -36,12 +36,11 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.hasActualModifier
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
-import org.jetbrains.kotlin.resolve.MultiTargetPlatform
 import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker
 import org.jetbrains.kotlin.resolve.checkers.ExperimentalUsageChecker
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
-import org.jetbrains.kotlin.resolve.getMultiTargetPlatform
+import org.jetbrains.kotlin.platform.isCommon
 import org.jetbrains.kotlin.types.AbbreviatedType
 import org.jetbrains.kotlin.types.KotlinType

@@ -296,7 +295,7 @@ private fun KotlinType.checkAccessibility(accessibleClasses: List<KtClassOrObjec
    }
    val classifierDescriptor = constructor.declarationDescriptor as? ClassifierDescriptorWithTypeParameters ?: return
    val moduleDescriptor = classifierDescriptor.module
-    if (moduleDescriptor.getMultiTargetPlatform() == MultiTargetPlatform.Common) {
+    if (moduleDescriptor.platform.isCommon()) {
        // Common classes are Ok; unfortunately this check does not work correctly for simple (non-expect) classes from common module
        return
    }
@@ -16,6 +16,7 @@

 package org.jetbrains.kotlin.idea.quickfix.replaceWith

+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.analysis.analyzeInContext
@@ -47,8 +47,8 @@ import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.resolve.jvm.annotations.findJvmOverloadsAnnotation
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.resolve.source.getPsi
 import org.jetbrains.kotlin.types.isError
 import org.jetbrains.kotlin.types.typeUtil.isUnit
@@ -488,7 +488,7 @@ open class KotlinChangeInfo(
            return createJavaChangeInfo(originalPsiMethod, currentPsiMethod, newName, PsiType.VOID, newJavaParameters.toTypedArray())
        }

-        if (TargetPlatformDetector.getPlatform(method.containingFile as KtFile) != JvmPlatform) return null
+        if (!TargetPlatformDetector.getPlatform(method.containingFile as KtFile).isJvm()) return null

        if (javaChangeInfos == null) {
            val method = method
@@ -73,7 +73,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameOrNull
 import org.jetbrains.kotlin.resolve.descriptorUtil.getImportableDescriptor
 import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassNotAny
 import org.jetbrains.kotlin.resolve.descriptorUtil.isSubclassOf
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.lazy.descriptors.findPackageFragmentForFile
 import org.jetbrains.kotlin.resolve.source.KotlinSourceElement
@@ -278,7 +278,7 @@ class MoveConflictChecker(
        val baseScope = GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(this)

        val targetPlatform = TargetPlatformDetector.getPlatform(this)
-        if (targetPlatform is JvmPlatform) return baseScope
+        if (targetPlatform.isJvm()) return baseScope

        return ModuleRootManager.getInstance(this)
            .orderEntries
@@ -31,16 +31,19 @@ import org.jetbrains.jps.model.module.JpsModuleSourceRootType
 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.kotlin.analyzer.common.CommonPlatform
 import org.jetbrains.kotlin.config.getFacetPlatformByConfigurationElement
 import org.jetbrains.kotlin.idea.facet.KotlinFacetType
 import org.jetbrains.kotlin.idea.framework.JavaRuntimeDetectionUtil
 import org.jetbrains.kotlin.idea.framework.JsLibraryStdDetectionUtil
 import org.jetbrains.kotlin.idea.framework.getLibraryJar
 import org.jetbrains.kotlin.idea.refactoring.toVirtualFile
-import org.jetbrains.kotlin.js.resolve.JsPlatform
-import org.jetbrains.kotlin.resolve.TargetPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.platform.CommonPlatforms
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.isCommon
+import org.jetbrains.kotlin.platform.js.JsPlatforms
+import org.jetbrains.kotlin.platform.js.isJs
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.utils.PathUtil

 class KotlinNonJvmSourceRootConverterProvider : ConverterProvider("kotlin-non-jvm-source-roots") {
@@ -52,10 +55,11 @@ class KotlinNonJvmSourceRootConverterProvider : ConverterProvider("kotlin-non-jv
            JavaResourceRootType.TEST_RESOURCE
        )

+        // TODO(dsavvinov): review how it behaves in HMPP environment
        private val PLATFORM_TO_STDLIB_DETECTORS: Map<TargetPlatform, (Array<VirtualFile>) -> Boolean> = mapOf(
-            JvmPlatform to { roots: Array<VirtualFile> -> JavaRuntimeDetectionUtil.getRuntimeJar(roots.toList()) != null },
-            JsPlatform to { roots: Array<VirtualFile> -> JsLibraryStdDetectionUtil.getJsStdLibJar(roots.toList()) != null },
-            CommonPlatform to { roots: Array<VirtualFile> -> getLibraryJar(roots, PathUtil.KOTLIN_STDLIB_COMMON_JAR_PATTERN) != null }
+            JvmPlatforms.defaultJvmPlatform to { roots: Array<VirtualFile> -> JavaRuntimeDetectionUtil.getRuntimeJar(roots.toList()) != null },
+            JsPlatforms.defaultJsPlatform to { roots: Array<VirtualFile> -> JsLibraryStdDetectionUtil.getJsStdLibJar(roots.toList()) != null },
+            CommonPlatforms.defaultCommonPlatform to { roots: Array<VirtualFile> -> getLibraryJar(roots, PathUtil.KOTLIN_STDLIB_COMMON_JAR_PATTERN) != null }
        )
    }

@@ -148,7 +152,7 @@ class KotlinNonJvmSourceRootConverterProvider : ConverterProvider("kotlin-non-jv
                        .forEach {
                            val stdlibPlatform = it.stdlibPlatform
                            if (stdlibPlatform != null) {
-                                if (stdlibPlatform == CommonPlatform) {
+                                if (stdlibPlatform.isCommon()) {
                                    hasCommonStdlib = true
                                } else {
                                    return stdlibPlatform
@@ -156,13 +160,13 @@ class KotlinNonJvmSourceRootConverterProvider : ConverterProvider("kotlin-non-jv
                            }
                        }

-                    return if (hasCommonStdlib) CommonPlatform else null
+                    return if (hasCommonStdlib) CommonPlatforms.defaultCommonPlatform else null
                }

                private fun ModuleSettings.detectPlatform(): TargetPlatform {
                    return detectPlatformByFacet()
                        ?: detectPlatformByDependencies()
-                        ?: JvmPlatform
+                        ?: JvmPlatforms.defaultJvmPlatform
                }

                private fun ModuleSettings.getSourceFolderElements(): List<Element> {
@@ -192,7 +196,7 @@ class KotlinNonJvmSourceRootConverterProvider : ConverterProvider("kotlin-non-jv
                    }

                    val targetPlatform = settings.detectPlatform()
-                    return (targetPlatform != JvmPlatform)
+                    return (!targetPlatform.isJvm())
                }

                override fun process(settings: ModuleSettings) {
--- a/Show More
+++ b/Show More