Multi-platform Projects: Enable multi-platform projects for platform modules which depend on common modules

idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/Platform.kt

@@ -20,6 +20,7 @@ import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.module.Module
 import com.intellij.openapi.module.ModuleUtilCore
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.ModuleRootManager
 import com.intellij.openapi.roots.ProjectFileIndex
 import com.sampullara.cli.Argument
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
@@ -50,7 +51,8 @@ val Project.languageVersionSettings: LanguageVersionSettings
         val extraLanguageFeatures = getExtraLanguageFeatures(
                 TargetPlatformKind.Default,
                 CoroutineSupport.byCompilerArguments(KotlinCommonCompilerArgumentsHolder.getInstance(this).settings),
-                compilerSettings
+                compilerSettings,
+                null
         )
         return LanguageVersionSettingsImpl(
                 languageVersion,
@@ -70,16 +72,25 @@ val Module.languageVersionSettings: LanguageVersionSettings
         val extraLanguageFeatures = getExtraLanguageFeatures(
                 versionInfo.targetPlatformKind ?: TargetPlatformKind.Default,
                 facetSettings.compilerInfo.coroutineSupport,
-                facetSettings.compilerInfo.compilerSettings
+                facetSettings.compilerInfo.compilerSettings,
+                this
         )
 
         return LanguageVersionSettingsImpl(languageVersion, ApiVersion.createByLanguageVersion(apiVersion), extraLanguageFeatures)
     }
 
+private val Module.targetPlatform: TargetPlatformKind<*>?
+    get() = KotlinFacetSettingsProvider.getInstance(project).getSettings(this).versionInfo.targetPlatformKind
+
+private val Module.implementsCommonModule: Boolean
+    get() = targetPlatform != TargetPlatformKind.Default
+            && ModuleRootManager.getInstance(this).dependencies.any { it.targetPlatform == TargetPlatformKind.Default}
+
 private fun getExtraLanguageFeatures(
         targetPlatformKind: TargetPlatformKind<*>,
         coroutineSupport: CoroutineSupport,
-        compilerSettings: CompilerSettings?
+        compilerSettings: CompilerSettings?,
+        module: Module?
 ): List<LanguageFeature> {
     return mutableListOf<LanguageFeature>().apply {
         when (coroutineSupport) {
@@ -89,7 +100,8 @@ private fun getExtraLanguageFeatures(
         }
         if (targetPlatformKind == TargetPlatformKind.Default ||
             // TODO: this is a dirty hack, parse arguments correctly here
-            compilerSettings?.additionalArguments?.contains(multiPlatformProjectsArg) == true) {
+            compilerSettings?.additionalArguments?.contains(multiPlatformProjectsArg) == true ||
+            (module != null && module.implementsCommonModule)) {
             add(LanguageFeature.MultiPlatformProjects)
         }
     }

jps-plugin/src/org/jetbrains/kotlin/jps/JpsKotlinCompilerSettings.kt

@@ -20,6 +20,7 @@ import org.jetbrains.jps.model.JpsProject
 import org.jetbrains.jps.model.ex.JpsElementBase
 import org.jetbrains.jps.model.ex.JpsElementChildRoleBase
 import org.jetbrains.jps.model.module.JpsModule
+import org.jetbrains.jps.model.module.JpsModuleDependency
 import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
@@ -61,15 +62,27 @@ class JpsKotlinCompilerSettings : JpsElementBase<JpsKotlinCompilerSettings>() {
             return settings
         }
 
+        private val JpsModule.targetPlatform: TargetPlatformKind<*>?
+            get() {
+                val facetSettings = kotlinFacetExtension?.settings ?: return TargetPlatformKind.Default
+                if (facetSettings.useProjectSettings) return TargetPlatformKind.Default
+                return facetSettings.versionInfo.targetPlatformKind
+            }
+
         fun getCommonCompilerArguments(module: JpsModule): CommonCompilerArguments {
             val defaultArguments = getSettings(module.project).commonCompilerArguments
             val facetSettings = module.kotlinFacetExtension?.settings ?: return defaultArguments
             if (facetSettings.useProjectSettings) return defaultArguments
             val (languageLevel, apiLevel) = facetSettings.versionInfo
-            return facetSettings.compilerInfo.commonCompilerArguments?.apply {
+            val facetArguments = facetSettings.compilerInfo.commonCompilerArguments ?: return defaultArguments
+            return copyBean(facetArguments).apply {
                 languageVersion = languageLevel?.description
                 apiVersion = apiLevel?.description
-            } ?: defaultArguments
+                multiPlatform = module
+                        .dependenciesList
+                        .dependencies
+                        .any { (it as? JpsModuleDependency)?.module?.targetPlatform == TargetPlatformKind.Default }
+            }
         }
 
         fun setCommonCompilerArguments(project: JpsProject, commonCompilerSettings: CommonCompilerArguments) {