[Platform API] Split TargetPlatform into lightweight TargetPlatform and CompilerServices

This decouples simple data (TargetPlatform) from other subsystem-specific
logic (like default imports, built-ins, etc.).

Aside from purely aesthetic improvements, it also makes it easier
to move 'TargetPlatform' into core (see next commits)

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

@@ -18,14 +18,8 @@ import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.DynamicTypesSettings
 
 object CommonPlatform : TargetPlatform("Default") {
-    override fun computePlatformSpecificDefaultImports(storageManager: StorageManager, result: MutableList<ImportPath>) {}
-
-    override val multiTargetPlatform: MultiTargetPlatform
+    override val platform: MultiTargetPlatform
         get() = MultiTargetPlatform.Common
-
-    override val platformConfigurator: PlatformConfigurator = CommonPlatformConfigurator
-
-    override fun dependencyOnBuiltIns(): ModuleInfo.DependencyOnBuiltIns = ModuleInfo.DependencyOnBuiltIns.AFTER_SDK
 }
 
 private object CommonPlatformConfigurator : PlatformConfiguratorBase(
@@ -41,3 +35,10 @@ private object CommonPlatformConfigurator : PlatformConfiguratorBase(
     }
 }
 
+object CommonPlatformCompilerServices : PlatformDependentCompilerServices() {
+    override fun computePlatformSpecificDefaultImports(storageManager: StorageManager, result: MutableList<ImportPath>) {}
+
+    override val platformConfigurator: PlatformConfigurator = CommonPlatformConfigurator
+
+    override fun dependencyOnBuiltIns(): ModuleInfo.DependencyOnBuiltIns = ModuleInfo.DependencyOnBuiltIns.AFTER_SDK
+}

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

