azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Kotlin Facet: Change module JDK according to jdkHome

Browse Source 
It's possible when JDK with the same home path is already configured
This commit is contained in:
Alexey Sedunov
2017-06-22 19:49:44 +03:00
parent 2a53043fef
commit ee200c87ea
5 changed files with 156 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/idea-maven/src/org/jetbrains/kotlin/idea/maven/KotlinMavenImporter.kt
+3 -2
View File
@@ -125,6 +125,7 @@ class KotlinMavenImporter : MavenImporter(KOTLIN_PLUGIN_GROUP_ID, KOTLIN_PLUGIN_
when (arguments) {
is K2JVMCompilerArguments -> {
arguments.classpath = configuration?.getChild("classpath")?.text
arguments.jdkHome = configuration?.getChild("jdkHome")?.text
arguments.jvmTarget = configuration?.getChild("jvmTarget")?.text ?: mavenProject.properties["kotlin.compiler.jvmTarget"]?.toString()
}
is K2JSCompilerArguments -> {
@@ -163,9 +164,9 @@ class KotlinMavenImporter : MavenImporter(KOTLIN_PLUGIN_GROUP_ID, KOTLIN_PLUGIN_
val executionArguments = mavenPlugin.executions?.filter { it.goals.any { it in compilationGoals } }
?.firstOrNull()
?.configurationElement?.let { getCompilerArgumentsByConfigurationElement(mavenProject, it, configuredPlatform) }
parseCompilerArgumentsToFacet(sharedArguments, emptyList(), kotlinFacet)
parseCompilerArgumentsToFacet(sharedArguments, emptyList(), kotlinFacet, modifiableModelsProvider)
if (executionArguments != null) {
parseCompilerArgumentsToFacet(executionArguments, emptyList(), kotlinFacet)
parseCompilerArgumentsToFacet(executionArguments, emptyList(), kotlinFacet, modifiableModelsProvider)
}
MavenProjectImportHandler.getInstances(module.project).forEach { it(kotlinFacet, mavenProject) }
}
idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/KotlinMavenImporterTest.kt
+72
View File
@@ -16,6 +16,11 @@
package org.jetbrains.kotlin.idea.maven
import com.intellij.openapi.application.Result
import com.intellij.openapi.application.WriteAction
import com.intellij.openapi.projectRoots.JavaSdk
import com.intellij.openapi.projectRoots.ProjectJdkTable
import com.intellij.openapi.roots.ModuleRootManager
import org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments
import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
import org.jetbrains.kotlin.config.*
@@ -1645,6 +1650,73 @@ class KotlinMavenImporterTest : MavenImportingTestCase() {
}
}
fun testJDKImport() {
object : WriteAction<Unit>() {
override fun run(result: Result<Unit>) {
val jdk = JavaSdk.getInstance().createJdk("myJDK", "my/path/to/jdk")
ProjectJdkTable.getInstance().addJdk(jdk)
}
}.execute()
try {
createProjectSubDirs("src/main/kotlin", "src/main/kotlin.jvm", "src/test/kotlin", "src/test/kotlin.jvm")
importProject("""
<groupId>test</groupId>
<artifactId>project</artifactId>
<version>1.0.0</version>
<dependencies>
<dependency>
<groupId>org.jetbrains.kotlin</groupId>
<artifactId>kotlin-stdlib</artifactId>
<version>$kotlinVersion</version>
</dependency>
</dependencies>
<build>
<sourceDirectory>src/main/kotlin</sourceDirectory>
<plugins>
<plugin>
<groupId>org.jetbrains.kotlin</groupId>
<artifactId>kotlin-maven-plugin</artifactId>
<executions>
<execution>
<id>compile</id>
<phase>compile</phase>
<goals>
<goal>compile</goal>
</goals>
</execution>
</executions>
<configuration>
<jdkHome>my/path/to/jdk</jdkHome>
</configuration>
</plugin>
</plugins>
</build>
""")
assertModules("project")
assertImporterStatePresent()
val moduleSDK = ModuleRootManager.getInstance(getModule("project")).sdk!!
Assert.assertTrue(moduleSDK.sdkType is JavaSdk)
Assert.assertEquals("myJDK", moduleSDK.name)
Assert.assertEquals("my/path/to/jdk", moduleSDK.homePath)
}
finally {
object : WriteAction<Unit>() {
override fun run(result: Result<Unit>) {
val jdkTable = ProjectJdkTable.getInstance()
jdkTable.removeJdk(jdkTable.findJdk("myJDK"))
}
}.execute()
}
}
private fun assertImporterStatePresent() {
assertNotNull("Kotlin importer component is not present", myTestFixture.module.getComponent(KotlinImporterComponent::class.java))
}
idea/src/org/jetbrains/kotlin/idea/configuration/KotlinGradleSourceSetDataService.kt
+1 -1
View File
@@ -139,7 +139,7 @@ private fun configureFacetByGradleModule(
val defaultCompilerArguments = argsInfo.defaultArguments
val dependencyClasspath = argsInfo.dependencyClasspath.map { PathUtil.toSystemIndependentName(it) }
if (currentCompilerArguments.isNotEmpty()) {
parseCompilerArgumentsToFacet(currentCompilerArguments, defaultCompilerArguments, kotlinFacet)
parseCompilerArgumentsToFacet(currentCompilerArguments, defaultCompilerArguments, kotlinFacet, modelsProvider)
}
adjustClasspath(kotlinFacet, dependencyClasspath)
}
idea/src/org/jetbrains/kotlin/idea/facet/facetUtils.kt
+20 -1
View File
@@ -21,8 +21,10 @@ import com.intellij.openapi.module.Module
import com.intellij.openapi.project.Project
import com.intellij.openapi.projectRoots.JavaSdk
import com.intellij.openapi.projectRoots.JavaSdkVersion
import com.intellij.openapi.projectRoots.ProjectJdkTable
import com.intellij.openapi.roots.ModuleRootManager
import com.intellij.openapi.roots.ModuleRootModel
import com.intellij.openapi.util.io.FileUtil
import com.intellij.openapi.util.text.StringUtil
import org.jetbrains.kotlin.cli.common.arguments.*
import org.jetbrains.kotlin.compilerRunner.ArgumentUtils
@@ -184,7 +186,20 @@ private val CommonCompilerArguments.ignoredFields: List<String>
else -> emptyList()
}
fun parseCompilerArgumentsToFacet(arguments: List<String>, defaultArguments: List<String>, kotlinFacet: KotlinFacet) {
private fun Module.configureJdkIfPossible(compilerArguments: K2JVMCompilerArguments, modelsProvider: IdeModifiableModelsProvider) {
val jdkHome = compilerArguments.jdkHome ?: return
val jdk = ProjectJdkTable.getInstance().allJdks.firstOrNull {
it.sdkType is JavaSdk && FileUtil.comparePaths(it.homePath, jdkHome) == 0
} ?: return
modelsProvider.getModifiableRootModel(this).sdk = jdk
}
fun parseCompilerArgumentsToFacet(
arguments: List<String>,
defaultArguments: List<String>,
kotlinFacet: KotlinFacet,
modelsProvider: IdeModifiableModelsProvider
) {
val argumentArray = arguments.toTypedArray()
with(kotlinFacet.configuration.settings) {
@@ -201,6 +216,10 @@ fun parseCompilerArgumentsToFacet(arguments: List<String>, defaultArguments: Lis
// Retain only fields exposed (and not explicitly ignored) in facet configuration editor.
// The rest is combined into string and stored in CompilerSettings.additionalArguments
if (compilerArguments is K2JVMCompilerArguments) {
kotlinFacet.module.configureJdkIfPossible(compilerArguments, modelsProvider)
}
val primaryFields = compilerArguments.primaryFields
val ignoredFields = compilerArguments.ignoredFields
idea/tests/org/jetbrains/kotlin/idea/codeInsight/gradle/GradleFacetImportTest.kt
+60
View File
@@ -16,6 +16,11 @@
package org.jetbrains.kotlin.idea.codeInsight.gradle
import com.intellij.openapi.application.Result
import com.intellij.openapi.application.WriteAction
import com.intellij.openapi.projectRoots.JavaSdk
import com.intellij.openapi.projectRoots.ProjectJdkTable
import com.intellij.openapi.roots.ModuleRootManager
import com.intellij.openapi.util.text.StringUtil
import org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments
import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
@@ -1079,4 +1084,59 @@ class GradleFacetImportTest : GradleImportingTestCase() {
Assert.assertEquals(null, (compilerArguments as K2JVMCompilerArguments).classpath)
}
}
@Test
fun testJDKImport() {
object : WriteAction<Unit>() {
override fun run(result: Result<Unit>) {
val jdk = JavaSdk.getInstance().createJdk("myJDK", "my/path/to/jdk")
ProjectJdkTable.getInstance().addJdk(jdk)
}
}.execute()
try {
createProjectSubFile("build.gradle", """
group 'Again'
version '1.0-SNAPSHOT'
buildscript {
repositories {
mavenCentral()
maven {
url 'http://dl.bintray.com/kotlin/kotlin-eap-1.1'
}
}
dependencies {
classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.1.0")
}
}
apply plugin: 'kotlin'
dependencies {
compile "org.jetbrains.kotlin:kotlin-stdlib:1.1.0"
compile "org.apache.logging.log4j:log4j-core:2.7"
}
compileKotlin {
kotlinOptions.jdkHome = "my/path/to/jdk"
}
""")
importProject()
val moduleSDK = ModuleRootManager.getInstance(getModule("project_main")).sdk!!
Assert.assertTrue(moduleSDK.sdkType is JavaSdk)
Assert.assertEquals("myJDK", moduleSDK.name)
Assert.assertEquals("my/path/to/jdk", moduleSDK.homePath)
}
finally {
object : WriteAction<Unit>() {
override fun run(result: Result<Unit>) {
val jdkTable = ProjectJdkTable.getInstance()
jdkTable.removeJdk(jdkTable.findJdk("myJDK"))
}
}.execute()
}
}
}