Make KotlinJvmCheckerProvider non-singleton, pass module to it

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt

@@ -38,7 +38,7 @@ public fun createContainerForReplWithJava(
         moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory,
         moduleContentScope: GlobalSearchScope, additionalFileScopeProvider: FileScopeProvider.AdditionalScopes
 ): ContainerForReplWithJava = createContainer("ReplWithJava") {
-    configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace)
+    configureModule(moduleContext, KotlinJvmCheckerProvider(moduleContext.module), bindingTrace)
     configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project)
 
     useInstance(additionalFileScopeProvider)

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

@@ -71,7 +71,7 @@ public fun createContainerForLazyResolveWithJava(
         moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory,
         moduleContentScope: GlobalSearchScope, moduleClassResolver: ModuleClassResolver
 ): Pair<ResolveSession, JavaDescriptorResolver> = createContainer("LazyResolveWithJava") {
-    configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace)
+    configureModule(moduleContext, KotlinJvmCheckerProvider(moduleContext.module), bindingTrace)
     configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project)
 
     useInstance(moduleClassResolver)
@@ -92,7 +92,7 @@ public fun createContainerForTopDownAnalyzerForJvm(
         declarationProviderFactory: DeclarationProviderFactory,
         moduleContentScope: GlobalSearchScope
 ): ContainerForTopDownAnalyzerForJvm = createContainer("TopDownAnalyzerForJvm") {
-    configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace)
+    configureModule(moduleContext, KotlinJvmCheckerProvider(moduleContext.module), bindingTrace)
     configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project)
     useInstance(declarationProviderFactory)
     useInstance(BodyResolveCache.ThrowException)

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmCheckerProvider.kt

@@ -52,7 +52,7 @@ import org.jetbrains.kotlin.types.expressions.SenselessComparisonChecker
 import org.jetbrains.kotlin.types.flexibility
 import org.jetbrains.kotlin.types.isFlexible
 
