Parametrize module creation by platform with built-ins

compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.java

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.descriptors.impl.MutablePackageFragmentDescriptor;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.platform.JvmBuiltIns;
 import org.jetbrains.kotlin.resolve.FunctionTypeResolveUtilsKt;
 import org.jetbrains.kotlin.resolve.TargetPlatformKt;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
@@ -43,8 +44,8 @@ public class JvmRuntimeTypes {
         ModuleDescriptorImpl module = TargetPlatformKt.createModule(
                 JvmPlatform.INSTANCE,
                 Name.special("<jvm functions impl>"),
-                LockBasedStorageManager.NO_LOCKS
+                LockBasedStorageManager.NO_LOCKS,
-        );
+                JvmBuiltIns.getInstance());
         PackageFragmentDescriptor kotlinJvmInternal = new MutablePackageFragmentDescriptor(module, new FqName("kotlin.jvm.internal"));
 
         this.lambda = createClass(kotlinJvmInternal, "Lambda");

compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt

@@ -37,6 +37,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.platform.JvmBuiltIns
 import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
@@ -92,6 +93,7 @@ class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) {
                 { ModuleContent(files, GlobalSearchScope.EMPTY_SCOPE) },
                 JvmPlatformParameters { throw IllegalStateException() },
                 CompilerEnvironment,
+                builtIns = JvmBuiltIns.Instance,
                 packagePartProviderFactory = { module, content -> JvmPackagePartProvider(environment) }
         )
 

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java

