[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)
2019-03-05 18:14:11 +03:00
parent 83914614b9
commit f2a0a809f1
41 changed files with 217 additions and 98 deletions
@@ -18,7 +18,7 @@ class FirDefaultSimpleImportingScope(session: FirSession) : FirAbstractSimpleImp

    override val simpleImports = run {
        val importResolveTransformer = FirImportResolveTransformer(session)
-        session.moduleInfo?.platform?.getDefaultImports(LanguageVersionSettingsImpl.DEFAULT, true)
+        session.moduleInfo?.compilerServices?.getDefaultImports(LanguageVersionSettingsImpl.DEFAULT, true)
            ?.filter { !it.isAllUnder }
            ?.map {
                FirImportImpl(session, null, it.fqName, isAllUnder = false, aliasName = null)
@@ -14,7 +14,7 @@ class FirDefaultStarImportingScope(session: FirSession, lookupInFir: Boolean = f
    FirAbstractStarImportingScope(session, lookupInFir) {

    // TODO: put languageVersionSettings into FirSession?
-    override val starImports = session.moduleInfo?.platform?.getDefaultImports(LanguageVersionSettingsImpl.DEFAULT, true)
+    override val starImports = session.moduleInfo?.compilerServices?.getDefaultImports(LanguageVersionSettingsImpl.DEFAULT, true)
        ?.filter { it.isAllUnder }
        ?.map {
            FirResolvedImportImpl(
@@ -23,8 +23,10 @@ import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
 import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.MultiTargetPlatform
+import org.jetbrains.kotlin.resolve.PlatformDependentCompilerServices
 import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformCompilerServices
 import java.io.File
 import java.util.*

@@ -144,6 +146,9 @@ abstract class AbstractFirDiagnosticsSmokeTest : BaseDiagnosticsTest() {
        override val platform: TargetPlatform?
            get() = JvmPlatform

+        override val compilerServices: PlatformDependentCompilerServices
+            get() = JvmPlatformCompilerServices
+
        override fun dependencies(): List<ModuleInfo> {
            return listOf(this)
        }
@@ -153,6 +158,9 @@ abstract class AbstractFirDiagnosticsSmokeTest : BaseDiagnosticsTest() {
        override val platform: TargetPlatform?
            get() = JvmPlatform

+        override val compilerServices: PlatformDependentCompilerServices
+            get() = JvmPlatformCompilerServices
+
        val dependencies = mutableListOf<ModuleInfo>(this)
        override fun dependencies(): List<ModuleInfo> {
            return dependencies
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analyzer

 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.PlatformDependentCompilerServices
 import org.jetbrains.kotlin.resolve.TargetPlatform


@@ -16,6 +17,7 @@ interface ModuleInfo {
    fun dependencies(): List<ModuleInfo>
    val expectedBy: List<ModuleInfo> get() = emptyList()
    val platform: TargetPlatform? get() = null
+    val compilerServices: PlatformDependentCompilerServices? get() = null
    fun modulesWhoseInternalsAreVisible(): Collection<ModuleInfo> = listOf()
    val capabilities: Map<ModuleDescriptor.Capability<*>, Any?>
        get() = mapOf(Capability to this)
@@ -28,7 +30,7 @@ interface ModuleInfo {
    // but if they are present, they should come after JVM built-ins in the dependencies list, because JVM built-ins contain
    // additional members dependent on the JDK
    fun dependencyOnBuiltIns(): ModuleInfo.DependencyOnBuiltIns =
-        platform?.dependencyOnBuiltIns() ?: ModuleInfo.DependencyOnBuiltIns.LAST
+        compilerServices?.dependencyOnBuiltIns() ?: ModuleInfo.DependencyOnBuiltIns.LAST

    //TODO: (module refactoring) provide dependency on builtins after runtime in IDEA
    enum class DependencyOnBuiltIns { NONE, AFTER_SDK, LAST }
@@ -14,6 +14,11 @@ import org.jetbrains.kotlin.storage.StorageManager
 import java.util.*

 abstract class TargetPlatform(val platformName: String) {
+    override fun toString() = platformName
+    abstract val platform: MultiTargetPlatform
+}
+
+abstract class PlatformDependentCompilerServices {
    private data class DefaultImportsKey(val includeKotlinComparisons: Boolean, val includeLowPriorityImports: Boolean)

    private val defaultImports = LockBasedStorageManager("TargetPlatform").let { storageManager ->
@@ -42,8 +47,6 @@ abstract class TargetPlatform(val platformName: String) {
        }
    }

-    override fun toString() = platformName
-
    abstract val platformConfigurator: PlatformConfigurator

    open val defaultLowPriorityImports: List<ImportPath> get() = emptyList()
@@ -60,8 +63,6 @@ abstract class TargetPlatform(val platformName: String) {

    open val excludedImports: List<FqName> get() = emptyList()

-    abstract val multiTargetPlatform: MultiTargetPlatform
-
    // This function is used in "cat.helm.clean:0.1.1-SNAPSHOT": https://plugins.jetbrains.com/plugin/index?xmlId=cat.helm.clean
    @Suppress("DeprecatedCallableAddReplaceWith", "unused")
    @Deprecated("Use getDefaultImports(LanguageVersionSettings, Boolean) instead.", level = DeprecationLevel.ERROR)
@@ -44,6 +44,7 @@ import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformCompilerServices
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
@@ -92,8 +93,8 @@ fun createContainerForLazyResolveWithJava(
        useBuiltInsProvider: Boolean,
        configureJavaClassFinder: (StorageComponentContainer.() -> Unit)? = null,
        javaClassTracker: JavaClassesTracker? = null
-): StorageComponentContainer = createContainer("LazyResolveWithJava", JvmPlatform) {
-    configureModule(moduleContext, JvmPlatform, jvmTarget, bindingTrace)
+): StorageComponentContainer = createContainer("LazyResolveWithJava", JvmPlatformCompilerServices) {
+    configureModule(moduleContext, JvmPlatform, jvmTarget, JvmPlatformCompilerServices, bindingTrace)
    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, lookupTracker, expectActualTracker)

    if (configureJavaClassFinder != null) {
@@ -23,6 +23,10 @@ import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.storage.StorageManager

 object JvmPlatform : TargetPlatform("JVM") {
+    override val platform = MultiTargetPlatform.Specific(platformName)
+}
+
+object JvmPlatformCompilerServices : PlatformDependentCompilerServices() {
    override fun computePlatformSpecificDefaultImports(storageManager: StorageManager, result: MutableList<ImportPath>) {
        result.add(ImportPath.fromString("kotlin.jvm.*"))

@@ -40,6 +44,4 @@ object JvmPlatform : TargetPlatform("JVM") {
    override val defaultLowPriorityImports: List<ImportPath> = listOf(ImportPath.fromString("java.lang.*"))

    override val platformConfigurator: PlatformConfigurator = JvmPlatformConfigurator
-
-    override val multiTargetPlatform = MultiTargetPlatform.Specific(platformName)
 }
@@ -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
+}
@@ -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)
    }
 }
@@ -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>()
@@ -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)
@@ -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 ->
@@ -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(
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
 import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.config.JsConfig
-import org.jetbrains.kotlin.js.resolve.JsPlatform
+import org.jetbrains.kotlin.js.resolve.JsPlatformCompilerServices
 import org.jetbrains.kotlin.js.resolve.MODULE_KIND
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtFile
@@ -84,7 +84,7 @@ abstract class AbstractDiagnosticsTestWithJsStdLib : AbstractDiagnosticsTest() {
    override fun shouldSkipJvmSignatureDiagnostics(groupedByModule: Map<TestModule?, List<TestFile>>): Boolean = true

    override fun createModule(moduleName: String, storageManager: StorageManager): ModuleDescriptorImpl =
-        ModuleDescriptorImpl(Name.special("<$moduleName>"), storageManager, JsPlatform.builtIns)
+        ModuleDescriptorImpl(Name.special("<$moduleName>"), storageManager, JsPlatformCompilerServices.builtIns)

    override fun createSealedModule(storageManager: StorageManager): ModuleDescriptorImpl {
        val module = createModule("kotlin-js-test-module", storageManager)
@@ -7,13 +7,16 @@ package org.jetbrains.kotlin.fir

 import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.PlatformDependentCompilerServices
 import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformCompilerServices

 class FirTestModuleInfo(
    override val name: Name = Name.identifier("TestModule"),
    val dependencies: MutableList<ModuleInfo> = mutableListOf(),
-    override val platform: TargetPlatform = JvmPlatform
+    override val platform: TargetPlatform = JvmPlatform,
+    override val compilerServices: PlatformDependentCompilerServices = JvmPlatformCompilerServices
 ) : ModuleInfo {
    override fun dependencies(): List<ModuleInfo> = dependencies
 }
@@ -22,11 +22,15 @@ import org.jetbrains.kotlin.analyzer.LanguageSettingsProvider
 import org.jetbrains.kotlin.analyzer.ModuleContent
 import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.analyzer.ResolverForProjectImpl
+import org.jetbrains.kotlin.analyzer.common.CommonPlatform
+import org.jetbrains.kotlin.analyzer.common.CommonPlatformCompilerServices
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.resolve.PlatformDependentCompilerServices
+import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.jvm.JvmResolverForModuleFactory
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters

@@ -61,4 +65,10 @@ private class TestModule(val dependsOnBuiltIns: Boolean) : ModuleInfo {
                ModuleInfo.DependencyOnBuiltIns.LAST
            else
                ModuleInfo.DependencyOnBuiltIns.NONE
+
+    override val platform: TargetPlatform
+        get() = CommonPlatform
+
+    override val compilerServices: PlatformDependentCompilerServices?
+        get() = CommonPlatformCompilerServices
 }
@@ -29,13 +29,14 @@ import org.jetbrains.kotlin.frontend.di.configureModule
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformCompilerServices
 import org.jetbrains.kotlin.types.SubstitutingScopeProviderImpl
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices
 import org.jetbrains.kotlin.types.expressions.FakeCallResolver

 fun createContainerForTests(project: Project, module: ModuleDescriptor): ContainerForTests {
-    return ContainerForTests(createContainer("Tests", JvmPlatform) {
-        configureModule(ModuleContext(module, project), JvmPlatform, JvmTarget.DEFAULT)
+    return ContainerForTests(createContainer("Tests", JvmPlatformCompilerServices) {
+        configureModule(ModuleContext(module, project), JvmPlatform, JvmTarget.DEFAULT, JvmPlatformCompilerServices)
        useInstance(LanguageVersionSettingsImpl.DEFAULT)
        useImpl<SubstitutingScopeProviderImpl>()
        useImpl<AnnotationResolverImpl>()
@@ -34,11 +34,15 @@ import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.resolve.PlatformDependentCompilerServices
+import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.constants.EnumValue
 import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
 import org.jetbrains.kotlin.resolve.jvm.JvmResolverForModuleFactory
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformCompilerServices
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TestJdkKind
@@ -56,6 +60,12 @@ class MultiModuleJavaAnalysisCustomTest : KtUsefulTestCase() {
    ) : ModuleInfo {
        override fun dependencies() = _dependencies()
        override val name = Name.special("<$_name>")
+
+        override val platform: TargetPlatform
+            get() = JvmPlatform
+
+        override val compilerServices: PlatformDependentCompilerServices?
+            get() = JvmPlatformCompilerServices
    }

    fun testJavaEntitiesBelongToCorrectModule() {
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.js.config.JsConfig
 import org.jetbrains.kotlin.js.facade.K2JSTranslator
 import org.jetbrains.kotlin.js.facade.MainCallParameters
 import org.jetbrains.kotlin.js.facade.TranslationResult
-import org.jetbrains.kotlin.js.resolve.JsPlatform
+import org.jetbrains.kotlin.js.resolve.JsPlatformCompilerServices
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.serialization.AbstractVersionRequirementTest
@@ -76,7 +76,7 @@ class JsVersionRequirementTest : AbstractVersionRequirementTest() {

    private fun createModule(environment: KotlinCoreEnvironment): MutableModuleContext {
        val config = JsConfig(environment.project, environment.configuration)
-        return ContextForNewModule(ProjectContext(environment.project), Name.special("<test>"), JsPlatform.builtIns, null).apply {
+        return ContextForNewModule(ProjectContext(environment.project), Name.special("<test>"), JsPlatformCompilerServices.builtIns, null).apply {
            setDependencies(listOf(module) + config.moduleDescriptors + module.builtIns.builtInsModule)
        }
    }
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.config.JsConfig
-import org.jetbrains.kotlin.js.resolve.JsPlatform
+import org.jetbrains.kotlin.js.resolve.JsPlatformCompilerServices
 import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil.TEST_PACKAGE_FQNAME
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil.readModuleAsProto
@@ -94,7 +94,7 @@ class KotlinJavascriptSerializerTest : TestCaseWithTmpdir() {
    }

    private fun deserialize(metaFile: File): ModuleDescriptorImpl {
-        val module = KotlinTestUtils.createEmptyModule("<${KotlinTestUtils.TEST_MODULE_NAME}>", JsPlatform.builtIns)
+        val module = KotlinTestUtils.createEmptyModule("<${KotlinTestUtils.TEST_MODULE_NAME}>", JsPlatformCompilerServices.builtIns)
        val metadata = KotlinJavascriptMetadataUtils.loadMetadata(metaFile).single()

        val (header, packageFragmentProtos) = readModuleAsProto(metadata.body, metadata.version)