[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.

compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt

@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
-import org.jetbrains.kotlin.config.TargetPlatformVersion
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.context.ProjectContext
@@ -37,10 +36,10 @@ import org.jetbrains.kotlin.descriptors.impl.ModuleDependencies
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.TargetPlatformVersion
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.CompilerEnvironment
-import org.jetbrains.kotlin.resolve.TargetEnvironment
-import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.storage.getValue
 import java.util.*
@@ -185,6 +184,8 @@ class ResolverForProjectImpl<M : ModuleInfo>(
 
                 val languageVersionSettings =
                     moduleLanguageSettingsProvider.getLanguageVersionSettings(module, projectContext.project, isReleaseCoroutines)
+
+                // FIXME(dsavvinov): make sure that module.platform returns platform with the same JvmTarget as this one
                 val targetPlatformVersion = moduleLanguageSettingsProvider.getTargetPlatform(module, projectContext.project)
 
                 val resolverForModuleFactory = resolverForModuleFactoryByPlatform(module.platform)
@@ -195,8 +196,7 @@ class ResolverForProjectImpl<M : ModuleInfo>(
                     platformParameters(module.platform ?: TODO("Missing platform!")),
                     targetEnvironment,
                     this@ResolverForProjectImpl,
-                    languageVersionSettings,
-                    targetPlatformVersion
+                    languageVersionSettings
                 )
             }
         }
@@ -255,7 +255,7 @@ class ResolverForProjectImpl<M : ModuleInfo>(
             module.name,
             projectContext.storageManager,
             builtIns,
-            module.platform?.multiTargetPlatform,
+            module.platform,
             module.capabilities,
             module.stableName
         )
@@ -304,8 +304,7 @@ abstract class ResolverForModuleFactory {
         platformParameters: PlatformAnalysisParameters,
         targetEnvironment: TargetEnvironment,
         resolverForProject: ResolverForProject<M>,
-        languageVersionSettings: LanguageVersionSettings,
-        targetPlatformVersion: TargetPlatformVersion
+        languageVersionSettings: LanguageVersionSettings
     ): ResolverForModule
 }
 

compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/CommonPlatform.kt

@@ -17,11 +17,6 @@ import org.jetbrains.kotlin.resolve.scopes.SyntheticScopes
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.DynamicTypesSettings
 
