Extract module info & target platform to separate frontend.common

compiler/frontend.common/build.gradle.kts

@@ -0,0 +1,18 @@
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+dependencies {
+    compile(project(":compiler:psi"))
+    compile(project(":compiler:container"))
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core", "annotations") }
+}
+
+
+sourceSets {
+    "main" {
+        projectDefault()
+    }
+    "test" {}
+}

compiler/frontend.common/src/org/jetbrains/kotlin/analyzer/ModuleInfo.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analyzer
+
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.TargetPlatform
+
+
+interface ModuleInfo {
+    val name: Name
+    val displayedName: String get() = name.asString()
+    fun dependencies(): List<ModuleInfo>
+    val expectedBy: List<ModuleInfo> get() = emptyList()
+    val platform: TargetPlatform? get() = null
+    fun modulesWhoseInternalsAreVisible(): Collection<ModuleInfo> = listOf()
+    val capabilities: Map<ModuleDescriptor.Capability<*>, Any?>
+        get() = mapOf(Capability to this)
+    val stableName: Name?
+        get() = null
+
+    // For common modules, we add built-ins at the beginning of the dependencies list, after the SDK.
+    // This is needed because if a JVM module depends on the common module, we should use JVM built-ins for resolution of both modules.
+    // The common module usually depends on kotlin-stdlib-common which may or may not have its own (common, non-JVM) built-ins,
+    // but if they are present, they should come after JVM built-ins in the dependencies list, because JVM built-ins contain
+    // additional members dependent on the JDK
+    fun dependencyOnBuiltIns(): ModuleInfo.DependencyOnBuiltIns =
+        platform?.dependencyOnBuiltIns() ?: ModuleInfo.DependencyOnBuiltIns.LAST
+
+    //TODO: (module refactoring) provide dependency on builtins after runtime in IDEA
+    enum class DependencyOnBuiltIns { NONE, AFTER_SDK, LAST }
+
+    companion object {
+        val Capability = ModuleDescriptor.Capability<ModuleInfo>("ModuleInfo")
+    }
+}

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

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.resolve
+
+import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.config.*
+import org.jetbrains.kotlin.container.StorageComponentContainer
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
+import org.jetbrains.kotlin.storage.StorageManager
+import java.util.*
+
+abstract class TargetPlatform(val platformName: String) {
+    private data class DefaultImportsKey(val includeKotlinComparisons: Boolean, val includeLowPriorityImports: Boolean)
+
+    private val defaultImports = LockBasedStorageManager().let { storageManager ->
+        storageManager.createMemoizedFunction<DefaultImportsKey, List<ImportPath>> { (includeKotlinComparisons, includeLowPriorityImports) ->
+            ArrayList<ImportPath>().apply {
+                listOf(
+                    "kotlin.*",
+                    "kotlin.annotation.*",
+                    "kotlin.collections.*",
+                    "kotlin.ranges.*",
+                    "kotlin.sequences.*",
+                    "kotlin.text.*",
+                    "kotlin.io.*"
+                ).forEach { add(ImportPath.fromString(it)) }
+
+                if (includeKotlinComparisons) {
+                    add(ImportPath.fromString("kotlin.comparisons.*"))
+                }
+
+                computePlatformSpecificDefaultImports(storageManager, this)
+
+                if (includeLowPriorityImports) {
+                    addAll(defaultLowPriorityImports)
+                }
+            }
+        }
+    }
+
+    override fun toString() = platformName
+
+    abstract val platformConfigurator: PlatformConfigurator
+
+    open val defaultLowPriorityImports: List<ImportPath> get() = emptyList()
+
+    fun getDefaultImports(languageVersionSettings: LanguageVersionSettings, includeLowPriorityImports: Boolean): List<ImportPath> =
+        defaultImports(
+            DefaultImportsKey(
+                languageVersionSettings.supportsFeature(LanguageFeature.DefaultImportOfPackageKotlinComparisons),
+                includeLowPriorityImports
+            )
+        )
+
+    protected abstract fun computePlatformSpecificDefaultImports(storageManager: StorageManager, result: MutableList<ImportPath>)
+
+    open val excludedImports: List<FqName> get() = emptyList()
+
+    abstract val multiTargetPlatform: MultiTargetPlatform
+
+    // This function is used in "cat.helm.clean:0.1.1-SNAPSHOT": https://plugins.jetbrains.com/plugin/index?xmlId=cat.helm.clean
+    @Suppress("DeprecatedCallableAddReplaceWith", "unused")
+    @Deprecated("Use getDefaultImports(LanguageVersionSettings, Boolean) instead.", level = DeprecationLevel.ERROR)
+    fun getDefaultImports(includeKotlinComparisons: Boolean): List<ImportPath> {
+        return getDefaultImports(
+            if (includeKotlinComparisons) LanguageVersionSettingsImpl.DEFAULT
+            else LanguageVersionSettingsImpl(LanguageVersion.KOTLIN_1_0, ApiVersion.KOTLIN_1_0),
+            true
+        )
+    }
+
+    open fun dependencyOnBuiltIns(): ModuleInfo.DependencyOnBuiltIns = ModuleInfo.DependencyOnBuiltIns.LAST
+}
+
+interface PlatformConfigurator {
+    val platformSpecificContainer: StorageComponentContainer
+    fun configureModuleComponents(container: StorageComponentContainer)
+    fun configureModuleDependentCheckers(container: StorageComponentContainer)
+}