@@ -65,6 +65,9 @@ object CommonResolverForModuleFactory : ResolverForModuleFactory() {
 
         override fun dependencyOnBuiltIns(): ModuleInfo.DependencyOnBuiltIns =
             if (dependOnOldBuiltIns) ModuleInfo.DependencyOnBuiltIns.LAST else ModuleInfo.DependencyOnBuiltIns.NONE
+
+        override val compilerServices: PlatformDependentCompilerServices
+            get() = CommonPlatformCompilerServices
     }
 
     fun analyzeFiles(
@@ -152,8 +155,8 @@ object CommonResolverForModuleFactory : ResolverForModuleFactory() {
         targetEnvironment: TargetEnvironment,
         metadataPartProvider: MetadataPartProvider,
         languageVersionSettings: LanguageVersionSettings
-    ): StorageComponentContainer = createContainer("ResolveCommonCode", CommonPlatform) {
-        configureModule(moduleContext, CommonPlatform, TargetPlatformVersion.NoVersion, bindingTrace)
+    ): StorageComponentContainer = createContainer("ResolveCommonCode", CommonPlatformCompilerServices) {
+        configureModule(moduleContext, CommonPlatform, TargetPlatformVersion.NoVersion, CommonPlatformCompilerServices, bindingTrace)
 
         useInstance(moduleContentScope)
         useInstance(LookupTracker.DO_NOTHING)
@@ -173,8 +176,6 @@ object CommonResolverForModuleFactory : ResolverForModuleFactory() {
                 ?: error("No MetadataFinderFactory in project")
         useInstance(metadataFinderFactory.create(moduleContentScope))
 
-
-
         targetEnvironment.configure(this)
     }
 }

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

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.frontend.di
 
 import org.jetbrains.kotlin.analyzer.common.CommonPlatform
+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
@@ -45,7 +46,8 @@ import org.jetbrains.kotlin.types.expressions.LocalLazyDeclarationResolver
 fun StorageComponentContainer.configureModule(
     moduleContext: ModuleContext,
     platform: TargetPlatform,
-    platformVersion: TargetPlatformVersion
+    platformVersion: TargetPlatformVersion,
+    compilerServices: PlatformDependentCompilerServices
 ) {
     useInstance(moduleContext)
     useInstance(moduleContext.module)
@@ -55,9 +57,10 @@ fun StorageComponentContainer.configureModule(
 
     useInstance(platform)
     useInstance(platformVersion)
+    useInstance(compilerServices)
 
-    platform.platformConfigurator.configureModuleComponents(this)
-    platform.platformConfigurator.configureModuleDependentCheckers(this)
+    compilerServices.platformConfigurator.configureModuleComponents(this)
+    compilerServices.platformConfigurator.configureModuleDependentCheckers(this)
 
     for (extension in StorageComponentContainerContributor.getInstances(moduleContext.project)) {
         extension.registerModuleComponents(this, platform, moduleContext.module)
@@ -81,9 +84,10 @@ fun StorageComponentContainer.configureModule(
     moduleContext: ModuleContext,
     platform: TargetPlatform,
     platformVersion: TargetPlatformVersion,
+    compilerServices: PlatformDependentCompilerServices,
     trace: BindingTrace
 ) {
-    configureModule(moduleContext, platform, platformVersion)
+    configureModule(moduleContext, platform, platformVersion, compilerServices)
     useInstance(trace)
 }
 
@@ -93,9 +97,10 @@ fun createContainerForBodyResolve(
     platform: TargetPlatform,
     statementFilter: StatementFilter,
     targetPlatformVersion: TargetPlatformVersion,
+    compilerServices: PlatformDependentCompilerServices,
     languageVersionSettings: LanguageVersionSettings
-): StorageComponentContainer = createContainer("BodyResolve", platform) {
-    configureModule(moduleContext, platform, targetPlatformVersion, bindingTrace)
+): StorageComponentContainer = createContainer("BodyResolve", compilerServices) {
+    configureModule(moduleContext, platform, targetPlatformVersion, compilerServices, bindingTrace)
 
     useInstance(statementFilter)
 
@@ -114,9 +119,10 @@ fun createContainerForLazyBodyResolve(
     platform: TargetPlatform,
     bodyResolveCache: BodyResolveCache,
     targetPlatformVersion: TargetPlatformVersion,
+    compilerServices: PlatformDependentCompilerServices,
     languageVersionSettings: LanguageVersionSettings
-): StorageComponentContainer = createContainer("LazyBodyResolve", platform) {
-    configureModule(moduleContext, platform, targetPlatformVersion, bindingTrace)
+): StorageComponentContainer = createContainer("LazyBodyResolve", compilerServices) {
+    configureModule(moduleContext, platform, targetPlatformVersion, compilerServices, bindingTrace)
 
     useInstance(kotlinCodeAnalyzer)
     useInstance(kotlinCodeAnalyzer.fileScopeProvider)
@@ -136,9 +142,10 @@ fun createContainerForLazyLocalClassifierAnalyzer(
     targetPlatformVersion: TargetPlatformVersion,
     languageVersionSettings: LanguageVersionSettings,
     statementFilter: StatementFilter,
-    localClassDescriptorHolder: LocalClassDescriptorHolder
-): StorageComponentContainer = createContainer("LocalClassifierAnalyzer", platform) {
-    configureModule(moduleContext, platform, targetPlatformVersion, bindingTrace)
+    localClassDescriptorHolder: LocalClassDescriptorHolder,
+    compilerServices: PlatformDependentCompilerServices
+): StorageComponentContainer = createContainer("LocalClassifierAnalyzer", compilerServices) {
+    configureModule(moduleContext, platform, targetPlatformVersion, compilerServices, bindingTrace)
 
     useInstance(localClassDescriptorHolder)
     useInstance(lookupTracker)
@@ -167,10 +174,11 @@ fun createContainerForLazyResolve(
     bindingTrace: BindingTrace,
     platform: TargetPlatform,
     targetPlatformVersion: TargetPlatformVersion,
+    compilerServices: PlatformDependentCompilerServices,
     targetEnvironment: TargetEnvironment,
     languageVersionSettings: LanguageVersionSettings
-): StorageComponentContainer = createContainer("LazyResolve", platform) {
-    configureModule(moduleContext, platform, targetPlatformVersion, bindingTrace)
+): StorageComponentContainer = createContainer("LazyResolve", compilerServices) {
+    configureModule(moduleContext, platform, targetPlatformVersion, compilerServices, bindingTrace)
 
     useInstance(declarationProviderFactory)
     useInstance(languageVersionSettings)
@@ -191,6 +199,7 @@ fun createLazyResolveSession(moduleContext: ModuleContext, files: Collection<KtF
         BindingTraceContext(),
         CommonPlatform,
         TargetPlatformVersion.NoVersion,
+        CommonPlatformCompilerServices,
         CompilerEnvironment,
         LanguageVersionSettingsImpl.DEFAULT
     ).get<ResolveSession>()

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

@@ -96,5 +96,5 @@ abstract class PlatformConfiguratorBase(
     }
 }
 
-fun createContainer(id: String, platform: TargetPlatform, init: StorageComponentContainer.() -> Unit) =
-    composeContainer(id, platform.platformConfigurator.platformSpecificContainer, init)
+fun createContainer(id: String, compilerServices: PlatformDependentCompilerServices, init: StorageComponentContainer.() -> Unit) =
+    composeContainer(id, compilerServices.platformConfigurator.platformSpecificContainer, init)

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeFactory.kt

@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.psi.KtImportDirective
 import org.jetbrains.kotlin.psi.KtImportInfo
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.ImportPath
-import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.TemporaryBindingTrace
 import org.jetbrains.kotlin.resolve.extensions.ExtraImportsProviderExtension
 import org.jetbrains.kotlin.resolve.scopes.*
@@ -40,13 +40,13 @@ data class FileScopes(val lexicalScope: LexicalScope, val importingScope: Import
 class FileScopeFactory(
     private val topLevelDescriptorProvider: TopLevelDescriptorProvider,
     private val bindingTrace: BindingTrace,
-    private val targetPlatform: TargetPlatform,
+    private val compilerServices: PlatformDependentCompilerServices,
     private val components: ImportResolutionComponents
 ) {
     private val defaultImports =
-        targetPlatform.getDefaultImports(components.languageVersionSettings, includeLowPriorityImports = false).map(::DefaultImportImpl)
+        compilerServices.getDefaultImports(components.languageVersionSettings, includeLowPriorityImports = false).map(::DefaultImportImpl)
 
-    private val defaultLowPriorityImports = targetPlatform.defaultLowPriorityImports.map(::DefaultImportImpl)
+    private val defaultLowPriorityImports = compilerServices.defaultLowPriorityImports.map(::DefaultImportImpl)
 
     private class DefaultImportImpl(private val importPath: ImportPath) : KtImportInfo {
         override val isAllUnder: Boolean get() = importPath.isAllUnder
@@ -95,7 +95,7 @@ class FileScopeFactory(
             tempTrace,
             packageFragment = null,
             aliasImportNames = aliasImportNames,
-            excludedImports = targetPlatform.excludedImports
+            excludedImports = compilerServices.excludedImports
         )
         val lowPriority = createDefaultImportResolver(
             AllUnderImportsIndexed(defaultLowPriorityImports.also { imports ->

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

@@ -61,6 +61,7 @@ class LocalClassifierAnalyzer(
     private val typeResolver: TypeResolver,
     private val annotationResolver: AnnotationResolver,
     private val platform: TargetPlatform,
+    private val compilerServices: PlatformDependentCompilerServices,
     private val lookupTracker: LookupTracker,
     private val supertypeLoopChecker: SupertypeLoopChecker,
     private val targetPlatformVersion: TargetPlatformVersion,
@@ -103,7 +104,8 @@ class LocalClassifierAnalyzer(
                 delegationFilter,
                 wrappedTypeFactory,
                 substitutingScopeProvider
-            )
+            ),
+            compilerServices
         )
 
         container.get<LazyTopDownAnalyzer>().analyzeDeclarations(