Delete Kotlin IntelliJ IDEA plugin sources

Kotlin plugin sources were migrated to intellij-community:
https://github.com/JetBrains/intellij-community/tree/master/plugins/kotlin

Preserve `jps-plugin/testData/incremental`
because it's used in `compiler/incremental-compilation-impl/test`

Preserve `idea/testData/multiModuleHighlighting/multiplatform`
because it's used in `MppHighlightingTestDataWithGradleIT`

plugins/allopen/allopen-ide/allopen-ide.iml

@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" name="kotlin-runtime" level="project" />
-    <orderEntry type="module" module-name="frontend" />
-    <orderEntry type="module" module-name="plugin-api" />
-    <orderEntry type="module" module-name="allopen-cli" />
-    <orderEntry type="library" name="idea-full" level="project" />
-    <orderEntry type="library" scope="PROVIDED" name="gradle-and-groovy-plugin" level="project" />
-    <orderEntry type="module" module-name="idea" />
-    <orderEntry type="module" module-name="idea-maven" />
-    <orderEntry type="library" scope="PROVIDED" name="maven" level="project" />
-    <orderEntry type="module" module-name="cli-common" />
-    <orderEntry type="module" module-name="idea-jps-common" />
-    <orderEntry type="module" module-name="util" />
-    <orderEntry type="module" module-name="annotation-based-compiler-plugins-ide-support" />
-  </component>
-</module>

plugins/allopen/allopen-ide/build.gradle.kts

@@ -1,64 +0,0 @@
-
-description = "Kotlin AllOpen IDEA Plugin"
-
-plugins {
-    kotlin("jvm")
-    id("jps-compatible")
-}
-
-dependencies {
-    compile(project(":kotlin-allopen-compiler-plugin"))
-
-    compileOnly(project(":compiler:util"))
-    compileOnly(project(":compiler:frontend"))
-    compileOnly(project(":compiler:cli-common"))
-    compileOnly(project(":idea"))
-    compileOnly(project(":idea:idea-jvm"))
-    compileOnly(project(":idea:idea-jps-common"))
-    compileOnly(project(":plugins:annotation-based-compiler-plugins-ide-support"))
-    compileOnly(intellijDep())
-    excludeInAndroidStudio(rootProject) { compileOnly(intellijPluginDep("maven")) }
-    compileOnly(intellijPluginDep("gradle"))
-    compileOnly(project(":idea:kotlin-gradle-tooling"))
-
-    testRuntime(project(":kotlin-reflect"))
-
-    testCompileOnly(project(":kotlin-serialization"))
-    testCompileOnly(project(":plugins:lint"))
-    testCompileOnly(project(":plugins:kapt3-idea"))
-    testCompileOnly(project(":plugins:android-extensions-compiler"))
-    testCompileOnly(project(":kotlin-android-extensions"))
-    testCompileOnly(project(":kotlin-android-extensions-runtime"))
-    testCompileOnly(project(":plugins:android-extensions-ide"))
-    testCompileOnly(project(":kotlin-allopen-compiler-plugin"))
-    testCompileOnly(project(":allopen-ide-plugin"))
-    testCompileOnly(project(":kotlin-imports-dumper-compiler-plugin"))
-    testCompileOnly(project(":kotlinx-serialization-compiler-plugin"))
-    testCompileOnly(project(":kotlinx-serialization-ide-plugin"))
-    testCompileOnly(project(":kotlin-sam-with-receiver-compiler-plugin"))
-    testCompileOnly(project(":noarg-ide-plugin"))
-    testCompileOnly(project(":sam-with-receiver-ide-plugin"))
-    testCompileOnly(project(":plugins:lombok:lombok-ide-plugin"))
-    testCompileOnly(project(":idea:idea-native"))
-    testCompileOnly(project(":idea:idea-gradle-native"))
-    testCompileOnly(projectTests(":idea:idea-test-framework"))
-    testCompileOnly(intellijDep())
-    testRuntimeOnly(intellijDep())
-
-    compileOnly(intellijPluginDep("java"))
-    testCompileOnly(intellijPluginDep("java"))
-    testRuntimeOnly(intellijPluginDep("java"))
-}
-
-sourceSets {
-    "main" { projectDefault() }
-    "test" { projectDefault() }
-}
-
-runtimeJar()
-
-sourcesJar()
-
-javadocJar()
-
-projectTest(parallel = true)

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