-public object KotlinJvmCheckerProvider : AdditionalCheckerProvider(
+public class KotlinJvmCheckerProvider(private val module: ModuleDescriptor) : AdditionalCheckerProvider(
         additionalDeclarationCheckers = listOf(PlatformStaticAnnotationChecker(),
                                                LocalFunInlineChecker(),
                                                ReifiedTypeParameterAnnotationChecker(),

compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt

@@ -53,7 +53,8 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
                 context,
                 FileBasedDeclarationProviderFactory(context.storageManager, listOf(psiFile)),
                 CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
-                KotlinJvmCheckerProvider, DynamicTypesSettings())
+                KotlinJvmCheckerProvider(context.module), DynamicTypesSettings()
+        )
 
         context.initializeModuleContents(resolveSession.getPackageFragmentProvider())
 

compiler/tests/org/jetbrains/kotlin/tests/di/injection.kt

@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.types.expressions.FakeCallResolver
 
 public fun createContainerForTests(project: Project, module: ModuleDescriptor): ContainerForTests {
     return ContainerForTests(createContainer("Tests") {
-        configureModule(ModuleContext(module, project), KotlinJvmCheckerProvider)
+        configureModule(ModuleContext(module, project), KotlinJvmCheckerProvider(module))
         useImpl<ExpressionTypingServices>()
     })
 }

idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt

@@ -401,11 +401,17 @@ public abstract class ElementResolver protected constructor(
         return trace
     }
 
-    private fun createBodyResolver(resolveSession: ResolveSession, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter): BodyResolver {
+    private fun createBodyResolver(
+            resolveSession: ResolveSession,
+            trace: BindingTrace,
+            file: JetFile,
+            statementFilter: StatementFilter
+    ): BodyResolver {
         val globalContext = SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker())
+        val module = resolveSession.getModuleDescriptor()
         return createContainerForBodyResolve(
-                globalContext.withProject(file.getProject()).withModule(resolveSession.getModuleDescriptor()),
+                globalContext.withProject(file.getProject()).withModule(module),
-                trace, getAdditionalCheckerProvider(file), statementFilter, getDynamicTypesSettings(file)
+                trace, createAdditionalCheckerProvider(file, module), statementFilter, getDynamicTypesSettings(file)
         ).get<BodyResolver>()
     }
 
@@ -477,7 +483,7 @@ public abstract class ElementResolver protected constructor(
         return null
     }
 
-    protected abstract fun getAdditionalCheckerProvider(jetFile: JetFile): AdditionalCheckerProvider
+    protected abstract fun createAdditionalCheckerProvider(jetFile: JetFile, module: ModuleDescriptor): AdditionalCheckerProvider
     protected abstract fun getDynamicTypesSettings(jetFile: JetFile): DynamicTypesSettings
 
     private class BodyResolveContextForLazy(

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt

@@ -215,11 +215,9 @@ private object KotlinResolveDataProvider {
 
     fun analyze(project: Project, resolveSession: ResolveSessionForBodies, analyzableElement: JetElement): AnalysisResult {
         try {
+            val module = resolveSession.getModuleDescriptor()
             if (analyzableElement is JetCodeFragment) {
-                return AnalysisResult.success(
+                return AnalysisResult.success(analyzeExpressionCodeFragment(resolveSession, analyzableElement), module)
-                        analyzeExpressionCodeFragment(resolveSession, analyzableElement),
-                        resolveSession.getModuleDescriptor()
-                )
             }
 
             val file = analyzableElement.getContainingJetFile()
@@ -232,12 +230,12 @@ private object KotlinResolveDataProvider {
 
             val targetPlatform = TargetPlatformDetector.getPlatform(analyzableElement.getContainingJetFile())
             val globalContext = SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker())
-            val moduleContext = globalContext.withProject(project).withModule(resolveSession.getModuleDescriptor())
+            val moduleContext = globalContext.withProject(project).withModule(module)
             val lazyTopDownAnalyzer = createContainerForLazyBodyResolve(
                     moduleContext,
                     resolveSession,
                     trace,
-                    targetPlatform.getAdditionalCheckerProvider(),
+                    targetPlatform.createAdditionalCheckerProvider(module),
                     targetPlatform.getDynamicTypesSettings(),
                     resolveSession.getBodyResolveCache()
             ).get<LazyTopDownAnalyzerForTopLevel>()
@@ -248,7 +246,7 @@ private object KotlinResolveDataProvider {
             )
             return AnalysisResult.success(
                     trace.getBindingContext(),
-                    resolveSession.getModuleDescriptor()
+                    module
             )
         }
         catch (e: ProcessCanceledException) {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.java

@@ -24,6 +24,7 @@ import com.intellij.psi.util.PsiModificationTracker;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+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.JetElement;
@@ -88,8 +89,8 @@ public class ResolveElementCache extends ElementResolver implements BodyResolveC
 
     @NotNull
     @Override
-    public AdditionalCheckerProvider getAdditionalCheckerProvider(@NotNull JetFile jetFile) {
+    public AdditionalCheckerProvider createAdditionalCheckerProvider(@NotNull JetFile jetFile, @NotNull ModuleDescriptor module) {
-        return TargetPlatformDetector.getPlatform(jetFile).getAdditionalCheckerProvider();
+        return TargetPlatformDetector.getPlatform(jetFile).createAdditionalCheckerProvider(module);
     }
 
     @NotNull

idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/TargetPlatform.java

@@ -17,6 +17,7 @@
 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;
@@ -25,11 +26,24 @@ import org.jetbrains.kotlin.types.DynamicTypesSettings;
 
 public interface TargetPlatform {
     @NotNull
-    AdditionalCheckerProvider getAdditionalCheckerProvider();
+    AdditionalCheckerProvider createAdditionalCheckerProvider(@NotNull ModuleDescriptor module);
 
     @NotNull
     DynamicTypesSettings getDynamicTypesSettings();
 
-    TargetPlatform JVM = new TargetPlatformImpl("JVM", KotlinJvmCheckerProvider.INSTANCE$, new DynamicTypesSettings());
+    TargetPlatform JVM = new TargetPlatformImpl("JVM", new DynamicTypesSettings()) {
-    TargetPlatform JS = new TargetPlatformImpl("JS", KotlinJsCheckerProvider.INSTANCE$, new DynamicTypesAllowed());
+        @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$;
+        }
+    };
 }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/TargetPlatformImpl.java

@@ -17,30 +17,17 @@
 package org.jetbrains.kotlin.idea.project;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
 import org.jetbrains.kotlin.types.DynamicTypesSettings;
 
-public class TargetPlatformImpl implements TargetPlatform {
+public abstract class TargetPlatformImpl implements TargetPlatform {
-    @NotNull private final String platformName;
+    private final String platformName;
-    @NotNull private final AdditionalCheckerProvider additionalCheckerProvider;
+    private final DynamicTypesSettings dynamicTypesSettings;
-    @NotNull private final DynamicTypesSettings dynamicTypesSettings;
 
-    public TargetPlatformImpl(
+    public TargetPlatformImpl(@NotNull String platformName, @NotNull DynamicTypesSettings dynamicTypesSettings) {
-            @NotNull String platformName,
-            @NotNull AdditionalCheckerProvider additionalCheckerProvider,
-            @NotNull DynamicTypesSettings dynamicTypesSettings
-    ) {
         this.platformName = platformName;
-        this.additionalCheckerProvider = additionalCheckerProvider;
         this.dynamicTypesSettings = dynamicTypesSettings;
     }
 
-    @NotNull
-    @Override
-    public AdditionalCheckerProvider getAdditionalCheckerProvider() {
-        return additionalCheckerProvider;
-    }
-
     @NotNull
     @Override
     public DynamicTypesSettings getDynamicTypesSettings() {