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()
            );

@@ -16,7 +16,6 @@

 package org.jetbrains.kotlin.resolve.lazy

-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analyzer.computeTypeInContext
 import org.jetbrains.kotlin.cfg.JetFlowInformationProvider
 import org.jetbrains.kotlin.container.get
@@ -26,20 +25,17 @@ import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.frontend.di.createContainerForBodyResolve
-import org.jetbrains.kotlin.resolve.util.getScopeAndDataFlowForAnalyzeFragment
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfo
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor
-import org.jetbrains.kotlin.resolve.scopes.ChainedScope
 import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.types.DynamicTypesSettings
+import org.jetbrains.kotlin.resolve.util.getScopeAndDataFlowForAnalyzeFragment
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull

@@ -392,9 +388,10 @@ public abstract class ElementResolver protected constructor(
    ): BodyResolver {
        val globalContext = SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker())
        val module = resolveSession.getModuleDescriptor()
+        val targetPlatform = getTargetPlatform(file)
        return createContainerForBodyResolve(
                globalContext.withProject(file.getProject()).withModule(module),
-                trace, createAdditionalCheckerProvider(file, module), statementFilter, getDynamicTypesSettings(file)
+                trace, targetPlatform.platformConfigurator, statementFilter, targetPlatform.dynamicTypesSettings
        ).get<BodyResolver>()
    }

@@ -466,9 +463,7 @@ public abstract class ElementResolver protected constructor(
        return null
    }

