Remove duplicated code in annotation-based-compiler-plugins-ide-support

plugins/allopen/allopen-ide/src/AllOpenGradleProjectImportHandler.kt

@@ -17,10 +17,10 @@
 package org.jetbrains.kotlin.allopen.ide
 
 import org.jetbrains.kotlin.allopen.AllOpenCommandLineProcessor
-import org.jetbrains.kotlin.annotation.plugin.ide.AbstractGradleImportHandler
+import org.jetbrains.kotlin.annotation.plugin.ide.AbstractAnnotationPluginGradleImportHandler
 import org.jetbrains.kotlin.utils.PathUtil
 
-class AllOpenGradleProjectImportHandler : AbstractGradleImportHandler<AllOpenModel>() {
+class AllOpenGradleProjectImportHandler : AbstractAnnotationPluginGradleImportHandler<AllOpenModel>() {
     override val compilerPluginId = AllOpenCommandLineProcessor.PLUGIN_ID
     override val pluginName = "allopen"
     override val annotationOptionName = AllOpenCommandLineProcessor.ANNOTATION_OPTION.optionName

plugins/allopen/allopen-ide/src/AllOpenMavenProjectImportHandler.kt

@@ -17,8 +17,8 @@
 package org.jetbrains.kotlin.allopen.ide
 
 import org.jetbrains.kotlin.allopen.AllOpenCommandLineProcessor
-import org.jetbrains.kotlin.annotation.plugin.ide.AbstractMavenImportHandler
+import org.jetbrains.kotlin.plugin.ide.CompilerPluginSetup.PluginOption
-import org.jetbrains.kotlin.annotation.plugin.ide.AnnotationBasedCompilerPluginSetup.PluginOption
+import org.jetbrains.kotlin.plugin.ide.AbstractMavenImportHandler
 import org.jetbrains.kotlin.utils.PathUtil
 
 class AllOpenMavenProjectImportHandler : AbstractMavenImportHandler() {
@@ -28,7 +28,6 @@ class AllOpenMavenProjectImportHandler : AbstractMavenImportHandler() {
 
     override val compilerPluginId = AllOpenCommandLineProcessor.PLUGIN_ID
     override val pluginName = "allopen"
-    override val mavenPluginArtifactName = "kotlin-maven-allopen"
     override val pluginJarFileFromIdea = PathUtil.kotlinPathsForIdeaPlugin.allOpenPluginJarPath
 
     override fun getOptions(enabledCompilerPlugins: List<String>, compilerPluginOptions: List<String>): List<PluginOption>? {

plugins/annotation-based-compiler-plugins-ide-support/build.gradle.kts

@@ -13,6 +13,7 @@ dependencies {
     compile(project(":idea:idea-jps-common"))
     compile(project(":idea:idea-gradle"))
     compile(project(":idea:idea-maven"))
+    api(project(":plugins:base-compiler-plugins-ide-support"))
     excludeInAndroidStudio(rootProject) { compileOnly(intellijPluginDep("maven")) }
     compileOnly(intellijPluginDep("gradle"))
     compileOnly(intellijDep())

plugins/annotation-based-compiler-plugins-ide-support/src/AbstractAnnotationPluginGradleImportHandler.kt

@@ -10,13 +10,15 @@ import com.intellij.openapi.externalSystem.model.ProjectKeys
 import com.intellij.openapi.externalSystem.model.project.ModuleData
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
 import com.intellij.openapi.util.Key
-import org.jetbrains.kotlin.annotation.plugin.ide.AnnotationBasedCompilerPluginSetup.PluginOption
+import org.jetbrains.kotlin.plugin.ide.CompilerPluginSetup.PluginOption
 import org.jetbrains.kotlin.idea.configuration.GradleProjectImportHandler
 import org.jetbrains.kotlin.idea.facet.KotlinFacet
+import org.jetbrains.kotlin.plugin.ide.CompilerPluginSetup
+import org.jetbrains.kotlin.plugin.ide.modifyCompilerArgumentsForPlugin
 import org.jetbrains.plugins.gradle.model.data.GradleSourceSetData
 import java.io.File
 
-abstract class AbstractGradleImportHandler<T : AnnotationBasedPluginModel> : GradleProjectImportHandler {
+abstract class AbstractAnnotationPluginGradleImportHandler<T : AnnotationBasedPluginModel> : GradleProjectImportHandler {
     abstract val compilerPluginId: String
     abstract val pluginName: String
     abstract val annotationOptionName: String
@@ -42,7 +44,7 @@ abstract class AbstractGradleImportHandler<T : AnnotationBasedPluginModel> : Gra
 
     private fun getPluginSetupByModule(
             moduleNode: DataNode<ModuleData>
-    ): AnnotationBasedCompilerPluginSetup? {
+    ): CompilerPluginSetup? {
         val pluginModel = moduleNode.getCopyableUserData(modelKey)?.takeIf { it.isEnabled } ?: return null
         val annotations = pluginModel.annotations
         val presets = pluginModel.presets
@@ -54,7 +56,7 @@ abstract class AbstractGradleImportHandler<T : AnnotationBasedPluginModel> : Gra
         // So we use ones from the IDEA plugin.
         val classpath = listOf(pluginJarFileFromIdea.absolutePath)
 
-        return AnnotationBasedCompilerPluginSetup(options, classpath)
+        return CompilerPluginSetup(options, classpath)
     }
 
     private fun getPluginSetupBySourceSet(sourceSetNode: DataNode<GradleSourceSetData>) =

plugins/annotation-based-compiler-plugins-ide-support/src/AbstractMavenImportHandler.kt

@@ -1,72 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.annotation.plugin.ide
-
-import org.jdom.Element
-import org.jdom.Text
-import org.jetbrains.idea.maven.project.MavenProject
-import org.jetbrains.kotlin.annotation.plugin.ide.AnnotationBasedCompilerPluginSetup.PluginOption
-import org.jetbrains.kotlin.idea.facet.KotlinFacet
-import org.jetbrains.kotlin.idea.maven.MavenProjectImportHandler
-import org.jetbrains.kotlin.idea.maven.KotlinMavenImporter.Companion.KOTLIN_PLUGIN_GROUP_ID
-import org.jetbrains.kotlin.idea.maven.KotlinMavenImporter.Companion.KOTLIN_PLUGIN_ARTIFACT_ID
-import java.io.File
-
-abstract class AbstractMavenImportHandler : MavenProjectImportHandler {
-    abstract val compilerPluginId: String
-    abstract val pluginName: String
-    abstract val mavenPluginArtifactName: String
-    abstract val pluginJarFileFromIdea: File
-
-    override fun invoke(facet: KotlinFacet, mavenProject: MavenProject) {
-        modifyCompilerArgumentsForPlugin(facet, getPluginSetup(mavenProject),
-                                         compilerPluginId = compilerPluginId,
-                                         pluginName = pluginName)
-    }
-
-    abstract fun getOptions(enabledCompilerPlugins: List<String>, compilerPluginOptions: List<String>): List<PluginOption>?
-
-    private fun getPluginSetup(mavenProject: MavenProject): AnnotationBasedCompilerPluginSetup? {
-        val kotlinPlugin = mavenProject.plugins.firstOrNull {
-            it.groupId == KOTLIN_PLUGIN_GROUP_ID && it.artifactId == KOTLIN_PLUGIN_ARTIFACT_ID
-        } ?: return null
-
-        val configuration = kotlinPlugin.configurationElement ?: return null
-
-        val enabledCompilerPlugins = configuration.getElement("compilerPlugins")
-                ?.getElements()
-                ?.flatMap { plugin -> plugin.content.mapNotNull { (it as? Text)?.text } }
-                ?: emptyList()
-
-        val compilerPluginOptions = configuration.getElement("pluginOptions")
-                ?.getElements()
-                ?.flatMap { it.content }
-                ?.mapTo(mutableListOf()) { (it as Text).text }
-                ?: mutableListOf<String>()
-
-        // We can't use the plugin from Gradle as it may have the incompatible version
-        val classpath = listOf(pluginJarFileFromIdea.absolutePath)
-
-        val options = getOptions(enabledCompilerPlugins, compilerPluginOptions) ?: return null
-        return AnnotationBasedCompilerPluginSetup(options, classpath)
-    }
-
-    private fun Element.getElement(name: String) = content.firstOrNull { it is Element && it.name == name } as? Element
-
-    @Suppress("UNCHECKED_CAST")
-    private fun Element.getElements() = content.filterIsInstance<Element>()
-}

plugins/annotation-based-compiler-plugins-ide-support/src/idePluginUtils.kt

@@ -17,12 +17,6 @@
 package org.jetbrains.kotlin.annotation.plugin.ide
 
 import com.intellij.openapi.module.Module
-import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
-import org.jetbrains.kotlin.idea.facet.KotlinFacet
-import org.jetbrains.kotlin.lexer.KtTokens
-import org.jetbrains.kotlin.psi.KtClass
-import org.jetbrains.kotlin.psi.KtDeclaration
-import java.io.File
 
 fun Module.getSpecialAnnotations(prefix: String): List<String> {
     val kotlinFacet = org.jetbrains.kotlin.idea.facet.KotlinFacet.get(this) ?: return emptyList()
@@ -33,41 +27,3 @@ fun Module.getSpecialAnnotations(prefix: String): List<String> {
         ?.map { it.substring(prefix.length) }
         ?: emptyList()
 }
-
-class AnnotationBasedCompilerPluginSetup(val options: List<PluginOption>, val classpath: List<String>) {
-    class PluginOption(val key: String, val value: String)
-}
-
-internal fun modifyCompilerArgumentsForPlugin(
-    facet: KotlinFacet,
-    setup: AnnotationBasedCompilerPluginSetup?,
-    compilerPluginId: String,
-    pluginName: String
-) {
-    val facetSettings = facet.configuration.settings
-
-    // investigate why copyBean() sometimes throws exceptions
-    val commonArguments = facetSettings.compilerArguments ?: CommonCompilerArguments.DummyImpl()
-
-    /** See [CommonCompilerArguments.PLUGIN_OPTION_FORMAT] **/
-    val newOptionsForPlugin = setup?.options?.map { "plugin:$compilerPluginId:${it.key}=${it.value}" } ?: emptyList()
-
-    val oldAllPluginOptions =
-        (commonArguments.pluginOptions ?: emptyArray()).filterTo(mutableListOf()) { !it.startsWith("plugin:$compilerPluginId:") }
-    val newAllPluginOptions = oldAllPluginOptions + newOptionsForPlugin
-
-    val oldPluginClasspaths = (commonArguments.pluginClasspaths ?: emptyArray()).filterTo(mutableListOf()) {
-        val lastIndexOfFile = it.lastIndexOfAny(charArrayOf('/', File.separatorChar))
-        if (lastIndexOfFile < 0) {
-            return@filterTo true
-        }
-        !it.drop(lastIndexOfFile + 1).matches("(kotlin-)?(maven-)?$pluginName-.*\\.jar".toRegex())
-    }
-
-    val newPluginClasspaths = oldPluginClasspaths + (setup?.classpath ?: emptyList())
-
-    commonArguments.pluginOptions = newAllPluginOptions.toTypedArray()
-    commonArguments.pluginClasspaths = newPluginClasspaths.toTypedArray()
-
-    facetSettings.compilerArguments = commonArguments
-}

plugins/base-compiler-plugins-ide-support/build.gradle.kts

@@ -5,14 +5,11 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
+    implementation(project(":idea"))
-    compile(project(":compiler:frontend"))
+    implementation(project(":idea:idea-jvm"))
-    compile(project(":compiler:cli-common"))
+    implementation(project(":idea:idea-jps-common"))
-    compile(project(":idea"))
+    implementation(project(":idea:idea-gradle"))
-    compile(project(":idea:idea-jvm"))
+    implementation(project(":idea:idea-maven"))
-    compile(project(":idea:idea-jps-common"))
-    compile(project(":idea:idea-gradle"))
-    compile(project(":idea:idea-maven"))
     excludeInAndroidStudio(rootProject) { compileOnly(intellijPluginDep("maven")) }
     compileOnly(intellijPluginDep("gradle"))
     compileOnly(intellijDep())

plugins/base-compiler-plugins-ide-support/src/org/jetbrains/kotlin/plugin/ide/idePluginUtils.kt

@@ -9,14 +9,11 @@ import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
 import org.jetbrains.kotlin.idea.facet.KotlinFacet
 import java.io.File
 
-//todo this is basically a copy-paste of the same file from annotation-based-compiler-plugins-ide-support
-//and should be merged together later
-
 class CompilerPluginSetup(val options: List<PluginOption>, val classpath: List<String>) {
     class PluginOption(val key: String, val value: String)
 }
 
-internal fun modifyCompilerArgumentsForPlugin(
+fun modifyCompilerArgumentsForPlugin(
     facet: KotlinFacet,
     setup: CompilerPluginSetup?,
     compilerPluginId: String,

plugins/kotlin-serialization/kotlin-serialization-ide/src/org/jetbrains/kotlinx/serialization/idea/KotlinSerializationMavenImportHandler.kt

@@ -5,20 +5,19 @@
 
 package org.jetbrains.kotlinx.serialization.idea
 
-import org.jetbrains.kotlin.annotation.plugin.ide.AbstractMavenImportHandler
+import org.jetbrains.kotlin.plugin.ide.AbstractMavenImportHandler
-import org.jetbrains.kotlin.annotation.plugin.ide.AnnotationBasedCompilerPluginSetup
+import org.jetbrains.kotlin.plugin.ide.CompilerPluginSetup
 import java.io.File
 
 class KotlinSerializationMavenImportHandler : AbstractMavenImportHandler() {
     override val compilerPluginId: String = "org.jetbrains.kotlinx.serialization"
     override val pluginName: String = "serialization"
-    override val mavenPluginArtifactName: String = "kotlin-maven-serialization"
     override val pluginJarFileFromIdea: File
         get() = File(KotlinSerializationImportHandler.PLUGIN_JPS_JAR)
 
     override fun getOptions(
         enabledCompilerPlugins: List<String>,
         compilerPluginOptions: List<String>
-    ): List<AnnotationBasedCompilerPluginSetup.PluginOption>? =
+    ): List<CompilerPluginSetup.PluginOption>? =
         if ("kotlinx-serialization" in enabledCompilerPlugins) emptyList() else null
 }

plugins/lombok/lombok-ide-plugin/build.gradle.kts

@@ -13,6 +13,7 @@ dependencies {
     compileOnly(project(":idea:idea-jvm"))
     compileOnly(project(":idea:idea-jps-common"))
     compileOnly(project(":idea:idea-maven"))
+    compileOnly(project(":idea:idea-gradle"))
     compileOnly(intellijDep())
     excludeInAndroidStudio(rootProject) { compileOnly(intellijPluginDep("maven")) }
     compileOnly(intellijPluginDep("gradle"))

plugins/lombok/lombok-ide-plugin/src/org/jetbrains/kotlin/lombok/ide/LombokMavenProjectImportHandler.kt

@@ -23,9 +23,9 @@ class LombokMavenProjectImportHandler : AbstractMavenImportHandler() {
     ): List<PluginOption>? {
         if (!enabledCompilerPlugins.contains(pluginName)) return null
 
-        return compilerPluginOptions.mapNotNull { v ->
+        return compilerPluginOptions.mapNotNull { option ->
-            if (v.startsWith(CONFIG_FILE_PREFIX)) {
+            if (option.startsWith(CONFIG_FILE_PREFIX)) {
-                val location = v.substring(CONFIG_FILE_PREFIX.length)
+                val location = option.substring(CONFIG_FILE_PREFIX.length)
                 PluginOption(CONFIG_FILE_OPTION.optionName, location)
             } else {
                 null

plugins/noarg/noarg-ide/src/NoArgGradleProjectImportHandler.kt

@@ -16,12 +16,12 @@
 
 package org.jetbrains.kotlin.noarg.ide
 
-import org.jetbrains.kotlin.annotation.plugin.ide.AbstractGradleImportHandler
+import org.jetbrains.kotlin.annotation.plugin.ide.AbstractAnnotationPluginGradleImportHandler
-import org.jetbrains.kotlin.annotation.plugin.ide.AnnotationBasedCompilerPluginSetup.PluginOption
+import org.jetbrains.kotlin.plugin.ide.CompilerPluginSetup.PluginOption
 import org.jetbrains.kotlin.noarg.NoArgCommandLineProcessor
 import org.jetbrains.kotlin.utils.PathUtil
 
-class NoArgGradleProjectImportHandler : AbstractGradleImportHandler<NoArgModel>() {
+class NoArgGradleProjectImportHandler : AbstractAnnotationPluginGradleImportHandler<NoArgModel>() {
     override val compilerPluginId = NoArgCommandLineProcessor.PLUGIN_ID
     override val pluginName = "noarg"
     override val annotationOptionName = NoArgCommandLineProcessor.ANNOTATION_OPTION.optionName

plugins/noarg/noarg-ide/src/NoArgMavenProjectImportHandler.kt

@@ -16,9 +16,9 @@
 
 package org.jetbrains.kotlin.noarg.ide
 
-import org.jetbrains.kotlin.annotation.plugin.ide.AbstractMavenImportHandler
+import org.jetbrains.kotlin.plugin.ide.CompilerPluginSetup.PluginOption
-import org.jetbrains.kotlin.annotation.plugin.ide.AnnotationBasedCompilerPluginSetup.PluginOption
 import org.jetbrains.kotlin.noarg.NoArgCommandLineProcessor
+import org.jetbrains.kotlin.plugin.ide.AbstractMavenImportHandler
 import org.jetbrains.kotlin.utils.PathUtil
 
 class NoArgMavenProjectImportHandler : AbstractMavenImportHandler() {
@@ -29,7 +29,6 @@ class NoArgMavenProjectImportHandler : AbstractMavenImportHandler() {
 
     override val compilerPluginId = NoArgCommandLineProcessor.PLUGIN_ID
     override val pluginName = "noarg"
-    override val mavenPluginArtifactName = "kotlin-maven-noarg"
     override val pluginJarFileFromIdea = PathUtil.kotlinPathsForIdeaPlugin.noArgPluginJarPath
 
     override fun getOptions(enabledCompilerPlugins: List<String>, compilerPluginOptions: List<String>): List<PluginOption>? {

plugins/sam-with-receiver/sam-with-receiver-ide/src/SamWithReceiverGradleProjectImportHandler.kt

@@ -16,11 +16,11 @@
 
 package org.jetbrains.kotlin.samWithReceiver.ide
 
-import org.jetbrains.kotlin.annotation.plugin.ide.AbstractGradleImportHandler
+import org.jetbrains.kotlin.annotation.plugin.ide.AbstractAnnotationPluginGradleImportHandler
 import org.jetbrains.kotlin.samWithReceiver.SamWithReceiverCommandLineProcessor
 import org.jetbrains.kotlin.utils.PathUtil
 
-class SamWithReceiverGradleProjectImportHandler : AbstractGradleImportHandler<SamWithReceiverModel>() {
+class SamWithReceiverGradleProjectImportHandler : AbstractAnnotationPluginGradleImportHandler<SamWithReceiverModel>() {
     override val compilerPluginId = SamWithReceiverCommandLineProcessor.PLUGIN_ID
     override val pluginName = "sam-with-receiver"
     override val annotationOptionName = SamWithReceiverCommandLineProcessor.ANNOTATION_OPTION.optionName

plugins/sam-with-receiver/sam-with-receiver-ide/src/SamWithReceiverMavenProjectImportHandler.kt

@@ -16,8 +16,8 @@
 
 package org.jetbrains.kotlin.samWithReceiver.ide
 
-import org.jetbrains.kotlin.annotation.plugin.ide.AbstractMavenImportHandler
+import org.jetbrains.kotlin.plugin.ide.CompilerPluginSetup.PluginOption
-import org.jetbrains.kotlin.annotation.plugin.ide.AnnotationBasedCompilerPluginSetup.PluginOption
+import org.jetbrains.kotlin.plugin.ide.AbstractMavenImportHandler
 import org.jetbrains.kotlin.samWithReceiver.SamWithReceiverCommandLineProcessor
 import org.jetbrains.kotlin.utils.PathUtil
 
@@ -28,7 +28,6 @@ class SamWithReceiverMavenProjectImportHandler : AbstractMavenImportHandler() {
 
     override val compilerPluginId = SamWithReceiverCommandLineProcessor.PLUGIN_ID
     override val pluginName = "samWithReceiver"
-    override val mavenPluginArtifactName = "kotlin-maven-sam-with-receiver"
     override val pluginJarFileFromIdea = PathUtil.kotlinPathsForIdeaPlugin.samWithReceiverJarPath
 
     override fun getOptions(enabledCompilerPlugins: List<String>, compilerPluginOptions: List<String>): List<PluginOption>? {