Wizard: allow specifying Kotlin target version for JPS build system

#KT-37970 fixed

idea/idea-new-project-wizard/src/org/jetbrains/kotlin/tools/projectWizard/wizard/service/IdeaGradleWizardService.kt

@@ -15,6 +15,7 @@ import com.intellij.openapi.externalSystem.util.ExternalSystemUtil
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.LocalFileSystem
 import org.jetbrains.annotations.NonNls
+import org.jetbrains.kotlin.tools.projectWizard.core.Reader
 import org.jetbrains.kotlin.tools.projectWizard.core.TaskResult
 import org.jetbrains.kotlin.tools.projectWizard.core.andThen
 import org.jetbrains.kotlin.tools.projectWizard.core.safe
@@ -34,6 +35,7 @@ class IdeaGradleWizardService(private val project: Project) : ProjectImportingWi
     // We have to call action directly as there is no common way
     // to import Gradle project in all IDEAs from 183 to 193
     override fun importProject(
+        reader: Reader,
         path: Path,
         modulesIrs: List<ModuleIR>,
         buildSystem: BuildSystemType

idea/idea-new-project-wizard/src/org/jetbrains/kotlin/tools/projectWizard/wizard/service/IdeaJpsWizardService.kt

@@ -10,16 +10,23 @@ import com.intellij.ide.impl.NewProjectUtil
 import com.intellij.ide.util.projectWizard.ModuleBuilder
 import com.intellij.jarRepository.JarRepositoryManager
 import com.intellij.jarRepository.RemoteRepositoryDescription
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProviderImpl
 import com.intellij.openapi.module.ModifiableModuleModel
 import com.intellij.openapi.module.ModuleTypeId
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.*
 import com.intellij.openapi.roots.libraries.ui.OrderRoot
+import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.vfs.VfsUtil
 import com.intellij.util.PathUtil
 import org.jetbrains.idea.maven.utils.library.RepositoryLibraryProperties
 import org.jetbrains.jps.model.java.JavaResourceRootType
 import org.jetbrains.jps.model.java.JavaSourceRootType
+import org.jetbrains.kotlin.config.JvmTarget
+import org.jetbrains.kotlin.idea.compiler.configuration.Kotlin2JvmCompilerArgumentsHolder
+import org.jetbrains.kotlin.idea.facet.getOrCreateFacet
+import org.jetbrains.kotlin.idea.facet.initializeIfNeeded
 import org.jetbrains.kotlin.idea.formatter.KotlinStyleGuideCodeStyle.Companion.INSTANCE
 import org.jetbrains.kotlin.idea.formatter.ProjectCodeStyleImporter
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
@@ -32,6 +39,9 @@ import org.jetbrains.kotlin.tools.projectWizard.settings.buildsystem.SourcesetTy
 import org.jetbrains.kotlin.tools.projectWizard.wizard.IdeWizard
 import org.jetbrains.kotlin.tools.projectWizard.wizard.NewProjectWizardModuleBuilder
 import org.jetbrains.kotlin.idea.framework.KotlinSdkType
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
+import org.jetbrains.kotlin.tools.projectWizard.moduleConfigurators.JvmModuleConfigurator
+import org.jetbrains.kotlin.tools.projectWizard.moduleConfigurators.withSettingsOf
 import org.jetbrains.kotlin.tools.projectWizard.settings.buildsystem.Repository
 import java.nio.file.Path
 import java.util.*
@@ -47,19 +57,29 @@ class IdeaJpsWizardService(
         buildSystemType == BuildSystemType.Jps
 
     override fun importProject(
+        reader: Reader,
         path: Path,
         modulesIrs: List<ModuleIR>,
         buildSystem: BuildSystemType
     ): TaskResult<Unit> = runWriteAction {
         ideWizard.jpsData.jdk?.let { jdk -> NewProjectUtil.applyJdkToProject(project, jdk) }
         KotlinSdkType.setUpIfNeeded()
-        modulesBuilder.addModuleConfigurationUpdater(JpsModuleConfigurationUpdater(ideWizard.jpsData))
+        val projectImporter = ProjectImporter(project, modulesModel, path, modulesIrs)
+        modulesBuilder.addModuleConfigurationUpdater(
+            JpsModuleConfigurationUpdater(ideWizard.jpsData, projectImporter, project, reader)
+        )
 
-        ProjectImporter(project, modulesModel, path, modulesIrs).import()
+        projectImporter.import()
     }
 }
 
-private class JpsModuleConfigurationUpdater(private val jpsData: IdeWizard.JpsData) : ModuleBuilder.ModuleConfigurationUpdater() {
+private class JpsModuleConfigurationUpdater(
+    private val jpsData: IdeWizard.JpsData,
+    private val projectImporter: ProjectImporter,
+    private val project: Project,
+    private val reader: Reader
+) : ModuleBuilder.ModuleConfigurationUpdater() {
+
     override fun update(module: IdeaModule, rootModel: ModifiableRootModel) = with(jpsData) {
         libraryOptionsPanel.apply()?.addLibraries(
             rootModel,
@@ -67,15 +87,47 @@ private class JpsModuleConfigurationUpdater(private val jpsData: IdeWizard.JpsDa
             librariesContainer
         )
         libraryDescription.finishLibConfiguration(module, rootModel, true)
+        setUpJvmTargetVersionForModules(module, rootModel)
         ProjectCodeStyleImporter.apply(module.project, INSTANCE)
     }
+
+    private fun setUpJvmTargetVersionForModules(module: IdeaModule, rootModel: ModifiableRootModel) {
+        val modules = projectImporter.modulesIrs
+        if (modules.all { it.jvmTarget() == modules.first().jvmTarget() }) {
+            Kotlin2JvmCompilerArgumentsHolder.getInstance(project).update {
+                jvmTarget = modules.first().jvmTarget().value
+            }
+        } else {
+            val jvmTarget = modules.first { it.name == module.name }.jvmTarget()
+            val modelsProvider = IdeModifiableModelsProviderImpl(project)
+            try {
+                val facet = module.getOrCreateFacet(modelsProvider, useProjectSettings = true, commitModel = true)
+                val platform = JvmTarget.fromString(jvmTarget.value)
+                    ?.let(JvmPlatforms::jvmPlatformByTargetVersion)
+                    ?: JvmPlatforms.defaultJvmPlatform
+                facet.configuration.settings.apply {
+                    initializeIfNeeded(module, rootModel, platform)
+                    targetPlatform = platform
+                }
+            } finally {
+                modelsProvider.dispose()
+            }
+        }
+    }
+
+    private fun ModuleIR.jvmTarget() = reader {
+        withSettingsOf(originalModule) {
+            JvmModuleConfigurator.targetJvmVersion.reference.settingValue
+        }
+    }
+
 }
 
 private class ProjectImporter(
     private val project: Project,
     private val modulesModel: ModifiableModuleModel,
     private val path: Path,
-    private val modulesIrs: List<ModuleIR>
+    val modulesIrs: List<ModuleIR>
 ) {
     private val librariesPath: Path
         get() = path / "libs"

idea/idea-new-project-wizard/src/org/jetbrains/kotlin/tools/projectWizard/wizard/service/IdeaMavenWizardService.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.tools.projectWizard.wizard.service
 
 import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.tools.projectWizard.core.Reader
 import org.jetbrains.kotlin.tools.projectWizard.core.TaskResult
 import org.jetbrains.kotlin.tools.projectWizard.core.safe
 import org.jetbrains.kotlin.tools.projectWizard.core.service.ProjectImportingWizardService
@@ -19,6 +20,7 @@ class IdeaMavenWizardService(private val project: Project) : ProjectImportingWiz
         buildSystemType == BuildSystemType.Maven
 
     override fun importProject(
+        reader: Reader,
         path: Path,
         modulesIrs: List<ModuleIR>,
         buildSystem: BuildSystemType

idea/idea-new-project-wizard/tests/org/jetbrains/kotlin/tools/projectWizard/wizard/services/ProjectImportingTestWizardService.kt

@@ -16,10 +16,7 @@ import com.intellij.openapi.externalSystem.util.ExternalSystemUtil
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.idea.framework.MAVEN_SYSTEM_ID
 import org.jetbrains.kotlin.tools.projectWizard.cli.TestWizardService
-import org.jetbrains.kotlin.tools.projectWizard.core.Failure
-import org.jetbrains.kotlin.tools.projectWizard.core.ProjectImportingError
-import org.jetbrains.kotlin.tools.projectWizard.core.TaskResult
-import org.jetbrains.kotlin.tools.projectWizard.core.UNIT_SUCCESS
+import org.jetbrains.kotlin.tools.projectWizard.core.*
 import org.jetbrains.kotlin.tools.projectWizard.core.service.ProjectImportingWizardService
 import org.jetbrains.kotlin.tools.projectWizard.ir.buildsystem.ModuleIR
 import org.jetbrains.kotlin.tools.projectWizard.plugins.buildSystem.BuildSystemType
@@ -32,6 +29,7 @@ class GradleProjectImportingTestWizardService(private val project: Project) : Pr
         buildSystemType.isGradle || buildSystemType == BuildSystemType.Maven
 
     override fun importProject(
+        reader: Reader,
         path: Path,
         modulesIrs: List<ModuleIR>,
         buildSystem: BuildSystemType
@@ -46,7 +44,8 @@ class GradleProjectImportingTestWizardService(private val project: Project) : Pr
                         if (externalProject == null) {
                             importingErrorMessage = "Got null External project after import"
                         } else {
-                            ServiceManager.getService(ProjectDataManager::class.java).importData(externalProject, project, true)
+                            ServiceManager.getService(ProjectDataManager::class.java).importData(externalProject,
+                                                                                                 project, true)
                         }
                     }
 

libraries/tools/new-project-wizard/src/org/jetbrains/kotlin/tools/projectWizard/core/service/ProjectImportingWizardService.kt

@@ -1,5 +1,6 @@
 package org.jetbrains.kotlin.tools.projectWizard.core.service
 
+import org.jetbrains.kotlin.tools.projectWizard.core.Reader
 import org.jetbrains.kotlin.tools.projectWizard.core.TaskResult
 import org.jetbrains.kotlin.tools.projectWizard.core.UNIT_SUCCESS
 import org.jetbrains.kotlin.tools.projectWizard.ir.buildsystem.ModuleIR
@@ -8,6 +9,7 @@ import java.nio.file.Path
 
 interface ProjectImportingWizardService : BuildSystemWizardService {
     fun importProject(
+        reader: Reader,
         path: Path,
         modulesIrs: List<ModuleIR>,
         buildSystem: BuildSystemType
@@ -17,6 +19,7 @@ interface ProjectImportingWizardService : BuildSystemWizardService {
 class ProjectImportingWizardServiceImpl : ProjectImportingWizardService, IdeaIndependentWizardService {
     override fun isSuitableFor(buildSystemType: BuildSystemType): Boolean = true
     override fun importProject(
+        reader: Reader,
         path: Path,
         modulesIrs: List<ModuleIR>,
         buildSystem: BuildSystemType

libraries/tools/new-project-wizard/src/org/jetbrains/kotlin/tools/projectWizard/plugins/buildSystem/BuildSystemPlugin.kt

@@ -100,7 +100,7 @@ abstract class BuildSystemPlugin(context: Context) : Plugin(context) {
         withAction {
             val data = BuildSystemPlugin::buildSystemData.propertyValue.first { it.type == buildSystemType }
             service<ProjectImportingWizardService> { service -> service.isSuitableFor(data.type) }
-                .importProject(StructurePlugin::projectPath.reference.settingValue, allIRModules, buildSystemType)
+                .importProject(this, StructurePlugin::projectPath.reference.settingValue, allIRModules, buildSystemType)
         }
     }