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

AdditionalCheckerProvider -> PlatformConfigurator which operates directly on container

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

@@ -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)

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

@@ -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()) {}
-}

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

@@ -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)
+        }
+    }
+}

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java

@@ -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;

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

@@ -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,