@@ -1,39 +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.allopen.ide
-
-import org.jetbrains.kotlin.allopen.AllOpenCommandLineProcessor
-import org.jetbrains.kotlin.annotation.plugin.ide.AbstractAnnotationPluginGradleImportHandler
-import org.jetbrains.kotlin.utils.PathUtil
-
-class AllOpenGradleProjectImportHandler : AbstractAnnotationPluginGradleImportHandler<AllOpenModel>() {
-    override val compilerPluginId = AllOpenCommandLineProcessor.PLUGIN_ID
-    override val pluginName = "allopen"
-    override val annotationOptionName = AllOpenCommandLineProcessor.ANNOTATION_OPTION.optionName
-    override val pluginJarFileFromIdea = PathUtil.kotlinPathsForIdeaPlugin.allOpenPluginJarPath
-    override val modelKey = AllOpenProjectResolverExtension.KEY
-
-    override fun getAnnotationsForPreset(presetName: String): List<String> {
-        for ((name, annotations) in AllOpenCommandLineProcessor.SUPPORTED_PRESETS.entries) {
-            if (presetName == name) {
-                return annotations
-            }
-        }
-
-        return super.getAnnotationsForPreset(presetName)
-    }
-}

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

@@ -1,53 +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.allopen.ide
-
-import org.jetbrains.kotlin.allopen.AllOpenCommandLineProcessor
-import org.jetbrains.kotlin.plugin.ide.CompilerPluginSetup.PluginOption
-import org.jetbrains.kotlin.plugin.ide.AbstractMavenImportHandler
-import org.jetbrains.kotlin.utils.PathUtil
-
-class AllOpenMavenProjectImportHandler : AbstractMavenImportHandler() {
-    private companion object {
-        val ANNOTATION_PARAMETER_PREFIX = "all-open:${AllOpenCommandLineProcessor.ANNOTATION_OPTION.optionName}="
-    }
-
-    override val compilerPluginId = AllOpenCommandLineProcessor.PLUGIN_ID
-    override val pluginName = "allopen"
-    override val pluginJarFileFromIdea = PathUtil.kotlinPathsForIdeaPlugin.allOpenPluginJarPath
-
-    override fun getOptions(enabledCompilerPlugins: List<String>, compilerPluginOptions: List<String>): List<PluginOption>? {
-        if ("all-open" !in enabledCompilerPlugins && "spring" !in enabledCompilerPlugins) {
-            return null
-        }
-
-        val annotations = mutableListOf<String>()
-
-        for ((presetName, presetAnnotations) in AllOpenCommandLineProcessor.SUPPORTED_PRESETS) {
-            if (presetName in enabledCompilerPlugins) {
-                annotations.addAll(presetAnnotations)
-            }
-        }
-
-        annotations.addAll(compilerPluginOptions.mapNotNull { text ->
-            if (!text.startsWith(ANNOTATION_PARAMETER_PREFIX)) return@mapNotNull null
-            text.substring(ANNOTATION_PARAMETER_PREFIX.length)
-        })
-
-        return annotations.map { PluginOption(AllOpenCommandLineProcessor.ANNOTATION_OPTION.optionName, it) }
-    }
-}

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

