Refactor: Move TargetPlatform to frontend, make it expose platform dependant resolve services

AdditionalCheckerProvider -> PlatformConfigurator which operates directly on container
2015-07-22 20:18:38 +03:00
parent b452c20cc2
commit 84b8ed00c5
55 changed files with 309 additions and 311 deletions
@@ -24,12 +24,12 @@ import org.jetbrains.kotlin.frontend.java.di.configureJavaTopDownAnalysis
 import org.jetbrains.kotlin.incremental.components.UsageCollector
 import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
 import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver
-import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.BodyResolveCache
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
 import org.jetbrains.kotlin.resolve.jvm.JavaClassFinderPostConstruct
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformConfigurator
 import org.jetbrains.kotlin.resolve.lazy.FileScopeProvider
 import org.jetbrains.kotlin.resolve.lazy.FileScopeProviderImpl
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
@@ -39,7 +39,7 @@ public fun createContainerForReplWithJava(
        moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory,
        moduleContentScope: GlobalSearchScope, additionalFileScopeProvider: FileScopeProvider.AdditionalScopes
 ): ContainerForReplWithJava = createContainer("ReplWithJava") {
-    configureModule(moduleContext, KotlinJvmCheckerProvider(moduleContext.module), bindingTrace)
+    configureModule(moduleContext, JvmPlatformConfigurator, bindingTrace)
    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, UsageCollector.DO_NOTHING)

    useInstance(additionalFileScopeProvider)
@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.container.*
 import org.jetbrains.kotlin.context.LazyResolveToken
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.frontend.di.configureModule
+import org.jetbrains.kotlin.incremental.components.UsageCollector
 import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
 import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider
 import org.jetbrains.kotlin.load.java.components.*
@@ -31,8 +32,6 @@ import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl
 import org.jetbrains.kotlin.load.java.structure.impl.JavaPropertyInitializerEvaluatorImpl
 import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava
 import org.jetbrains.kotlin.load.kotlin.JvmVirtualFileFinderFactory
-import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
-import org.jetbrains.kotlin.incremental.components.UsageCollector
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.BodyResolveCache
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer
@@ -40,6 +39,7 @@ import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
 import org.jetbrains.kotlin.resolve.jvm.JavaClassFinderPostConstruct
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformConfigurator
 import org.jetbrains.kotlin.resolve.lazy.FileScopeProviderImpl
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
@@ -74,7 +74,7 @@ public fun createContainerForLazyResolveWithJava(
        moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory,
        moduleContentScope: GlobalSearchScope, moduleClassResolver: ModuleClassResolver
 ): Pair<ResolveSession, JavaDescriptorResolver> = createContainer("LazyResolveWithJava") {
-    configureModule(moduleContext, KotlinJvmCheckerProvider(moduleContext.module), bindingTrace)
+    configureModule(moduleContext, JvmPlatformConfigurator, bindingTrace)
    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, UsageCollector.DO_NOTHING)

    useInstance(moduleClassResolver)
@@ -97,7 +97,7 @@ public fun createContainerForTopDownAnalyzerForJvm(
        moduleContentScope: GlobalSearchScope,
        usageCollector: UsageCollector
 ): ContainerForTopDownAnalyzerForJvm = createContainer("TopDownAnalyzerForJvm") {
-    configureModule(moduleContext, KotlinJvmCheckerProvider(moduleContext.module), bindingTrace)
+    configureModule(moduleContext, JvmPlatformConfigurator, bindingTrace)
    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, usageCollector)

    useInstance(declarationProviderFactory)
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2010-2015 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.resolve.jvm.platform
+
+import org.jetbrains.kotlin.resolve.PlatformConfigurator
+import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.types.DynamicTypesSettings
+
+public object JvmPlatform : TargetPlatform("JVM", DynamicTypesSettings()) {
+    override val platformConfigurator: PlatformConfigurator = JvmPlatformConfigurator
+}
@@ -14,9 +14,11 @@
 * limitations under the License.
 */

-package org.jetbrains.kotlin.load.kotlin
+package org.jetbrains.kotlin.resolve.jvm.platform

 import org.jetbrains.kotlin.cfg.WhenChecker