@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.modules.Module;
 import org.jetbrains.kotlin.modules.TargetId;
 import org.jetbrains.kotlin.modules.TargetIdKt;
 import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.platform.JvmBuiltIns;
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
@@ -161,7 +162,7 @@ public enum TopDownAnalyzerFacadeForJVM {
     @NotNull
     public static MutableModuleContext createContextWithSealedModule(@NotNull Project project, @NotNull String moduleName) {
         MutableModuleContext context = ContextKt.ContextForNewModule(
-                project, Name.special("<" + moduleName + ">"), JvmPlatform.INSTANCE
+                project, Name.special("<" + moduleName + ">"), JvmPlatform.INSTANCE, JvmBuiltIns.getInstance()
         );
         context.setDependencies(context.getModule(), context.getBuiltIns().getBuiltInsModule());
         return context;

compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.analyzer
 
 import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.context.ProjectContext
@@ -152,6 +153,7 @@ abstract class AnalyzerFacade<in P : PlatformAnalysisParameters> {
             modulesContent: (M) -> ModuleContent,
             platformParameters: P,
             targetEnvironment: TargetEnvironment,
+            builtIns: KotlinBuiltIns,
             delegateResolver: ResolverForProject<M> = EmptyResolverForProject(),
             packagePartProviderFactory: (M, ModuleContent) -> PackagePartProvider = { module, content -> PackagePartProvider.EMPTY }
     ): ResolverForProject<M> {
@@ -160,7 +162,8 @@ abstract class AnalyzerFacade<in P : PlatformAnalysisParameters> {
             val descriptorByModule = HashMap<M, ModuleDescriptorImpl>()
             modules.forEach {
                 module ->
-                descriptorByModule[module] = targetPlatform.createModule(module.name, storageManager, module.capabilities)
+                descriptorByModule[module] =
+                        targetPlatform.createModule(module.name, storageManager, builtIns, module.capabilities)
             }
             return ResolverForProjectImpl(debugName, descriptorByModule, delegateResolver)
         }
@@ -172,9 +175,8 @@ abstract class AnalyzerFacade<in P : PlatformAnalysisParameters> {
                 dependencyInfo ->
                 resolverForProject.descriptorForModule(dependencyInfo as M)
             }
-
+            module.dependencyOnBuiltIns().adjustDependencies(
-            val builtinsModule = targetPlatform.builtIns.builtInsModule
+                    resolverForProject.descriptorForModule(module).builtIns.builtInsModule, dependenciesDescriptors)
-            module.dependencyOnBuiltIns().adjustDependencies(builtinsModule, dependenciesDescriptors)
             return dependenciesDescriptors
         }
 

compiler/frontend/src/org/jetbrains/kotlin/context/context.kt

@@ -118,10 +118,11 @@ fun ContextForNewModule(
 fun ContextForNewModule(
         project: Project,
         moduleName: Name,
-        targetPlatform: TargetPlatform
+        targetPlatform: TargetPlatform,
+        builtIns: KotlinBuiltIns
 ): MutableModuleContext {
     val projectContext = ProjectContext(project)
-    val module = targetPlatform.createModule(moduleName, projectContext.storageManager)
+    val module = targetPlatform.createModule(moduleName, projectContext.storageManager, builtIns)
     return MutableModuleContextImpl(module, projectContext)
 }
 

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

@@ -108,6 +108,7 @@ abstract class PlatformConfigurator(
 fun TargetPlatform.createModule(
         name: Name,
         storageManager: StorageManager,
+        builtIns: KotlinBuiltIns,
         capabilities: Map<ModuleDescriptor.Capability<*>, Any?> = emptyMap()
 ) = ModuleDescriptorImpl(name, storageManager, defaultModuleParameters, builtIns, capabilities)
 

compiler/tests-common/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtils.kt

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.platform.JvmBuiltIns
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
@@ -40,7 +41,8 @@ fun createResolveSessionForFiles(
             projectContext, listOf(testModule),
             { ModuleContent(syntheticFiles, GlobalSearchScope.allScope(project)) },
             JvmPlatformParameters { testModule },
-            CompilerEnvironment
+            CompilerEnvironment,
+            JvmBuiltIns.Instance
     )
     return resolverForProject.resolverForModule(testModule).componentProvider.get<ResolveSession>()
 }

compiler/tests-common/org/jetbrains/kotlin/test/KotlinTestUtils.java

@@ -47,6 +47,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt;
@@ -63,6 +64,7 @@ import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
 import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.platform.JvmBuiltIns;
 import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
@@ -933,13 +935,13 @@ public class KotlinTestUtils {
 
     @NotNull
     public static ModuleDescriptorImpl createEmptyModule(@NotNull String name) {
-        return createEmptyModule(name, JvmPlatform.INSTANCE);
+        return createEmptyModule(name, JvmPlatform.INSTANCE, JvmBuiltIns.getInstance());
     }
 
     @NotNull
-    public static ModuleDescriptorImpl createEmptyModule(@NotNull String name, @NotNull TargetPlatform platform) {
+    public static ModuleDescriptorImpl createEmptyModule(@NotNull String name, @NotNull TargetPlatform platform, KotlinBuiltIns builtIns) {
         return new ModuleDescriptorImpl(
-                Name.special(name), LockBasedStorageManager.NO_LOCKS, platform.getDefaultModuleParameters(), platform.getBuiltIns()
+                Name.special(name), LockBasedStorageManager.NO_LOCKS, platform.getDefaultModuleParameters(), builtIns
         );
     }
 

compiler/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.java

@@ -38,11 +38,15 @@ import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.diagnostics.*;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.platform.JvmBuiltIns;
 import org.jetbrains.kotlin.psi.Call;
 import org.jetbrains.kotlin.psi.KtElement;
 import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.psi.KtFile;
-import org.jetbrains.kotlin.resolve.*;
+import org.jetbrains.kotlin.resolve.AnalyzingUtils;
+import org.jetbrains.kotlin.resolve.BindingContext;
+import org.jetbrains.kotlin.resolve.BindingTrace;
+import org.jetbrains.kotlin.resolve.TargetPlatformKt;
 import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
@@ -351,7 +355,7 @@ public abstract class AbstractDiagnosticsTest extends BaseDiagnosticsTest {
 
     @NotNull
     protected ModuleDescriptorImpl createModule(@NotNull String moduleName, @NotNull StorageManager storageManager) {
-        return TargetPlatformKt.createModule(JvmPlatform.INSTANCE, Name.special(moduleName), storageManager);
+        return TargetPlatformKt.createModule(JvmPlatform.INSTANCE, Name.special(moduleName), storageManager, JvmBuiltIns.getInstance());
     }
 
     @NotNull

compiler/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTestWithJsStdLib.java

@@ -72,7 +72,8 @@ public abstract class AbstractDiagnosticsTestWithJsStdLib extends AbstractDiagno
     @NotNull
     @Override
     protected ModuleDescriptorImpl createModule(@NotNull String moduleName, @NotNull StorageManager storageManager) {
-        return TargetPlatformKt.createModule(JsPlatform.INSTANCE, Name.special(moduleName), storageManager);
+        return TargetPlatformKt.createModule(
+                JsPlatform.INSTANCE, Name.special(moduleName), storageManager, JsPlatform.INSTANCE.getBuiltIns());
     }
 
     @NotNull

compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt

@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.platform.JvmBuiltIns
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
@@ -69,6 +70,7 @@ class MultiModuleJavaAnalysisCustomTest : KtUsefulTestCase() {
                     modules.first { it._name == moduleName }
                 },
                 CompilerEnvironment,
+                JvmBuiltIns.Instance,
                 packagePartProviderFactory = { a, b -> JvmPackagePartProvider(environment) }
         )
 

compiler/tests/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerTest.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.serialization.builtins
 
+import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.createBuiltInPackageFragmentProvider
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil.TEST_PACKAGE_FQNAME
@@ -39,7 +40,7 @@ class BuiltInsSerializerTest : TestCaseWithTmpdir() {
         )
 
         val platform = TargetPlatform.Default
-        val module = KotlinTestUtils.createEmptyModule("<module>", platform)
+        val module = KotlinTestUtils.createEmptyModule("<module>", platform, DefaultBuiltIns.Instance)
 
         val packageFragmentProvider = createBuiltInPackageFragmentProvider(
                 LockBasedStorageManager(), module, setOf(TEST_PACKAGE_FQNAME), ClassDescriptorFactory.EMPTY

compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt

@@ -78,7 +78,7 @@ class KotlinJavascriptSerializerTest : TestCaseWithTmpdir() {
     }
 
     private fun deserialize(metaFile: File): ModuleDescriptorImpl {
-        val module = KotlinTestUtils.createEmptyModule("<$MODULE_NAME>", JsPlatform)
+        val module = KotlinTestUtils.createEmptyModule("<$MODULE_NAME>", JsPlatform, JsPlatform.builtIns)
         val metadata = KotlinJavascriptMetadataUtils.loadMetadata(metaFile)
         assert(metadata.size == 1)
 

generators/src/org/jetbrains/kotlin/generators/evaluate/GenerateOperationsMap.kt

@@ -16,13 +16,12 @@
 
 package org.jetbrains.kotlin.generators.evaluate
 
+import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.generators.util.GeneratorsFileUtil
-import org.jetbrains.kotlin.resolve.TargetPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.utils.Printer
@@ -50,7 +49,7 @@ fun generate(): String {
     val unaryOperationsMap = arrayListOf<Triple<String, List<KotlinType>, Boolean>>()
     val binaryOperationsMap = arrayListOf<Pair<String, List<KotlinType>>>()
 
-    val builtIns = TargetPlatform.Default.builtIns
+    val builtIns = DefaultBuiltIns.Instance
     @Suppress("UNCHECKED_CAST")
     val allPrimitiveTypes = builtIns.builtInsPackageScope.getContributedDescriptors()
             .filter { it is ClassDescriptor && KotlinBuiltIns.isPrimitiveType(it.defaultType) } as List<ClassDescriptor>

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

@@ -27,6 +27,7 @@ import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.util.containers.SLRUCache
 import org.jetbrains.kotlin.analyzer.EmptyResolverForProject
 import org.jetbrains.kotlin.asJava.outOfBlockModificationCount
+import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
 import org.jetbrains.kotlin.container.getService
@@ -36,6 +37,7 @@ import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
 import org.jetbrains.kotlin.js.resolve.JsPlatform
+import org.jetbrains.kotlin.platform.JvmBuiltIns
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.TargetPlatform
@@ -238,10 +240,17 @@ private fun globalResolveSessionProvider(
                                 ?.withCompositeExceptionTrackerUnderSameLock()
                         ?: GlobalContext(logProcessCanceled)
 
+    val builtIns: KotlinBuiltIns = when (platform) {
+        is JsPlatform -> JsPlatform.builtIns
+        is JvmPlatform -> JvmBuiltIns.Instance
+        else -> DefaultBuiltIns.Instance
+    }
+
     val moduleResolverProvider = createModuleResolverProvider(
             debugName, project, globalContext,
             AnalyzerFacadeProvider.getAnalyzerFacade(platform),
-            syntheticFiles, delegateResolverForProject, moduleFilter
+            syntheticFiles, delegateResolverForProject, moduleFilter,
+            builtIns
     )
     val allDependencies = dependencies + listOf(moduleResolverProvider.exceptionTracker)
     return CachedValueProvider.Result.create(moduleResolverProvider, allDependencies)

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

@@ -24,6 +24,7 @@ import com.intellij.openapi.roots.ModuleRootManager
 import org.jetbrains.kotlin.analyzer.AnalyzerFacade
 import org.jetbrains.kotlin.analyzer.ModuleContent
 import org.jetbrains.kotlin.analyzer.ResolverForProject
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.context.GlobalContextImpl
 import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.idea.project.IdeaEnvironment
@@ -40,7 +41,8 @@ fun createModuleResolverProvider(
         analyzerFacade: AnalyzerFacade<JvmPlatformParameters>,
         syntheticFiles: Collection<KtFile>,
         delegateResolver: ResolverForProject<IdeaModuleInfo>,
-        moduleFilter: (IdeaModuleInfo) -> Boolean
+        moduleFilter: (IdeaModuleInfo) -> Boolean,
+        builtIns: KotlinBuiltIns
 ): ModuleResolverProvider {
 
     val allModuleInfos = collectAllModuleInfosFromIdeaModel(project).toHashSet()
@@ -64,8 +66,8 @@ fun createModuleResolverProvider(
 
         val resolverForProject = analyzerFacade.setupResolverForProject(
                 debugName, globalContext.withProject(project), modulesToCreateResolversFor, modulesContent,
-                jvmPlatformParameters, IdeaEnvironment, delegateResolver,
+                jvmPlatformParameters, IdeaEnvironment, builtIns,
-                { m, c -> IDEPackagePartProvider(c.moduleContentScope) }
+                delegateResolver, { m, c -> IDEPackagePartProvider(c.moduleContentScope) }
         )
         return resolverForProject
     }

idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/KotlinJavaScriptDecompiledTextConsistencyTest.kt

@@ -48,7 +48,7 @@ class KotlinJavaScriptDecompiledTextConsistencyTest : TextConsistencyBaseTest()
 
     override fun getModuleDescriptor(): ModuleDescriptor {
         val stdlibJar = PathUtil.getKotlinPathsForDistDirectory().jsStdLibJarPath.absolutePath
-        val module = KotlinTestUtils.createEmptyModule("<module for stdlib>", JsPlatform)
+        val module = KotlinTestUtils.createEmptyModule("<module for stdlib>", JsPlatform, JsPlatform.builtIns)
         val metadata = KotlinJavascriptMetadataUtils.loadMetadata(stdlibJar)
         assert(metadata.size == 1)
 

js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java

@@ -48,7 +48,8 @@ public final class TopDownAnalyzerFacadeForJS {
         BindingTrace trace = new BindingTraceContext();
 
         MutableModuleContext newModuleContext = ContextKt.ContextForNewModule(
-                config.getProject(), Name.special("<" + config.getModuleId() + ">"), JsPlatform.INSTANCE
+                config.getProject(), Name.special("<" + config.getModuleId() + ">"), JsPlatform.INSTANCE,
+                JsPlatform.INSTANCE.getBuiltIns()
         );
         newModuleContext.setDependencies(computeDependencies(newModuleContext.getModule(), config));
         return analyzeFilesWithGivenTrace(files, trace, newModuleContext, config);

js/js.frontend/src/org/jetbrains/kotlin/js/config/Config.java

@@ -19,8 +19,8 @@ package org.jetbrains.kotlin.js.config;
 import com.google.common.collect.Lists;
 import com.intellij.openapi.project.Project;
 import com.intellij.util.SmartList;
-import kotlin.collections.CollectionsKt;
 import kotlin.Unit;
+import kotlin.collections.CollectionsKt;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -160,8 +160,8 @@ public abstract class Config {
                 ", but metadata.abiVersion = " + metadata.getAbiVersion();
 
         ModuleDescriptorImpl moduleDescriptor = TargetPlatformKt.createModule(
-                JsPlatform.INSTANCE, Name.special("<" + metadata.getModuleName() + ">"), storageManager
+                JsPlatform.INSTANCE, Name.special("<" + metadata.getModuleName() + ">"), storageManager,
-        );
+                JsPlatform.INSTANCE.getBuiltIns());
 
         PackageFragmentProvider provider =
                 KotlinJavascriptSerializationUtil.createPackageFragmentProvider(moduleDescriptor, metadata.getBody(), storageManager);