@@ -1,29 +0,0 @@
-/*
- * Copyright 2010-2017 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.allopen.ide
-
-import com.intellij.openapi.util.Key
-import org.jetbrains.kotlin.annotation.plugin.ide.*
-
-class AllOpenProjectResolverExtension : AnnotationBasedPluginProjectResolverExtension<AllOpenModel>() {
-    companion object {
-        val KEY = Key<AllOpenModel>("AllOpenModel")
-    }
-
-    override val modelClass get() = AllOpenModel::class.java
-    override val userDataKey get() = KEY
-}

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

@@ -1,67 +0,0 @@
-/*
- * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * 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.allopen.ide
-
-import org.jetbrains.kotlin.descriptors.*
-
-/*
- * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiModifier
-import org.jetbrains.kotlin.annotation.plugin.ide.CachedAnnotationNames
-import org.jetbrains.kotlin.annotation.plugin.ide.getAnnotationNames
-import org.jetbrains.kotlin.asJava.UltraLightClassModifierExtension
-import org.jetbrains.kotlin.extensions.AnnotationBasedExtension
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.psi.psiUtil.containingClass
-import org.jetbrains.kotlin.psi.psiUtil.isPropertyParameter
-import org.jetbrains.kotlin.util.isAnnotated
-import org.jetbrains.kotlin.util.isOrdinaryClass
-
-class AllOpenUltraLightClassModifierExtension(project: Project) :
-    AnnotationBasedExtension,
-    UltraLightClassModifierExtension {
-
-    private val cachedAnnotationsNames = CachedAnnotationNames(project, ALL_OPEN_ANNOTATION_OPTION_PREFIX)
-
-    override fun getAnnotationFqNames(modifierListOwner: KtModifierListOwner?): List<String> =
-        cachedAnnotationsNames.getAnnotationNames(modifierListOwner)
-
-    private val KtDeclaration.isMethodOrProperty get() = this is KtProperty || this is KtPropertyAccessor || this is KtFunction || (this is KtParameter && this.isPropertyParameter())
-
-    private fun isSuitableDeclaration(declaration: KtDeclaration): Boolean {
-
-        if (getAnnotationFqNames(declaration).isEmpty()) return false
-
-        val declarationToCheck = if (declaration.isMethodOrProperty) declaration.containingClass() else declaration
-        declarationToCheck ?: return false
-
-        if (!declarationToCheck.isOrdinaryClass || declarationToCheck !is KtClassOrObject) return false
-
-        if (declarationToCheck.superTypeListEntries.isEmpty() && !declarationToCheck.isAnnotated) return false
-
-        return true
-    }
-
-    override fun interceptModalityBuilding(
-        declaration: KtDeclaration,
-        descriptor: Lazy<DeclarationDescriptor?>,
-        modifier: String
-    ): String {
-
-        //Final can be altered to Open only
-        if (modifier != PsiModifier.FINAL) return modifier
-
-        if (!isSuitableDeclaration(declaration)) return modifier
-
-        // Resolver will produce correct descriptor corresponding to modality from AllOpen.
-        // The easiest way to get new modality is to resolve the descriptor
-        return if ((descriptor.value as? MemberDescriptor)?.modality == Modality.OPEN) PsiModifier.OPEN else modifier
-    }
-}

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

@@ -1,39 +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.allopen.ide
-
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.allopen.AbstractAllOpenDeclarationAttributeAltererExtension
-import org.jetbrains.kotlin.allopen.AllOpenCommandLineProcessor.Companion.ANNOTATION_OPTION
-import org.jetbrains.kotlin.allopen.AllOpenCommandLineProcessor.Companion.PLUGIN_ID
-import org.jetbrains.kotlin.annotation.plugin.ide.CachedAnnotationNames
-import org.jetbrains.kotlin.annotation.plugin.ide.getAnnotationNames
-import org.jetbrains.kotlin.psi.KtModifierListOwner
-
-internal val ALL_OPEN_ANNOTATION_OPTION_PREFIX = "plugin:$PLUGIN_ID:${ANNOTATION_OPTION.optionName}="
-
-class IdeAllOpenDeclarationAttributeAltererExtension(val project: Project) :
-    AbstractAllOpenDeclarationAttributeAltererExtension() {
-
-    private val cachedAnnotationsNames = CachedAnnotationNames(project, ALL_OPEN_ANNOTATION_OPTION_PREFIX)
-
-    override fun getAnnotationFqNames(modifierListOwner: KtModifierListOwner?): List<String> {
-        return if (ApplicationManager.getApplication().isUnitTestMode) ANNOTATIONS_FOR_TESTS
-        else cachedAnnotationsNames.getAnnotationNames(modifierListOwner)
-    }
-}

plugins/allopen/allopen-ide/test/TestAllOpenForLightClass.kt

@@ -1,66 +0,0 @@
-/*
- * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * 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.allopen
-
-import com.intellij.lang.jvm.JvmModifier
-import com.intellij.testFramework.LightProjectDescriptor
-import org.jetbrains.kotlin.allopen.ide.ALL_OPEN_ANNOTATION_OPTION_PREFIX
-import org.jetbrains.kotlin.config.LanguageVersion
-import org.jetbrains.kotlin.idea.facet.KotlinFacet
-import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
-import org.jetbrains.kotlin.idea.test.KotlinProjectDescriptorWithFacet
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner
-import org.junit.runner.RunWith
-
-@RunWith(JUnit3WithIdeaConfigurationRunner::class)
-class TestAllOpenForLightClass : KotlinLightCodeInsightFixtureTestCase() {
-
-    companion object {
-        val allOpenAnnotationName = AbstractAllOpenDeclarationAttributeAltererExtension.ANNOTATIONS_FOR_TESTS.first()
-        const val targetClassName = "TargetClassName"
-    }
-
-    override fun getProjectDescriptor(): LightProjectDescriptor =
-        KotlinProjectDescriptorWithFacet(LanguageVersion.LATEST_STABLE, multiPlatform = false)
-
-    override fun setUp() {
-        super.setUp()
-
-        val facet = KotlinFacet.get(module) ?: error { "Facet not found" }
-        val configurationArguments = facet.configuration.settings.compilerArguments ?: error { "CompilerArguments not found" }
-
-        configurationArguments.pluginClasspaths = arrayOf("SomeClasspath")
-        configurationArguments.pluginOptions = arrayOf("$ALL_OPEN_ANNOTATION_OPTION_PREFIX$allOpenAnnotationName")
-    }
-
-    fun testAllOpenAnnotation() {
-        val file = myFixture.configureByText(
-            "A.kt",
-            "annotation class $allOpenAnnotationName\n"
-                    + "@$allOpenAnnotationName class $targetClassName(val e: Int)\n {"
-                    + "  fun a() {}\n"
-                    + "  val b = 32\n"
-                    + "}"
-
-
-        ) as KtFile
-
-        val classes = file.classes
-        assertEquals(2, classes.size)
-
-        val targetClass = classes.firstOrNull { it.name == targetClassName }
-            ?: error { "Expected class $targetClassName not found" }
-
-        assertFalse(targetClass.hasModifier(JvmModifier.FINAL))
-
-        targetClass.methods
-            .filter { !it.isConstructor }
-            .forEach {
-                assertFalse(it.hasModifier(JvmModifier.FINAL))
-            }
-    }
-}