+import org.jetbrains.kotlin.container.StorageComponentContainer
+import org.jetbrains.kotlin.container.useImpl
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.diagnostics.Errors
@@ -24,6 +26,8 @@ import org.jetbrains.kotlin.jvm.RuntimeAssertionsTypeChecker
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.load.java.lazy.types.isMarkedNotNull
 import org.jetbrains.kotlin.load.java.lazy.types.isMarkedNullable
+import org.jetbrains.kotlin.load.kotlin.JavaAnnotationCallChecker
+import org.jetbrains.kotlin.load.kotlin.JavaAnnotationMethodCallChecker
 import org.jetbrains.kotlin.load.kotlin.nativeDeclarations.NativeFunChecker
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
@@ -52,21 +56,36 @@ import org.jetbrains.kotlin.types.expressions.SenselessComparisonChecker
 import org.jetbrains.kotlin.types.flexibility
 import org.jetbrains.kotlin.types.isFlexible

-public class KotlinJvmCheckerProvider(private val module: ModuleDescriptor) : AdditionalCheckerProvider(
-        additionalDeclarationCheckers = listOf(PlatformStaticAnnotationChecker(),
-                                               LocalFunInlineChecker(),
-                                               ReifiedTypeParameterAnnotationChecker(),
-                                               NativeFunChecker(),
-                                               OverloadsAnnotationChecker(),
-                                               PublicFieldAnnotationChecker()),
+public object JvmPlatformConfigurator : PlatformConfigurator(
+        additionalDeclarationCheckers = listOf(
+                PlatformStaticAnnotationChecker(),
+                LocalFunInlineChecker(),
+                ReifiedTypeParameterAnnotationChecker(),
+                NativeFunChecker(),
+                OverloadsAnnotationChecker(),
+                PublicFieldAnnotationChecker()
+        ),

-        additionalCallCheckers = listOf(NeedSyntheticChecker(), JavaAnnotationCallChecker(),
-                                        JavaAnnotationMethodCallChecker(), TraitDefaultMethodCallChecker(),
-                                        ReflectionAPICallChecker(module)),
+        additionalCallCheckers = listOf(
+                NeedSyntheticChecker(),
+                JavaAnnotationCallChecker(),
+                JavaAnnotationMethodCallChecker(),
+                TraitDefaultMethodCallChecker()
+        ),

-        additionalTypeCheckers = listOf(JavaNullabilityWarningsChecker(), RuntimeAssertionsTypeChecker),
+        additionalTypeCheckers = listOf(
+                JavaNullabilityWarningsChecker(),
+                RuntimeAssertionsTypeChecker
+        ),
        additionalSymbolUsageValidators = listOf()
-)
+) {
+
+    override fun configure(container: StorageComponentContainer) {
+        super.configure(container)
+
+        container.useImpl<ReflectionAPICallChecker>()
+    }
+}

 public class LocalFunInlineChecker : DeclarationChecker {

@@ -145,7 +164,7 @@ public class OverloadsAnnotationChecker: DeclarationChecker {
            diagnosticHolder.report(ErrorsJvm.OVERLOADS_ABSTRACT.on(declaration))
        }
        else if ((!descriptor.getVisibility().isPublicAPI() && descriptor.getVisibility() != Visibilities.INTERNAL) ||
-            DescriptorUtils.isLocal(descriptor)) {
+                 DescriptorUtils.isLocal(descriptor)) {
            diagnosticHolder.report(ErrorsJvm.OVERLOADS_PRIVATE.on(declaration))
        }
        else if (descriptor.getValueParameters().none { it.declaresDefaultValue() }) {
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.types.DynamicTypesSettings
 import org.jetbrains.kotlin.types.expressions.*

 public fun StorageComponentContainer.configureModule(
-        moduleContext: ModuleContext, additionalCheckerProvider: AdditionalCheckerProvider
+        moduleContext: ModuleContext, platformConfigurator: PlatformConfigurator
 ) {
    useInstance(moduleContext)
    useInstance(moduleContext.module)
@@ -41,33 +41,25 @@ public fun StorageComponentContainer.configureModule(
    useInstance(moduleContext.storageManager)
    useInstance(moduleContext.builtIns)
    useInstance(moduleContext.platformToKotlinClassMap)
-    useInstance(additionalCheckerProvider)
-    useInstance(additionalCheckerProvider.symbolUsageValidator)

-    additionalCheckerProvider.declarationCheckers.forEach {
-        useInstance(it)
-    }
-    additionalCheckerProvider.typeCheckers.forEach {
-        useInstance(it)
-    }
-    additionalCheckerProvider.callCheckers.forEach {
-        useInstance(it)
-    }
+    useInstance(platformConfigurator)
+
+    platformConfigurator.configure(this)
 }

 public fun StorageComponentContainer.configureModule(
-        moduleContext: ModuleContext, additionalCheckerProvider: AdditionalCheckerProvider, trace: BindingTrace
+        moduleContext: ModuleContext, platformConfigurator: PlatformConfigurator, trace: BindingTrace
 ) {
-    configureModule(moduleContext, additionalCheckerProvider)
+    configureModule(moduleContext, platformConfigurator)
    useInstance(trace)
 }

 public fun createContainerForBodyResolve(
        moduleContext: ModuleContext, bindingTrace: BindingTrace,
-        additionalCheckerProvider: AdditionalCheckerProvider, statementFilter: StatementFilter,
+        platformConfigurator: PlatformConfigurator, statementFilter: StatementFilter,
        dynamicTypesSettings: DynamicTypesSettings
 ): StorageComponentContainer = createContainer("BodyResolve") {
-    configureModule(moduleContext, additionalCheckerProvider, bindingTrace)
+    configureModule(moduleContext, platformConfigurator, bindingTrace)

    useInstance(statementFilter)
    useInstance(dynamicTypesSettings)
@@ -77,11 +69,11 @@ public fun createContainerForBodyResolve(

 public fun createContainerForLazyBodyResolve(
        moduleContext: ModuleContext, kotlinCodeAnalyzer: KotlinCodeAnalyzer,
-        bindingTrace: BindingTrace, additionalCheckerProvider: AdditionalCheckerProvider,
+        bindingTrace: BindingTrace, platformConfigurator: PlatformConfigurator,
        dynamicTypesSettings: DynamicTypesSettings,
        bodyResolveCache: BodyResolveCache
 ): StorageComponentContainer = createContainer("LazyBodyResolve") {
-    configureModule(moduleContext, additionalCheckerProvider, bindingTrace)
+    configureModule(moduleContext, platformConfigurator, bindingTrace)

    useInstance(kotlinCodeAnalyzer)
    useInstance(kotlinCodeAnalyzer.getFileScopeProvider())
@@ -93,11 +85,11 @@ public fun createContainerForLazyBodyResolve(
 public fun createContainerForLazyLocalClassifierAnalyzer(
        moduleContext: ModuleContext,
        bindingTrace: BindingTrace,
-        additionalCheckerProvider: AdditionalCheckerProvider,
+        platformConfigurator: PlatformConfigurator,
        dynamicTypesSettings: DynamicTypesSettings,
        localClassDescriptorHolder: LocalClassDescriptorHolder
 ): StorageComponentContainer = createContainer("LocalClassifierAnalyzer") {
-    configureModule(moduleContext, additionalCheckerProvider, bindingTrace)
+    configureModule(moduleContext, platformConfigurator, bindingTrace)

    useInstance(dynamicTypesSettings)
    useInstance(localClassDescriptorHolder)
@@ -114,9 +106,9 @@ public fun createContainerForLazyLocalClassifierAnalyzer(

 private fun createContainerForLazyResolve(
        moduleContext: ModuleContext, declarationProviderFactory: DeclarationProviderFactory, bindingTrace: BindingTrace,
-        additionalCheckerProvider: AdditionalCheckerProvider, dynamicTypesSettings: DynamicTypesSettings
+        platformConfigurator: PlatformConfigurator, dynamicTypesSettings: DynamicTypesSettings
 ): StorageComponentContainer = createContainer("LazyResolve") {
-    configureModule(moduleContext, additionalCheckerProvider, bindingTrace)
+    configureModule(moduleContext, platformConfigurator, bindingTrace)

    useInstance(dynamicTypesSettings)
    useInstance(declarationProviderFactory)
@@ -128,14 +120,14 @@ private fun createContainerForLazyResolve(

 public fun createLazyResolveSession(
        moduleContext: ModuleContext, declarationProviderFactory: DeclarationProviderFactory, bindingTrace: BindingTrace,
-        additionalCheckerProvider: AdditionalCheckerProvider, dynamicTypesSettings: DynamicTypesSettings
+        platformConfigurator: PlatformConfigurator, dynamicTypesSettings: DynamicTypesSettings
 ): ResolveSession = createContainerForLazyResolve(
-        moduleContext, declarationProviderFactory, bindingTrace, additionalCheckerProvider, dynamicTypesSettings
+        moduleContext, declarationProviderFactory, bindingTrace, platformConfigurator, dynamicTypesSettings
 ).get<ResolveSession>()

 public fun createContainerForMacros(project: Project, module: ModuleDescriptor): ContainerForMacros {
    val componentContainer = createContainer("Macros") {
-        configureModule(ModuleContext(module, project), AdditionalCheckerProvider.DefaultProvider)
+        configureModule(ModuleContext(module, project), TargetPlatform.Default.platformConfigurator)
        useImpl<ExpressionTypingServices>()
    }
    return ContainerForMacros(componentContainer)
@@ -1,41 +0,0 @@
-/*
- * Copyright 2010-2015 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.resolve
-
-import org.jetbrains.kotlin.resolve.calls.checkers.*
-import org.jetbrains.kotlin.resolve.validation.DeprecatedSymbolValidator
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
-
-private val DEFAULT_DECLARATION_CHECKERS = listOf(DataClassAnnotationChecker())
-private val DEFAULT_CALL_CHECKERS = listOf(CapturingInClosureChecker(), InlineCheckerWrapper(), ReifiedTypeParameterSubstitutionChecker())
-private val DEFAULT_TYPE_CHECKERS = emptyList<AdditionalTypeChecker>()
-private val DEFAULT_VALIDATORS = listOf(DeprecatedSymbolValidator())
-
-public abstract class AdditionalCheckerProvider(
-        additionalDeclarationCheckers: List<DeclarationChecker>,
-        additionalCallCheckers: List<CallChecker>,
-        additionalTypeCheckers: List<AdditionalTypeChecker>,
-        additionalSymbolUsageValidators: List<SymbolUsageValidator>
-) {
-
-    public val declarationCheckers: List<DeclarationChecker> = DEFAULT_DECLARATION_CHECKERS + additionalDeclarationCheckers
-    public val callCheckers: List<CallChecker> = DEFAULT_CALL_CHECKERS + additionalCallCheckers
-    public val typeCheckers: List<AdditionalTypeChecker> = DEFAULT_TYPE_CHECKERS + additionalTypeCheckers
-    public val symbolUsageValidator: SymbolUsageValidator = SymbolUsageValidator.Composite(DEFAULT_VALIDATORS + additionalSymbolUsageValidators)
-
-    public object DefaultProvider : AdditionalCheckerProvider(listOf(), listOf(), listOf(), listOf()) {}
-}
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2010-2015 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.resolve
+
+import org.jetbrains.kotlin.container.StorageComponentContainer
+import org.jetbrains.kotlin.container.useInstance
+import org.jetbrains.kotlin.resolve.calls.checkers.*
+import org.jetbrains.kotlin.resolve.validation.DeprecatedSymbolValidator
+import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
+import org.jetbrains.kotlin.types.DynamicTypesSettings
+
+public abstract class TargetPlatform(
+        public val platformName: String,
+        public val dynamicTypesSettings: DynamicTypesSettings
+) {
+    override fun toString(): String {
+        return platformName
+    }
+
+    public abstract val platformConfigurator: PlatformConfigurator
+
+    public object Default : TargetPlatform("Default", DynamicTypesSettings()) {
+        override val platformConfigurator = PlatformConfigurator(listOf(), listOf(), listOf(), listOf())
+    }
+}
+
+private val DEFAULT_DECLARATION_CHECKERS = listOf(DataClassAnnotationChecker())
+private val DEFAULT_CALL_CHECKERS = listOf(CapturingInClosureChecker(), InlineCheckerWrapper(), ReifiedTypeParameterSubstitutionChecker())
+private val DEFAULT_TYPE_CHECKERS = emptyList<AdditionalTypeChecker>()
+private val DEFAULT_VALIDATORS = listOf(DeprecatedSymbolValidator())
+
+
+public open class PlatformConfigurator(
+        additionalDeclarationCheckers: List<DeclarationChecker>,
+        additionalCallCheckers: List<CallChecker>,
+        additionalTypeCheckers: List<AdditionalTypeChecker>,
+        additionalSymbolUsageValidators: List<SymbolUsageValidator>
+) {
+
+    private val declarationCheckers: List<DeclarationChecker> = DEFAULT_DECLARATION_CHECKERS + additionalDeclarationCheckers
+    private val callCheckers: List<CallChecker> = DEFAULT_CALL_CHECKERS + additionalCallCheckers
+    private val typeCheckers: List<AdditionalTypeChecker> = DEFAULT_TYPE_CHECKERS + additionalTypeCheckers
+    private val symbolUsageValidator: SymbolUsageValidator = SymbolUsageValidator.Composite(DEFAULT_VALIDATORS + additionalSymbolUsageValidators)
+
+    public open fun configure(container: StorageComponentContainer) {
+        with (container) {
+            declarationCheckers.forEach { useInstance(it) }
+            callCheckers.forEach { useInstance(it) }
+            typeCheckers.forEach { useInstance(it) }
+            useInstance(symbolUsageValidator)
+        }
+    }
+}
@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.types.expressions;

 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.StatementFilter;
 import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.types.expressions

 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.annotations.NotNull
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.GlobalContext
 import org.jetbrains.kotlin.context.withModule
@@ -53,7 +52,7 @@ public class LocalClassifierAnalyzer(
        private val funcionDescriptorResolver: FunctionDescriptorResolver,
        private val typeResolver: TypeResolver,
        private val annotationResolver: AnnotationResolver,
-        private val additionalCheckerProvider: AdditionalCheckerProvider,
+        private val platformConfigurator: PlatformConfigurator,
        private val dynamicTypesSettings: DynamicTypesSettings
 ) {
    fun processClassOrObject(
@@ -67,7 +66,7 @@ public class LocalClassifierAnalyzer(
        val container = createContainerForLazyLocalClassifierAnalyzer(
                moduleContext,
                context.trace,
-                additionalCheckerProvider,
+                platformConfigurator,
                dynamicTypesSettings,
                LocalClassDescriptorHolder(
                        scope,
@@ -26,9 +26,9 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.frontend.di.createLazyResolveSession
-import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformConfigurator
 import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
@@ -53,7 +53,7 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
                context,
                FileBasedDeclarationProviderFactory(context.storageManager, listOf(psiFile)),
                CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
-                KotlinJvmCheckerProvider(context.module), DynamicTypesSettings()
+                JvmPlatformConfigurator, DynamicTypesSettings()
        )

        context.initializeModuleContents(resolveSession.getPackageFragmentProvider())
@@ -24,17 +24,16 @@ import org.jetbrains.kotlin.container.useImpl
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.frontend.di.configureModule
-import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider
 import org.jetbrains.kotlin.resolve.DescriptorResolver
 import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver
 import org.jetbrains.kotlin.resolve.TypeResolver
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformConfigurator
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices
 import org.jetbrains.kotlin.types.expressions.FakeCallResolver

 public fun createContainerForTests(project: Project, module: ModuleDescriptor): ContainerForTests {
    return ContainerForTests(createContainer("Tests") {
-        configureModule(ModuleContext(module, project), KotlinJvmCheckerProvider(module))
+        configureModule(ModuleContext(module, project), JvmPlatformConfigurator)
        useImpl<ExpressionTypingServices>()
    })
 }
@@ -105,7 +105,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
                    new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(),
                                                            Collections.singleton(aClass.getContainingJetFile())),
                    new BindingTraceContext(),
-                    AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
+                    TargetPlatform.Default.platformConfigurator,
                    new DynamicTypesSettings()
            );