-object CommonPlatform : TargetPlatform("Default") {
-    override val platform: MultiTargetPlatform
-        get() = MultiTargetPlatform.Common
-}
-
 private object CommonPlatformConfigurator : PlatformConfiguratorBase(
     DynamicTypesSettings(), listOf(), listOf(), listOf(), listOf(), listOf(),
     IdentifierChecker.Default, OverloadFilter.Default, PlatformToKotlinClassMap.EMPTY, DelegationFilter.Default,

compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt

@@ -1,181 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.analyzer.common
-
-import com.intellij.openapi.components.ServiceManager
-import com.intellij.openapi.project.Project
-import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analyzer.*
-import org.jetbrains.kotlin.config.LanguageFeature
-import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.config.TargetPlatformVersion
-import org.jetbrains.kotlin.container.StorageComponentContainer
-import org.jetbrains.kotlin.container.get
-import org.jetbrains.kotlin.container.useImpl
-import org.jetbrains.kotlin.container.useInstance
-import org.jetbrains.kotlin.context.ModuleContext
-import org.jetbrains.kotlin.context.ProjectContext
-import org.jetbrains.kotlin.contracts.ContractDeserializerImpl
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.frontend.di.configureModule
-import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
-import org.jetbrains.kotlin.incremental.components.LookupTracker
-import org.jetbrains.kotlin.load.kotlin.MetadataFinderFactory
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
-import org.jetbrains.kotlin.serialization.deserialization.MetadataPackageFragmentProvider
-import org.jetbrains.kotlin.serialization.deserialization.MetadataPartProvider
-import org.jetbrains.kotlin.types.SubstitutingScopeProviderImpl
-
-class CommonAnalysisParameters(
-    val metadataPartProviderFactory: (ModuleContent<*>) -> MetadataPartProvider
-) : PlatformAnalysisParameters
-
-/**
- * A facade that is used to analyze common (platform-independent) modules in multi-platform projects.
- * See [CommonPlatform]
- */
-object CommonResolverForModuleFactory : ResolverForModuleFactory() {
-    private class SourceModuleInfo(
-        override val name: Name,
-        override val capabilities: Map<ModuleDescriptor.Capability<*>, Any?>,
-        private val dependOnOldBuiltIns: Boolean
-    ) : ModuleInfo {
-        override fun dependencies() = listOf(this)
-
-        override fun dependencyOnBuiltIns(): ModuleInfo.DependencyOnBuiltIns =
-            if (dependOnOldBuiltIns) ModuleInfo.DependencyOnBuiltIns.LAST else ModuleInfo.DependencyOnBuiltIns.NONE
-
-        override val compilerServices: PlatformDependentCompilerServices
-            get() = CommonPlatformCompilerServices
-    }
-
-    fun analyzeFiles(
-        files: Collection<KtFile>, moduleName: Name, dependOnBuiltIns: Boolean, languageVersionSettings: LanguageVersionSettings,
-        capabilities: Map<ModuleDescriptor.Capability<*>, Any?> = mapOf(MultiTargetPlatform.CAPABILITY to MultiTargetPlatform.Common),
-        metadataPartProviderFactory: (ModuleContent<ModuleInfo>) -> MetadataPartProvider
-    ): AnalysisResult {
-        val moduleInfo = SourceModuleInfo(moduleName, capabilities, dependOnBuiltIns)
-        val project = files.firstOrNull()?.project ?: throw AssertionError("No files to analyze")
-
-        val multiplatformLanguageSettings = object : LanguageVersionSettings by languageVersionSettings {
-            override fun getFeatureSupport(feature: LanguageFeature): LanguageFeature.State =
-                if (feature == LanguageFeature.MultiPlatformProjects) LanguageFeature.State.ENABLED
-                else languageVersionSettings.getFeatureSupport(feature)
-        }
-
-        @Suppress("NAME_SHADOWING")
-        val resolver = ResolverForProjectImpl(
-            "sources for metadata serializer",
-            ProjectContext(project),
-            listOf(moduleInfo),
-            modulesContent = { ModuleContent(it, files, GlobalSearchScope.allScope(project)) },
-            moduleLanguageSettingsProvider = object : LanguageSettingsProvider {
-                override fun getLanguageVersionSettings(
-                    moduleInfo: ModuleInfo,
-                    project: Project,
-                    isReleaseCoroutines: Boolean?
-                ) = multiplatformLanguageSettings
-
-                override fun getTargetPlatform(
-                    moduleInfo: ModuleInfo,
-                    project: Project
-                ) = TargetPlatformVersion.NoVersion
-            },
-            resolverForModuleFactoryByPlatform = { CommonResolverForModuleFactory },
-            platformParameters = { _ -> CommonAnalysisParameters(metadataPartProviderFactory) }
-        )
-
-        val moduleDescriptor = resolver.descriptorForModule(moduleInfo)
-        val container = resolver.resolverForModule(moduleInfo).componentProvider
-
-        container.get<LazyTopDownAnalyzer>().analyzeDeclarations(TopDownAnalysisMode.TopLevelDeclarations, files)
-
-        return AnalysisResult.success(container.get<BindingTrace>().bindingContext, moduleDescriptor)
-    }
-
-    override fun <M : ModuleInfo> createResolverForModule(
-        moduleDescriptor: ModuleDescriptorImpl,
-        moduleContext: ModuleContext,
-        moduleContent: ModuleContent<M>,
-        platformParameters: PlatformAnalysisParameters,
-        targetEnvironment: TargetEnvironment,
-        resolverForProject: ResolverForProject<M>,
-        languageVersionSettings: LanguageVersionSettings,
-        targetPlatformVersion: TargetPlatformVersion
-    ): ResolverForModule {
-        val (moduleInfo, syntheticFiles, moduleContentScope) = moduleContent
-        val project = moduleContext.project
-        val declarationProviderFactory = DeclarationProviderFactoryService.createDeclarationProviderFactory(
-            project, moduleContext.storageManager, syntheticFiles,
-            moduleContentScope,
-            moduleInfo
-        )
-
-        val metadataPartProvider = (platformParameters as CommonAnalysisParameters).metadataPartProviderFactory(moduleContent)
-        val trace = CodeAnalyzerInitializer.getInstance(project).createTrace()
-        val container = createContainerToResolveCommonCode(
-            moduleContext, trace, declarationProviderFactory, moduleContentScope, targetEnvironment, metadataPartProvider,
-            languageVersionSettings
-        )
-
-        val packageFragmentProviders = listOf(
-            container.get<ResolveSession>().packageFragmentProvider,
-            container.get<MetadataPackageFragmentProvider>()
-        )
-
-        return ResolverForModule(CompositePackageFragmentProvider(packageFragmentProviders), container)
-    }
-
-    private fun createContainerToResolveCommonCode(
-        moduleContext: ModuleContext,
-        bindingTrace: BindingTrace,
-        declarationProviderFactory: DeclarationProviderFactory,
-        moduleContentScope: GlobalSearchScope,
-        targetEnvironment: TargetEnvironment,
-        metadataPartProvider: MetadataPartProvider,
-        languageVersionSettings: LanguageVersionSettings
-    ): StorageComponentContainer = createContainer("ResolveCommonCode", CommonPlatformCompilerServices) {
-        configureModule(moduleContext, CommonPlatform, TargetPlatformVersion.NoVersion, CommonPlatformCompilerServices, bindingTrace)
-
-        useInstance(moduleContentScope)
-        useInstance(LookupTracker.DO_NOTHING)
-        useInstance(ExpectActualTracker.DoNothing)
-        useImpl<ResolveSession>()
-        useImpl<LazyTopDownAnalyzer>()
-        useInstance(languageVersionSettings)
-        useImpl<AnnotationResolverImpl>()
-        useImpl<CompilerDeserializationConfiguration>()
-        useInstance(metadataPartProvider)
-        useInstance(declarationProviderFactory)
-        useImpl<MetadataPackageFragmentProvider>()
-        useImpl<ContractDeserializerImpl>()
-        useImpl<SubstitutingScopeProviderImpl>()
-
-        val metadataFinderFactory = ServiceManager.getService(moduleContext.project, MetadataFinderFactory::class.java)
-                ?: error("No MetadataFinderFactory in project")
-        useInstance(metadataFinderFactory.create(moduleContentScope))
-
-        targetEnvironment.configure(this)
-    }
-}

compiler/frontend/src/org/jetbrains/kotlin/checkers/utils/CheckerTestUtil.kt

@@ -20,17 +20,18 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.psi.KtCallableDeclaration
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtReferenceExpression
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
-import org.jetbrains.kotlin.resolve.AnalyzingUtils
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.MultiTargetPlatform
+import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.calls.callUtil.getType
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
+import org.jetbrains.kotlin.platform.isCommon
+import org.jetbrains.kotlin.platform.oldFashionedDescription
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.noTypeInfo
 import java.util.*
@@ -48,7 +49,7 @@ object CheckerTestUtil {
 
     fun getDiagnosticsIncludingSyntaxErrors(
         bindingContext: BindingContext,
-        implementingModulesBindings: List<Pair<MultiTargetPlatform, BindingContext>>,
+        implementingModulesBindings: List<Pair<TargetPlatform, BindingContext>>,
         root: PsiElement,
         markDynamicCalls: Boolean,
         dynamicCallDescriptors: MutableList<DeclarationDescriptor>,
@@ -70,10 +71,11 @@ object CheckerTestUtil {
             moduleDescriptor,
             diagnosedRanges
         )
-        val sortedBindings = implementingModulesBindings.sortedBy { it.first }
+
+        val sortedBindings = implementingModulesBindings.sortedBy { it.first.oldFashionedDescription }
 
         for ((platform, second) in sortedBindings) {
-            assert(platform is MultiTargetPlatform.Specific) { "Implementing module must have a specific platform: $platform" }
+            assert(!platform.isCommon()) { "Implementing module must have a specific platform: $platform" }
 
             result.addAll(
                 getDiagnosticsIncludingSyntaxErrors(
@@ -81,7 +83,7 @@ object CheckerTestUtil {
                     root,
                     markDynamicCalls,
                     dynamicCallDescriptors,
-                    (platform as MultiTargetPlatform.Specific).platform,
+                    platform.single().platformName,
                     withNewInference,
                     languageVersionSettings,
                     dataFlowValueFactory,

compiler/frontend/src/org/jetbrains/kotlin/context/context.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.MultiTargetPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.storage.ExceptionTracker
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.storage.StorageManager
@@ -99,8 +99,8 @@ fun ContextForNewModule(
     projectContext: ProjectContext,
     moduleName: Name,
     builtIns: KotlinBuiltIns,
-    multiTargetPlatform: MultiTargetPlatform?
+    platform: TargetPlatform?
 ): MutableModuleContext {
-    val module = ModuleDescriptorImpl(moduleName, projectContext.storageManager, builtIns, multiTargetPlatform)
+    val module = ModuleDescriptorImpl(moduleName, projectContext.storageManager, builtIns, platform)
     return MutableModuleContextImpl(module, projectContext)
 }

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt

@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor
 import org.jetbrains.kotlin.diagnostics.rendering.TabledDescriptorRenderer.newTable
 import org.jetbrains.kotlin.diagnostics.rendering.TabledDescriptorRenderer.newText
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.platform.isCommon
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.renderer.DescriptorRenderer.Companion.DEBUG_TEXT
@@ -85,11 +86,10 @@ object Renderers {
 
     @JvmField
     val PLATFORM = Renderer<ModuleDescriptor> {
-        val platform = it.getMultiTargetPlatform()
-        " ${it.getCapability(ModuleInfo.Capability)?.displayedName ?: ""}" + when (platform) {
-            MultiTargetPlatform.Common -> ""
-            is MultiTargetPlatform.Specific -> " for " + platform.platform
-            null -> ""
+        val platform = it.platform
+        " ${it.getCapability(ModuleInfo.Capability)?.displayedName ?: ""}" + when {
+            platform == null || platform.isCommon() -> ""
+            else -> " for " + platform.single().platformName
         }
     }
 

compiler/frontend/src/org/jetbrains/kotlin/extensions/StorageComponentContainerContributor.kt

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.extensions
 
 import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
 
 interface StorageComponentContainerContributor {
     companion object : ProjectExtensionDescriptor<StorageComponentContainerContributor>(

compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt

@@ -16,11 +16,10 @@
 
 package org.jetbrains.kotlin.frontend.di
 
-import org.jetbrains.kotlin.analyzer.common.CommonPlatform
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.analyzer.common.CommonPlatformCompilerServices
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
-import org.jetbrains.kotlin.config.TargetPlatformVersion
 import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.container.useImpl
@@ -29,7 +28,9 @@ import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
+import org.jetbrains.kotlin.platform.subplatformOfType
 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.platform.TargetPlatformVersion
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.calls.components.ClassicTypeSystemContextForCS
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactoryImpl
@@ -46,7 +47,6 @@ import org.jetbrains.kotlin.types.expressions.LocalLazyDeclarationResolver
 fun StorageComponentContainer.configureModule(
     moduleContext: ModuleContext,
     platform: TargetPlatform,
-    platformVersion: TargetPlatformVersion,
     compilerServices: PlatformDependentCompilerServices
 ) {
     useInstance(moduleContext)
@@ -56,8 +56,8 @@ fun StorageComponentContainer.configureModule(
     useInstance(moduleContext.module.builtIns)
 
     useInstance(platform)
-    useInstance(platformVersion)
     useInstance(compilerServices)
+    useInstance(platform.componentPlatforms.singleOrNull()?.targetPlatformVersion ?: TargetPlatformVersion.NoVersion)
 
     compilerServices.platformConfigurator.configureModuleComponents(this)
     compilerServices.platformConfigurator.configureModuleDependentCheckers(this)
@@ -83,11 +83,10 @@ private fun StorageComponentContainer.configurePlatformIndependentComponents() {
 fun StorageComponentContainer.configureModule(
     moduleContext: ModuleContext,
     platform: TargetPlatform,
-    platformVersion: TargetPlatformVersion,
     compilerServices: PlatformDependentCompilerServices,
     trace: BindingTrace
 ) {
-    configureModule(moduleContext, platform, platformVersion, compilerServices)
+    configureModule(moduleContext, platform, compilerServices)
     useInstance(trace)
 }
 
@@ -96,11 +95,10 @@ fun createContainerForBodyResolve(
     bindingTrace: BindingTrace,
     platform: TargetPlatform,
     statementFilter: StatementFilter,
-    targetPlatformVersion: TargetPlatformVersion,
     compilerServices: PlatformDependentCompilerServices,
     languageVersionSettings: LanguageVersionSettings
 ): StorageComponentContainer = createContainer("BodyResolve", compilerServices) {
-    configureModule(moduleContext, platform, targetPlatformVersion, compilerServices, bindingTrace)
+    configureModule(moduleContext, platform, compilerServices, bindingTrace)
 
     useInstance(statementFilter)
 
@@ -118,11 +116,10 @@ fun createContainerForLazyBodyResolve(
     bindingTrace: BindingTrace,
     platform: TargetPlatform,
     bodyResolveCache: BodyResolveCache,
-    targetPlatformVersion: TargetPlatformVersion,
     compilerServices: PlatformDependentCompilerServices,
     languageVersionSettings: LanguageVersionSettings
 ): StorageComponentContainer = createContainer("LazyBodyResolve", compilerServices) {
-    configureModule(moduleContext, platform, targetPlatformVersion, compilerServices, bindingTrace)
+    configureModule(moduleContext, platform, compilerServices, bindingTrace)
 
     useInstance(kotlinCodeAnalyzer)
     useInstance(kotlinCodeAnalyzer.fileScopeProvider)
@@ -139,13 +136,12 @@ fun createContainerForLazyLocalClassifierAnalyzer(
     bindingTrace: BindingTrace,
     platform: TargetPlatform,
     lookupTracker: LookupTracker,
-    targetPlatformVersion: TargetPlatformVersion,
     languageVersionSettings: LanguageVersionSettings,
     statementFilter: StatementFilter,
     localClassDescriptorHolder: LocalClassDescriptorHolder,
     compilerServices: PlatformDependentCompilerServices
 ): StorageComponentContainer = createContainer("LocalClassifierAnalyzer", compilerServices) {
-    configureModule(moduleContext, platform, targetPlatformVersion, compilerServices, bindingTrace)
+    configureModule(moduleContext, platform, compilerServices, bindingTrace)
 
     useInstance(localClassDescriptorHolder)
     useInstance(lookupTracker)
@@ -173,12 +169,11 @@ fun createContainerForLazyResolve(
     declarationProviderFactory: DeclarationProviderFactory,
     bindingTrace: BindingTrace,
     platform: TargetPlatform,
-    targetPlatformVersion: TargetPlatformVersion,
     compilerServices: PlatformDependentCompilerServices,
     targetEnvironment: TargetEnvironment,
     languageVersionSettings: LanguageVersionSettings
 ): StorageComponentContainer = createContainer("LazyResolve", compilerServices) {
-    configureModule(moduleContext, platform, targetPlatformVersion, compilerServices, bindingTrace)
+    configureModule(moduleContext, platform, compilerServices, bindingTrace)
 
     useInstance(declarationProviderFactory)
     useInstance(languageVersionSettings)
@@ -192,13 +187,13 @@ fun createContainerForLazyResolve(
     useImpl<SubstitutingScopeProviderImpl>()
 }
 
+// TODO: remove it
 fun createLazyResolveSession(moduleContext: ModuleContext, files: Collection<KtFile>): ResolveSession =
     createContainerForLazyResolve(
         moduleContext,
         FileBasedDeclarationProviderFactory(moduleContext.storageManager, files),
         BindingTraceContext(),
-        CommonPlatform,
-        TargetPlatformVersion.NoVersion,
+        DefaultBuiltInPlatforms.commonPlatform,
         CommonPlatformCompilerServices,
         CompilerEnvironment,
         LanguageVersionSettingsImpl.DEFAULT

compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.kt

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.idea.MainFunctionDetector
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.FqNameUnsafe
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.descriptorUtil.platform
 
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import java.util.*
@@ -290,7 +291,7 @@ class OverloadResolver(
         if (member1 !is MemberDescriptor || member2 !is MemberDescriptor) return false
 
         return member1.isActual && member2.isActual &&
-                member1.getMultiTargetPlatform() != member2.getMultiTargetPlatform()
+                member1.platform != member2.platform
     }
 
     private fun reportRedeclarations(redeclarations: Collection<DeclarationDescriptorNonRoot>) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/OptionalExpectationUsageChecker.kt

@@ -9,9 +9,8 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.MultiTargetPlatform
-import org.jetbrains.kotlin.resolve.descriptorUtil.module
-import org.jetbrains.kotlin.resolve.getMultiTargetPlatform
+import org.jetbrains.kotlin.resolve.descriptorUtil.platform
+import org.jetbrains.kotlin.platform.isCommon
 import org.jetbrains.kotlin.resolve.multiplatform.isCommonSource
 
 class OptionalExpectationUsageChecker : ClassifierUsageChecker {
@@ -23,8 +22,9 @@ class OptionalExpectationUsageChecker : ClassifierUsageChecker {
         }
 
         val ktFile = element.containingFile as KtFile
+        // TODO(dsavvinov): unify for compiler/IDE
         // The first part is for the compiler, and the second one is for IDE
-        if (ktFile.isCommonSource != true && targetDescriptor.module.getMultiTargetPlatform() != MultiTargetPlatform.Common) {
+        if (ktFile.isCommonSource != true && !targetDescriptor.platform.isCommon()) {
             context.trace.report(Errors.OPTIONAL_DECLARATION_USAGE_IN_NON_COMMON_SOURCE.on(element))
         }
     }

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt

@@ -18,8 +18,8 @@ package org.jetbrains.kotlin.types.expressions
 
 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.config.TargetPlatformVersion
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.GlobalContext
 import org.jetbrains.kotlin.context.withModule
@@ -64,7 +64,6 @@ class LocalClassifierAnalyzer(
     private val compilerServices: PlatformDependentCompilerServices,
     private val lookupTracker: LookupTracker,
     private val supertypeLoopChecker: SupertypeLoopChecker,
-    private val targetPlatformVersion: TargetPlatformVersion,
     private val languageVersionSettings: LanguageVersionSettings,
     private val delegationFilter: DelegationFilter,
     private val wrappedTypeFactory: WrappedTypeFactory,
@@ -84,7 +83,6 @@ class LocalClassifierAnalyzer(
             context.trace,
             platform,
             lookupTracker,
-            targetPlatformVersion,
             languageVersionSettings,
             context.statementFilter,
             LocalClassDescriptorHolder(