-    protected abstract fun createAdditionalCheckerProvider(file: JetFile, module: ModuleDescriptor): AdditionalCheckerProvider
-
-    protected abstract fun getDynamicTypesSettings(file: JetFile): DynamicTypesSettings
+    protected abstract fun getTargetPlatform(file: JetFile): TargetPlatform

    private class BodyResolveContextForLazy(
            private val topDownAnalysisMode: TopDownAnalysisMode,
@@ -19,17 +19,18 @@ package org.jetbrains.kotlin.idea.caches.resolve
 import com.intellij.openapi.project.Project
 import com.intellij.psi.*
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.idea.project.TargetPlatform
 import org.jetbrains.kotlin.load.java.sources.JavaSourceElement
 import org.jetbrains.kotlin.load.java.structure.*
 import org.jetbrains.kotlin.load.java.structure.impl.*
 import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.resolve.jvm.JvmResolverForModule
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.resolve.scopes.JetScope

 public object JavaResolveExtension : CacheExtension<(PsiElement) -> Pair<JavaDescriptorResolver, BindingContext>> {
-    override val platform: TargetPlatform = TargetPlatform.JVM
+    override val platform: TargetPlatform = JvmPlatform

    override fun getData(resolverProvider: ModuleResolverProvider): (PsiElement) -> Pair<JavaDescriptorResolver, BindingContext> {
        return {
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.frontend.di.createLazyResolveSession
 import org.jetbrains.kotlin.idea.framework.KotlinJavaScriptLibraryDetectionUtil
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
-import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider
+import org.jetbrains.kotlin.js.resolve.JsPlatformConfigurator
 import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
@@ -57,7 +57,7 @@ public object JsAnalyzerFacade : AnalyzerFacade<JsResolverForModule, PlatformAna
        )

        val resolveSession = createLazyResolveSession(
-                moduleContext, declarationProviderFactory, BindingTraceContext(), KotlinJsCheckerProvider, DynamicTypesAllowed()
+                moduleContext, declarationProviderFactory, BindingTraceContext(), JsPlatformConfigurator, DynamicTypesAllowed()
        )
        var packageFragmentProvider = resolveSession.getPackageFragmentProvider()

@@ -29,17 +29,13 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.idea.project.AnalyzerFacadeProvider
 import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies
-import org.jetbrains.kotlin.idea.project.TargetPlatform
-import org.jetbrains.kotlin.idea.project.TargetPlatform.JS
-import org.jetbrains.kotlin.idea.project.TargetPlatform.JVM
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
+import org.jetbrains.kotlin.js.resolve.JsPlatform
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.BindingTraceContext
-import org.jetbrains.kotlin.resolve.ImportPath
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver
+import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.utils.keysToMap
@@ -80,7 +76,7 @@ public class KotlinCacheService(val project: Project) {
        CachedValueProvider.Result.create(moduleResolverProvider, allDependencies)
    }

-    private val globalCachesPerPlatform = listOf(JVM, JS).keysToMap { platform -> GlobalCache(platform) }
+    private val globalCachesPerPlatform = listOf(JvmPlatform, JsPlatform).keysToMap { platform -> GlobalCache(platform) }

    private inner class GlobalCache(platform: TargetPlatform) {
        val librariesCache = KotlinResolveCache(
@@ -37,7 +37,6 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
 import org.jetbrains.kotlin.frontend.di.createContainerForLazyBodyResolve
 import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies
-import org.jetbrains.kotlin.idea.project.TargetPlatform
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.*
@@ -233,8 +232,8 @@ private object KotlinResolveDataProvider {
                    moduleContext,
                    resolveSession,
                    trace,
-                    targetPlatform.createAdditionalCheckerProvider(module),
-                    targetPlatform.getDynamicTypesSettings(),
+                    targetPlatform.platformConfigurator,
+                    targetPlatform.dynamicTypesSettings,
                    resolveSession.getBodyResolveCache()
            ).get<LazyTopDownAnalyzerForTopLevel>()

@@ -57,9 +57,9 @@ import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap;
 import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
 import org.jetbrains.kotlin.resolve.BindingTraceContext;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
+import org.jetbrains.kotlin.resolve.TargetPlatform;
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName;
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
@@ -254,8 +254,9 @@ public class JetSourceNavigationHelper {
                newModuleContext,
                providerFactory,
                new BindingTraceContext(),
-                AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
-                new DynamicTypesSettings());
+                TargetPlatform.Default.platformConfigurator,
+                new DynamicTypesSettings()
+        );

        newModuleContext.initializeModuleContents(resolveSession.getPackageFragmentProvider());
        return resolveSession;
@@ -24,13 +24,13 @@ import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.asJava.AsJavaPackage;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolvePackage;
-import org.jetbrains.kotlin.idea.project.TargetPlatform;
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector;
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil;
 import org.jetbrains.kotlin.psi.JetDeclaration;
 import org.jetbrains.kotlin.psi.JetElement;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;

 import static org.jetbrains.kotlin.idea.caches.resolve.ResolvePackage.getModuleInfo;

@@ -41,12 +41,12 @@ public class DuplicateJvmSignatureAnnotator implements Annotator {
        if (!ProjectRootsUtil.isInProjectSource(element)) return;

        PsiFile file = element.getContainingFile();
-        if (!(file instanceof JetFile) || TargetPlatformDetector.getPlatform((JetFile) file) != TargetPlatform.JVM) return;
+        if (!(file instanceof JetFile) || TargetPlatformDetector.getPlatform((JetFile) file) != JvmPlatform.INSTANCE$) return;

        Diagnostics otherDiagnostics = ResolvePackage.analyzeFully((JetElement) element).getDiagnostics();
        GlobalSearchScope moduleScope = getModuleInfo(element).contentScope();
        Diagnostics diagnostics = AsJavaPackage.getJvmSignatureDiagnostics(element, otherDiagnostics, moduleScope);
-        
+
        if (diagnostics == null) return;
        new JetPsiChecker().annotateElement(element, holder, diagnostics);
    }
@@ -17,19 +17,22 @@
 package org.jetbrains.kotlin.idea.project

 import org.jetbrains.kotlin.analyzer.AnalyzerFacade
-import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
 import org.jetbrains.kotlin.analyzer.ResolverForModule
-import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
 import org.jetbrains.kotlin.idea.caches.resolve.JsAnalyzerFacade
+import org.jetbrains.kotlin.js.resolve.JsPlatform
+import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
+import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform

 public object AnalyzerFacadeProvider {
    //NOTE: it's convenient that JS backend doesn't have platform parameters (for now)
    // otherwise we would be forced to add casts on the call site of setupResolverForProject
    public fun getAnalyzerFacade(targetPlatform: TargetPlatform): AnalyzerFacade<out ResolverForModule, JvmPlatformParameters> {
        return when (targetPlatform) {
-            TargetPlatform.JVM -> JvmAnalyzerFacade
-            TargetPlatform.JS -> JsAnalyzerFacade
-            else -> throw IllegalArgumentException("Unsupported platfrom: $targetPlatform")
+            JvmPlatform -> JvmAnalyzerFacade
+            JsPlatform -> JsAnalyzerFacade
+            else -> throw IllegalArgumentException("Unsupported platform: $targetPlatform")
        }
    }
 }
@@ -22,15 +22,14 @@ import com.intellij.psi.util.CachedValueProvider
 import com.intellij.psi.util.CachedValuesManager
 import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.util.containers.ContainerUtil
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.idea.stubindex.JetProbablyNothingFunctionShortNameIndex
 import org.jetbrains.kotlin.idea.stubindex.JetProbablyNothingPropertyShortNameIndex
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BodyResolveCache
 import org.jetbrains.kotlin.resolve.StatementFilter
+import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.lazy.*
-import org.jetbrains.kotlin.storage.MemoizedFunctionToNotNull

 public class ResolveElementCache(resolveSession: ResolveSession, private val project: Project) : ElementResolver(resolveSession), BodyResolveCache {
    // Recreate internal cache after change of modification count
@@ -76,7 +75,8 @@ public class ResolveElementCache(resolveSession: ResolveSession, private val pro

                val (bindingContext, statementFilter) = performElementAdditionalResolve(resolveElement, contextElement, BodyResolveMode.PARTIAL)

-                if (statementFilter == StatementFilter.NONE) { // partial resolve is not supported for the given declaration - full resolve performed instead
+                if (statementFilter == StatementFilter.NONE) {
+                    // partial resolve is not supported for the given declaration - full resolve performed instead
                    fullResolveMap[resolveElement] = bindingContext
                    return bindingContext
                }
@@ -102,11 +102,7 @@ public class ResolveElementCache(resolveSession: ResolveSession, private val pro
        }
    }

-    override fun createAdditionalCheckerProvider(file: JetFile, module: ModuleDescriptor)
-            = TargetPlatformDetector.getPlatform(file).createAdditionalCheckerProvider(module)
-
-    override fun getDynamicTypesSettings(file: JetFile)
-            = TargetPlatformDetector.getPlatform(file).getDynamicTypesSettings()
+    override fun getTargetPlatform(file: JetFile): TargetPlatform = TargetPlatformDetector.getPlatform(file)

    override fun probablyNothingCallableNames(): ProbablyNothingCallableNames {
        return object : ProbablyNothingCallableNames {
@@ -1,49 +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.idea.project;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider;
-import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
-import org.jetbrains.kotlin.types.DynamicTypesAllowed;
-import org.jetbrains.kotlin.types.DynamicTypesSettings;
-
-public interface TargetPlatform {
-    @NotNull
-    AdditionalCheckerProvider createAdditionalCheckerProvider(@NotNull ModuleDescriptor module);
-
-    @NotNull
-    DynamicTypesSettings getDynamicTypesSettings();
-
-    TargetPlatform JVM = new TargetPlatformImpl("JVM", new DynamicTypesSettings()) {
-        @NotNull
-        @Override
-        public AdditionalCheckerProvider createAdditionalCheckerProvider(@NotNull ModuleDescriptor module) {
-            return new KotlinJvmCheckerProvider(module);
-        }
-    };
-
-    TargetPlatform JS = new TargetPlatformImpl("JS", new DynamicTypesAllowed()) {
-        @NotNull
-        @Override
-        public AdditionalCheckerProvider createAdditionalCheckerProvider(@NotNull ModuleDescriptor module) {
-            return KotlinJsCheckerProvider.INSTANCE$;
-        }
-    };
-}
@@ -21,7 +21,10 @@ import com.intellij.openapi.module.Module;
 import com.intellij.openapi.roots.ProjectFileIndex;
 import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.js.resolve.JsPlatform;
 import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.resolve.TargetPlatform;
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;

 public class TargetPlatformDetector {
    public static final TargetPlatformDetector INSTANCE = new TargetPlatformDetector();
@@ -47,14 +50,14 @@ public class TargetPlatformDetector {
    @NotNull
    public static TargetPlatform getPlatform(@NotNull Module module) {
        if (ProjectStructureUtil.isJsKotlinModule(module)) {
-            return TargetPlatform.JS;
+            return JsPlatform.INSTANCE$;
        }
-        return TargetPlatform.JVM;
+        return JvmPlatform.INSTANCE$;
    }

    @NotNull
    public static TargetPlatform getDefaultPlatform() {
        LOG.info("Using default platform");
-        return TargetPlatform.JVM;
+        return JvmPlatform.INSTANCE$;
    }
 }
@@ -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.idea.project;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.types.DynamicTypesSettings;
-
-public abstract class TargetPlatformImpl implements TargetPlatform {
-    private final String platformName;
-    private final DynamicTypesSettings dynamicTypesSettings;
-
-    public TargetPlatformImpl(@NotNull String platformName, @NotNull DynamicTypesSettings dynamicTypesSettings) {
-        this.platformName = platformName;
-        this.dynamicTypesSettings = dynamicTypesSettings;
-    }
-
-    @NotNull
-    @Override
-    public DynamicTypesSettings getDynamicTypesSettings() {
-        return dynamicTypesSettings;
-    }
-
-    @Override
-    public String toString() {
-        return platformName;
-    }
-}
@@ -44,10 +44,10 @@ import org.jetbrains.kotlin.frontend.di.DiPackage;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
 import org.jetbrains.kotlin.resolve.BindingTraceContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
+import org.jetbrains.kotlin.resolve.TargetPlatform;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
@@ -111,7 +111,7 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
                        DiPackage.createLazyResolveSession(
                                newModuleContext,
                                declarationFactory, new BindingTraceContext(),
-                                AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
+                                TargetPlatform.Default.INSTANCE$.getPlatformConfigurator(),
                                new DynamicTypesSettings()
                        );

@@ -22,5 +22,6 @@
    <orderEntry type="module" module-name="idea" scope="RUNTIME" />
    <orderEntry type="module" module-name="util" />
    <orderEntry type="module" module-name="idea-js" scope="TEST" />
+    <orderEntry type="module" module-name="js.frontend" />
  </component>
 </module>
@@ -17,14 +17,11 @@
 package org.jetbrains.kotlin.idea.completion.test

 import com.intellij.codeInsight.completion.CompletionType
-import com.intellij.codeInsight.lookup.LookupElement
-import com.intellij.testFramework.LightProjectDescriptor
 import org.jetbrains.kotlin.idea.test.JdkAndMockLibraryProjectDescriptor
-import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
-import org.jetbrains.kotlin.idea.project.TargetPlatform
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform

 public abstract class AbstractCompiledKotlinInJavaCompletionTest : JetFixtureCompletionBaseTestCase() {
-    override fun getPlatform() = TargetPlatform.JVM
+    override fun getPlatform() = JvmPlatform

    override fun getProjectDescriptor() = JdkAndMockLibraryProjectDescriptor(COMPLETION_TEST_DATA_BASE_PATH + "/injava/mockLib", false)

@@ -21,8 +21,9 @@ import com.intellij.codeInsight.lookup.LookupElement;
 import com.intellij.testFramework.LightProjectDescriptor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.js.KotlinJavaScriptLibraryManager;
-import org.jetbrains.kotlin.idea.project.TargetPlatform;
 import org.jetbrains.kotlin.idea.test.KotlinStdJSProjectDescriptor;
+import org.jetbrains.kotlin.js.resolve.JsPlatform;
+import org.jetbrains.kotlin.resolve.TargetPlatform;

 public abstract class AbstractJSBasicCompletionTest extends JetFixtureCompletionBaseTestCase {
    @NotNull
@@ -31,9 +32,10 @@ public abstract class AbstractJSBasicCompletionTest extends JetFixtureCompletion
        return KotlinStdJSProjectDescriptor.Companion.getInstance();
    }

+    @NotNull
    @Override
    public TargetPlatform getPlatform() {
-        return TargetPlatform.JS;
+        return JsPlatform.INSTANCE$;
    }

    @Override
@@ -21,7 +21,8 @@ import com.intellij.codeInsight.lookup.LookupElement;
 import com.intellij.testFramework.LightProjectDescriptor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.test.JetWithJdkAndRuntimeLightProjectDescriptor;
-import org.jetbrains.kotlin.idea.project.TargetPlatform;
+import org.jetbrains.kotlin.resolve.TargetPlatform;
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;

 public abstract class AbstractJvmBasicCompletionTest extends JetFixtureCompletionBaseTestCase {
    @NotNull
@@ -30,9 +31,10 @@ public abstract class AbstractJvmBasicCompletionTest extends JetFixtureCompletio
        return JetWithJdkAndRuntimeLightProjectDescriptor.INSTANCE;
    }

+    @NotNull
    @Override
    public TargetPlatform getPlatform() {
-        return TargetPlatform.JVM;
+        return JvmPlatform.INSTANCE$;
    }

    @Override
@@ -21,7 +21,8 @@ import com.intellij.codeInsight.lookup.LookupElement;
 import com.intellij.testFramework.LightProjectDescriptor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.test.JetWithJdkAndRuntimeLightProjectDescriptor;
-import org.jetbrains.kotlin.idea.project.TargetPlatform;
+import org.jetbrains.kotlin.resolve.TargetPlatform;
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;

 public abstract class AbstractJvmSmartCompletionTest extends JetFixtureCompletionBaseTestCase {
    @NotNull
@@ -30,9 +31,10 @@ public abstract class AbstractJvmSmartCompletionTest extends JetFixtureCompletio
        return JetWithJdkAndRuntimeLightProjectDescriptor.INSTANCE;
    }

+    @NotNull
    @Override
    public TargetPlatform getPlatform() {
-        return TargetPlatform.JVM;
+        return JvmPlatform.INSTANCE$;
    }

    @Override
@@ -17,11 +17,10 @@
 package org.jetbrains.kotlin.idea.completion.test

 import com.intellij.codeInsight.completion.CompletionType
-import com.intellij.codeInsight.lookup.LookupElement
 import com.intellij.testFramework.LightProjectDescriptor
 import org.jetbrains.kotlin.idea.test.JdkAndMockLibraryProjectDescriptor
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
-import org.jetbrains.kotlin.idea.project.TargetPlatform
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform

 public abstract class AbstractJvmWithLibBasicCompletionTest : JetFixtureCompletionBaseTestCase() {
    private val TEST_PATH = COMPLETION_TEST_DATA_BASE_PATH + "/basic/custom"
@@ -33,7 +32,7 @@ public abstract class AbstractJvmWithLibBasicCompletionTest : JetFixtureCompleti
        return JdkAndMockLibraryProjectDescriptor(TEST_PATH + "/" + getTestName(false) + "Src", false)
    }

-    override fun getPlatform() = TargetPlatform.JVM
+    override fun getPlatform() = JvmPlatform

    override fun complete(invocationCount: Int) = myFixture.complete(CompletionType.BASIC, invocationCount)
 }
@@ -19,11 +19,11 @@ package org.jetbrains.kotlin.idea.completion.test
 import com.intellij.codeInsight.completion.CompletionType
 import com.intellij.codeInsight.lookup.LookupElement
 import org.jetbrains.kotlin.idea.completion.KeywordLookupObject
-import org.jetbrains.kotlin.idea.project.TargetPlatform
 import org.jetbrains.kotlin.idea.test.JetLightProjectDescriptor
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform

 public abstract class AbstractKeywordCompletionTest : JetFixtureCompletionBaseTestCase() {
-    override fun getPlatform() = TargetPlatform.JVM
+    override fun getPlatform() = JvmPlatform

    override fun complete(invocationCount: Int): Array<LookupElement>? {
        val items = myFixture.complete(CompletionType.BASIC) ?: return null
@@ -17,20 +17,17 @@
 package org.jetbrains.kotlin.idea.completion.test

 import com.intellij.codeInsight.completion.CompletionType
-import com.intellij.codeInsight.lookup.LookupElement
 import com.intellij.openapi.util.io.FileUtil
-import com.intellij.testFramework.LightProjectDescriptor
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
 import com.intellij.util.ArrayUtil
 import com.intellij.util.Function
 import com.intellij.util.containers.ContainerUtil
 import junit.framework.TestCase
-import org.jetbrains.kotlin.idea.project.TargetPlatform
-import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import java.io.File

 public abstract class AbstractKotlinSourceInJavaCompletionTest : JetFixtureCompletionBaseTestCase() {
-    override fun getPlatform() = TargetPlatform.JVM
+    override fun getPlatform() = JvmPlatform

    override fun doTest(testPath: String) {
        val mockLibDir = File(COMPLETION_TEST_DATA_BASE_PATH + "/injava/mockLib")
@@ -16,16 +16,15 @@

 package org.jetbrains.kotlin.idea.completion.test

-import org.jetbrains.kotlin.idea.project.TargetPlatform
 import org.jetbrains.kotlin.idea.test.AstAccessControl
-import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform

 public abstract class AbstractMultiFileJvmBasicCompletionTest : KotlinCompletionTestCase() {
    protected fun doTest(testPath: String) {
        configureByFile(getTestName(false) + ".kt", "")
        val shouldFail = testPath.contains("NoSpecifiedType")
        AstAccessControl.testWithControlledAccessToAst(shouldFail, getFile().getVirtualFile(), getProject(), getTestRootDisposable(), {
-            testCompletion(getFile().getText(), TargetPlatform.JVM, { invocationCount ->
+            testCompletion(getFile().getText(), JvmPlatform, { invocationCount ->
                complete(invocationCount)
                myItems
            }, 0)
@@ -17,9 +17,8 @@
 package org.jetbrains.kotlin.idea.completion.test

 import com.intellij.codeInsight.completion.CompletionType
-import org.jetbrains.kotlin.idea.project.TargetPlatform
 import org.jetbrains.kotlin.idea.test.AstAccessControl
-import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform

 public abstract class AbstractMultiFileSmartCompletionTest : KotlinCompletionTestCase() {
    override fun setUp() {
@@ -30,7 +29,7 @@ public abstract class AbstractMultiFileSmartCompletionTest : KotlinCompletionTes
    protected fun doTest(testPath: String) {
        configureByFile(getTestName(false) + ".kt", "")
        AstAccessControl.testWithControlledAccessToAst(false, getFile().getVirtualFile(), getProject(), getTestRootDisposable(), {
-            testCompletion(getFile().getText(), TargetPlatform.JVM, { invocationCount ->
+            testCompletion(getFile().getText(), JvmPlatform, { invocationCount ->
                complete(invocationCount)
                myItems
            }, 1)
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.idea.completion.test

 import com.intellij.codeInsight.CodeInsightSettings
 import com.intellij.codeInsight.lookup.LookupElement
-import org.jetbrains.kotlin.idea.project.TargetPlatform
+import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.test.JetTestUtils
 import org.junit.Assert

@@ -31,8 +31,10 @@ import com.intellij.ui.JBColor;
 import com.intellij.util.ArrayUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.project.TargetPlatform;
 import org.jetbrains.kotlin.idea.test.AstAccessControl;
+import org.jetbrains.kotlin.js.resolve.JsPlatform;
+import org.jetbrains.kotlin.resolve.TargetPlatform;
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
 import org.jetbrains.kotlin.test.InTextDirectivesUtils;
 import org.junit.Assert;

@@ -108,7 +110,7 @@ public class ExpectedCompletionUtils {
        }
    }

-    private static final String UNSUPPORTED_PLATFORM_MESSAGE = String.format("Only %s and %s platforms are supported", TargetPlatform.JVM, TargetPlatform.JS);
+    private static final String UNSUPPORTED_PLATFORM_MESSAGE = String.format("Only %s and %s platforms are supported", JvmPlatform.INSTANCE$, JsPlatform.INSTANCE$);
    
    private static final String EXIST_LINE_PREFIX = "EXIST:";

@@ -153,10 +155,10 @@ public class ExpectedCompletionUtils {
        if (platform == null) {
            return processProposalAssertions(fileText, EXIST_LINE_PREFIX);
        }
-        else if (platform == TargetPlatform.JVM) {
+        else if (platform == JvmPlatform.INSTANCE$) {
            return processProposalAssertions(fileText, EXIST_LINE_PREFIX, EXIST_JAVA_ONLY_LINE_PREFIX);
        }
-        else if (platform == TargetPlatform.JS) {
+        else if (platform == JsPlatform.INSTANCE$) {
            return processProposalAssertions(fileText, EXIST_LINE_PREFIX, EXIST_JS_ONLY_LINE_PREFIX);
        }
        else {
@@ -169,10 +171,10 @@ public class ExpectedCompletionUtils {
        if (platform == null) {
            return processProposalAssertions(fileText, ABSENT_LINE_PREFIX);
        }
-        else if (platform == TargetPlatform.JVM) {
+        else if (platform == JvmPlatform.INSTANCE$) {
            return processProposalAssertions(fileText, ABSENT_LINE_PREFIX, ABSENT_JAVA_LINE_PREFIX, EXIST_JS_ONLY_LINE_PREFIX);
        }
-        else if (platform == TargetPlatform.JS) {
+        else if (platform == JsPlatform.INSTANCE$) {
            return processProposalAssertions(fileText, ABSENT_LINE_PREFIX, ABSENT_JS_LINE_PREFIX, EXIST_JAVA_ONLY_LINE_PREFIX);
        }
        else {
@@ -206,10 +208,10 @@ public class ExpectedCompletionUtils {
        if (platform == null) {
            return InTextDirectivesUtils.getPrefixedInt(fileText, NUMBER_LINE_PREFIX);
        }
-        else if (platform == TargetPlatform.JVM) {
+        else if (platform == JvmPlatform.INSTANCE$) {
            return getPlatformExpectedNumber(fileText, NUMBER_JAVA_LINE_PREFIX);
        }
-        else if (platform == TargetPlatform.JS) {
+        else if (platform == JsPlatform.INSTANCE$) {
            return getPlatformExpectedNumber(fileText, NUMBER_JS_LINE_PREFIX);
        }
        else {
@@ -19,8 +19,8 @@ package org.jetbrains.kotlin.idea.completion.test
 import com.intellij.codeInsight.lookup.LookupElement
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.idea.caches.resolve.LibraryModificationTracker
-import org.jetbrains.kotlin.idea.project.TargetPlatform
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
+import org.jetbrains.kotlin.resolve.TargetPlatform
 import java.io.File

 public abstract class JetFixtureCompletionBaseTestCase : JetLightCodeInsightFixtureTestCase() {
@@ -19,11 +19,12 @@ package org.jetbrains.kotlin.idea.actions
 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.actionSystem.CommonDataKeys
-import com.intellij.openapi.ui.Messages
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.idea.configuration.KotlinProjectConfigurator
+import com.intellij.openapi.ui.Messages
 import org.jetbrains.kotlin.idea.configuration.ConfigureKotlinInProjectUtils
-import org.jetbrains.kotlin.idea.project.TargetPlatform
+import org.jetbrains.kotlin.idea.configuration.KotlinProjectConfigurator
+import org.jetbrains.kotlin.js.resolve.JsPlatform
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform

 public abstract class ConfigureKotlinInProjectAction : AnAction() {

@@ -53,12 +54,12 @@ public abstract class ConfigureKotlinInProjectAction : AnAction() {

 public class ConfigureKotlinJsInProjectAction: ConfigureKotlinInProjectAction() {
    override fun getAbleToRunConfigurators(project: Project) = ConfigureKotlinInProjectUtils.getAbleToRunConfigurators(project).filter {
-        it.getTargetPlatform() == TargetPlatform.JS
+        it.getTargetPlatform() == JsPlatform
    }
 }

 public class ConfigureKotlinJavaInProjectAction: ConfigureKotlinInProjectAction() {
    override fun getAbleToRunConfigurators(project: Project) = ConfigureKotlinInProjectUtils.getAbleToRunConfigurators(project).filter {
-        it.getTargetPlatform() == TargetPlatform.JVM
+        it.getTargetPlatform() == JvmPlatform
    }
 }
@@ -19,7 +19,8 @@ package org.jetbrains.kotlin.idea.configuration;
 import com.intellij.openapi.module.Module;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.JetPluginUtil;
-import org.jetbrains.kotlin.idea.project.TargetPlatform;
+import org.jetbrains.kotlin.resolve.TargetPlatform;
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyFile;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;

@@ -37,7 +38,7 @@ public class KotlinAndroidGradleModuleConfigurator extends KotlinWithGradleConfi
    @NotNull
    @Override
    public TargetPlatform getTargetPlatform() {
-        return TargetPlatform.JVM;
+        return JvmPlatform.INSTANCE$;
    }

    @NotNull
@@ -19,7 +19,8 @@ package org.jetbrains.kotlin.idea.configuration;
 import com.intellij.openapi.module.Module;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.JetPluginUtil;
-import org.jetbrains.kotlin.idea.project.TargetPlatform;
+import org.jetbrains.kotlin.resolve.TargetPlatform;
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyFile;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;

@@ -37,7 +38,7 @@ public class KotlinGradleModuleConfigurator extends KotlinWithGradleConfigurator
    @NotNull
    @Override
    public TargetPlatform getTargetPlatform() {
-        return TargetPlatform.JVM;
+        return JvmPlatform.INSTANCE$;
    }

    @NotNull
@@ -21,7 +21,8 @@ import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.idea.maven.dom.model.MavenDomPlugin;
 import org.jetbrains.kotlin.idea.project.ProjectStructureUtil;
-import org.jetbrains.kotlin.idea.project.TargetPlatform;
+import org.jetbrains.kotlin.resolve.TargetPlatform;
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;

 public class KotlinJavaMavenConfigurator extends KotlinMavenConfigurator {
    private static final String NAME = "maven";
@@ -46,6 +47,6 @@ public class KotlinJavaMavenConfigurator extends KotlinMavenConfigurator {
    @NotNull
    @Override
    public TargetPlatform getTargetPlatform() {
-        return TargetPlatform.JVM;
+        return JvmPlatform.INSTANCE$;
    }
 }
@@ -26,8 +26,9 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.framework.JavaRuntimeLibraryDescription;
 import org.jetbrains.kotlin.idea.framework.JavaRuntimePresentationProvider;
 import org.jetbrains.kotlin.idea.project.ProjectStructureUtil;
-import org.jetbrains.kotlin.idea.project.TargetPlatform;
 import org.jetbrains.kotlin.idea.versions.KotlinRuntimeLibraryCoreUtil;
+import org.jetbrains.kotlin.resolve.TargetPlatform;
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
 import org.jetbrains.kotlin.utils.KotlinPaths;
 import org.jetbrains.kotlin.utils.PathUtil;

@@ -78,7 +79,7 @@ public class KotlinJavaModuleConfigurator extends KotlinWithLibraryConfigurator
    @NotNull
    @Override
    public TargetPlatform getTargetPlatform() {
-        return TargetPlatform.JVM;
+        return JvmPlatform.INSTANCE$;
    }

    @NotNull
@@ -21,7 +21,8 @@ import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.idea.maven.dom.model.MavenDomPlugin;
 import org.jetbrains.kotlin.idea.project.ProjectStructureUtil;
-import org.jetbrains.kotlin.idea.project.TargetPlatform;
+import org.jetbrains.kotlin.js.resolve.JsPlatform;
+import org.jetbrains.kotlin.resolve.TargetPlatform;

 public class KotlinJavascriptMavenConfigurator extends KotlinMavenConfigurator {
    private static final String NAME = "js maven";
@@ -61,6 +62,6 @@ public class KotlinJavascriptMavenConfigurator extends KotlinMavenConfigurator {
    @NotNull
    @Override
    public TargetPlatform getTargetPlatform() {
-        return TargetPlatform.JS;
+        return JsPlatform.INSTANCE$;
    }
 }
@@ -24,8 +24,9 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.framework.JSLibraryStdDescription;
 import org.jetbrains.kotlin.idea.framework.JSLibraryStdPresentationProvider;
 import org.jetbrains.kotlin.idea.project.ProjectStructureUtil;
-import org.jetbrains.kotlin.idea.project.TargetPlatform;
 import org.jetbrains.kotlin.js.JavaScript;
+import org.jetbrains.kotlin.js.resolve.JsPlatform;
+import org.jetbrains.kotlin.resolve.TargetPlatform;
 import org.jetbrains.kotlin.utils.KotlinPaths;
 import org.jetbrains.kotlin.utils.PathUtil;

@@ -41,7 +42,7 @@ public class KotlinJsModuleConfigurator extends KotlinWithLibraryConfigurator {
    @NotNull
    @Override
    public TargetPlatform getTargetPlatform() {
-        return TargetPlatform.JS;
+        return JsPlatform.INSTANCE$;
    }

    @NotNull
@@ -20,7 +20,7 @@ import com.intellij.openapi.extensions.ExtensionPointName;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.idea.project.TargetPlatform;
+import org.jetbrains.kotlin.resolve.TargetPlatform;

 public interface KotlinProjectConfigurator {
    ExtensionPointName<KotlinProjectConfigurator> EP_NAME = ExtensionPointName.create("org.jetbrains.kotlin.projectConfigurator");
@@ -19,10 +19,10 @@ package org.jetbrains.kotlin.idea.framework
 import com.intellij.ide.util.projectWizard.JavaModuleBuilder
 import com.intellij.ide.util.projectWizard.ModuleWizardStep
 import com.intellij.ide.util.projectWizard.SettingsStep
-import org.jetbrains.kotlin.idea.JetIcons
-import org.jetbrains.kotlin.idea.project.TargetPlatform
-import com.intellij.openapi.roots.ui.configuration.ModulesProvider
 import com.intellij.ide.util.projectWizard.WizardContext
+import com.intellij.openapi.roots.ui.configuration.ModulesProvider
+import org.jetbrains.kotlin.idea.JetIcons
+import org.jetbrains.kotlin.resolve.TargetPlatform

 public class KotlinModuleBuilder(
        val targetPlatform: TargetPlatform, val builderName: String, val builderDescription: String) : JavaModuleBuilder() {
@@ -35,7 +35,9 @@ import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.io.FileUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.project.TargetPlatform;
+import org.jetbrains.kotlin.js.resolve.JsPlatform;
+import org.jetbrains.kotlin.resolve.TargetPlatform;
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;

 import javax.swing.*;
 import java.util.ArrayList;
@@ -98,15 +100,15 @@ public class KotlinModuleSettingStep extends ModuleWizardStep {

    @NotNull
    protected String getLibraryLabelText() {
-        if (targetPlatform == TargetPlatform.JVM) return "\u001BKotlin runtime:";
-        if (targetPlatform == TargetPlatform.JS) return "\u001BKotlin JS library:";
+        if (targetPlatform == JvmPlatform.INSTANCE$) return "\u001BKotlin runtime:";
+        if (targetPlatform == JsPlatform.INSTANCE$) return "\u001BKotlin JS library:";
        throw new IllegalStateException("Only JS and JVM target are supported");
    }

    @NotNull
    protected CustomLibraryDescription getCustomLibraryDescription(@Nullable Project project) {
-        if (targetPlatform == TargetPlatform.JVM) return new JavaRuntimeLibraryDescription(project);
-        if (targetPlatform == TargetPlatform.JS) return new JSLibraryStdDescription(project);
+        if (targetPlatform == JvmPlatform.INSTANCE$) return new JavaRuntimeLibraryDescription(project);
+        if (targetPlatform == JsPlatform.INSTANCE$) return new JSLibraryStdDescription(project);
        throw new IllegalStateException("Only JS and JVM target are supported");
    }

@@ -20,7 +20,8 @@ import com.intellij.ide.util.projectWizard.WizardContext
 import com.intellij.platform.ProjectTemplatesFactory
 import com.intellij.platform.templates.BuilderBasedTemplate
 import org.jetbrains.kotlin.idea.JetIcons
-import org.jetbrains.kotlin.idea.project.TargetPlatform
+import org.jetbrains.kotlin.js.resolve.JsPlatform
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform

 public class KotlinTemplatesFactory : ProjectTemplatesFactory() {
    companion object {
@@ -31,8 +32,8 @@ public class KotlinTemplatesFactory : ProjectTemplatesFactory() {
    override fun getGroupIcon(group: String) = JetIcons.SMALL_LOGO

    override fun createTemplates(group: String?, context: WizardContext?) =
-        arrayOf(
-                BuilderBasedTemplate(KotlinModuleBuilder(TargetPlatform.JVM, "Kotlin - JVM", "Kotlin module for JVM target")),
-                BuilderBasedTemplate(KotlinModuleBuilder(TargetPlatform.JS, "Kotlin - JavaScript", "Kotlin module for JavaScript target"))
-        )
+            arrayOf(
+                    BuilderBasedTemplate(KotlinModuleBuilder(JvmPlatform, "Kotlin - JVM", "Kotlin module for JVM target")),
+                    BuilderBasedTemplate(KotlinModuleBuilder(JsPlatform, "Kotlin - JavaScript", "Kotlin module for JavaScript target"))
+            )
 }
@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.idea.debugger.evaluate

 import com.intellij.codeInsight.completion.CompletionType
 import com.intellij.openapi.module.Module
-import com.intellij.openapi.roots.ContentEntry
 import com.intellij.openapi.roots.ModifiableRootModel
 import com.intellij.openapi.roots.OrderRootType
 import com.intellij.openapi.vfs.LocalFileSystem
@@ -26,11 +25,11 @@ import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiManager
 import org.jetbrains.kotlin.idea.completion.test.AbstractJvmBasicCompletionTest
 import org.jetbrains.kotlin.idea.completion.test.testCompletion
-import org.jetbrains.kotlin.idea.project.TargetPlatform
 import org.jetbrains.kotlin.idea.test.JdkAndMockLibraryProjectDescriptor
 import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.psi.JetFunction
 import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.test.JetTestUtils
 import java.io.File

@@ -69,7 +68,7 @@ public class CodeFragmentCompletionInLibraryTest : AbstractJvmBasicCompletionTes
    private fun testCompletionInLibraryCodeFragment(fragmentText: String, vararg completionDirectives: String) {
        setupFixtureByCodeFragment(fragmentText)
        val directives = completionDirectives.map { "//$it" }.joinToString(separator = "\n")
-        testCompletion(directives, TargetPlatform.JVM, {
+        testCompletion(directives, JvmPlatform, {
            myFixture.complete(CompletionType.BASIC)
        })
    }
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.container.useInstance
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.frontend.di.configureModule
 import org.jetbrains.kotlin.incremental.components.UsageCollector
-import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider
+import org.jetbrains.kotlin.js.resolve.JsPlatformConfigurator
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.BodyResolveCache
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
@@ -38,7 +38,7 @@ public fun createTopDownAnalyzerForJs(
        declarationProviderFactory: DeclarationProviderFactory
 ): LazyTopDownAnalyzerForTopLevel {
    val storageComponentContainer = createContainer("TopDownAnalyzerForJs") {
-        configureModule(moduleContext, KotlinJsCheckerProvider, bindingTrace)
+        configureModule(moduleContext, JsPlatformConfigurator, bindingTrace)

        useInstance(declarationProviderFactory)
        useImpl<FileScopeProviderImpl>()
@@ -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.js.resolve
+
+import org.jetbrains.kotlin.resolve.PlatformConfigurator
+import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.types.DynamicTypesAllowed
+
+public object JsPlatform : TargetPlatform("JS", DynamicTypesAllowed()) {
+    override val platformConfigurator: PlatformConfigurator = JsPlatformConfigurator
+}
@@ -17,9 +17,9 @@
 package org.jetbrains.kotlin.js.resolve

 import org.jetbrains.kotlin.js.resolve.diagnostics.JsCallChecker
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider
+import org.jetbrains.kotlin.resolve.PlatformConfigurator

-public object KotlinJsCheckerProvider : AdditionalCheckerProvider(
+public object JsPlatformConfigurator : PlatformConfigurator(
        additionalDeclarationCheckers = listOf(NativeInvokeChecker(), NativeGetterChecker(), NativeSetterChecker(), ClassDeclarationChecker()),
        additionalCallCheckers = listOf(JsCallChecker()),
        additionalTypeCheckers = listOf(),
@@ -18,5 +18,6 @@
    <orderEntry type="module" module-name="idea-completion" scope="TEST" />
    <orderEntry type="library" name="kotlin-runtime" level="project" />
    <orderEntry type="module" module-name="idea-test-framework" scope="TEST" />
+    <orderEntry type="module" module-name="frontend.java" scope="TEST" />
  </component>
 </module>
@@ -20,7 +20,7 @@ import com.intellij.codeInsight.CodeInsightSettings
 import com.intellij.codeInsight.completion.CompletionType
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.idea.completion.test.testCompletion
-import org.jetbrains.kotlin.idea.project.TargetPlatform
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import java.io.File

 public abstract class AbstractAndroidCompletionTest : KotlinAndroidTestCase() {
@@ -48,7 +48,7 @@ public abstract class AbstractAndroidCompletionTest : KotlinAndroidTestCase() {
        val virtualFile = myFixture.copyFileToProject(path + getTestName(true) + ".kt", "src/" + getTestName(true) + ".kt");
        myFixture.configureFromExistingVirtualFile(virtualFile)
        val fileText = FileUtil.loadFile(File(path + getTestName(true) + ".kt"), true)
-        testCompletion(fileText, TargetPlatform.JVM, {
+        testCompletion(fileText, JvmPlatform, {
            count -> myFixture.complete(completionType())
        })
    }