CIDR: Disable start-up activities provided by Java plugin

2026-03-30 00:21:27 +00:00 · 2020-03-01 21:17:52 +07:00
parent 845557d83b
commit 8a85eac4d8
1 changed files with 124 additions and 0 deletions
--- a/ide/common-cidr-native/src/org/jetbrains/konan/internal/KotlinNativeIdeInitializer.kt.201
+++ b/ide/common-cidr-native/src/org/jetbrains/konan/internal/KotlinNativeIdeInitializer.kt.201
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. 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.konan.internal
+
+import com.intellij.codeInspection.InspectionEP
+import com.intellij.codeInspection.LocalInspectionEP
+import com.intellij.execution.actions.RunConfigurationProducer
+import com.intellij.execution.configurations.ConfigurationType
+import com.intellij.execution.runners.ProgramRunner
+import com.intellij.ide.util.TipAndTrickBean
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.extensions.ExtensionPoint
+import com.intellij.openapi.extensions.ExtensionPointName
+import com.intellij.openapi.extensions.Extensions
+import com.intellij.openapi.extensions.impl.ExtensionComponentAdapter
+import com.intellij.openapi.startup.StartupActivity
+import com.intellij.task.ProjectTaskRunner
+import com.intellij.task.impl.JpsProjectTaskRunner
+import org.jetbrains.kotlin.idea.KotlinPluginUtil
+import java.util.function.BiPredicate
+import java.util.function.Predicate
+
+/**
+ * @author Vladislav.Soroka
+ */
+@Suppress("SameParameterValue")
+class KotlinNativeIdeInitializer {
+
+    private companion object {
+        val LOG = Logger.getInstance(KotlinNativeIdeInitializer::class.java)
+
+        val PLUGINS_TO_UNREGISTER_TIP_AND_TRICKS = setOf(
+            KotlinPluginUtil.KOTLIN_PLUGIN_ID.idString, // all tips & tricks that come from the main Kotlin plugin
+            "org.intellij.intelliLang", // Java plugin specific
+            "com.intellij.diagram" // Java plugin specific
+        )
+
+        val JAVA_PLUGIN_IDS = setOf(
+            "com.intellij.kotlinNative.platformDeps", // Platform Deps (Java)
+            "com.intellij.java" // Java
+        )
+
+        // declared as private field in com.intellij.ide.startup.impl.StartupManagerImpl
+        val START_UP_ACTIVITY_EP = ExtensionPointName<StartupActivity>("com.intellij.startupActivity")
+    }
+
+    init {
+        // There are groovy local inspections which should not be loaded w/o groovy plugin enabled.
+        // Those plugin definitions should become optional and dependant on groovy plugin.
+        // This is a temp workaround before it happens.
+        unregisterExtensionInstances(LocalInspectionEP.LOCAL_INSPECTION) {
+            it.groupDisplayName == "Kotlin" && it.language == "Groovy"
+        }
+
+        // Suppress irrelevant tips & tricks
+        unregisterExtensionsFromPlugins(TipAndTrickBean.EP_NAME, PLUGINS_TO_UNREGISTER_TIP_AND_TRICKS)
+
+        // Disable JPS
+        unregisterExtensionsByClass(ProjectTaskRunner.EP_NAME, JpsProjectTaskRunner::class.java)
+
+        // Disable run configurations provided by Java plugin
+        unregisterExtensionsFromPlugins(ConfigurationType.CONFIGURATION_TYPE_EP, JAVA_PLUGIN_IDS)
+        unregisterExtensionsFromPlugins(RunConfigurationProducer.EP_NAME, JAVA_PLUGIN_IDS)
+        unregisterExtensionsFromPlugins(ProgramRunner.PROGRAM_RUNNER_EP, JAVA_PLUGIN_IDS)
+
+        // Disable start-up activities provided by Java plugin
+        unregisterExtensionsFromPlugins(START_UP_ACTIVITY_EP, JAVA_PLUGIN_IDS)
+    }
+
+    private fun <T : Any> unregisterExtensionsByClass(
+        extensionPointName: ExtensionPointName<T>,
+        extensionClass: Class<out T>
+    ) {
+        val extensionPoint = Extensions.getRootArea().getExtensionPoint(extensionPointName)
+        val extensionClassesToUnregister = extensionPoint.extensionList
+            .filter(extensionClass::isInstance)
+            .map { it::class.java.name }
+            .toSet()
+
+        unregisterExtensions(extensionPoint) { className, _ -> className in extensionClassesToUnregister }
+    }
+
+    private fun <T : Any> unregisterExtensionsFromPlugins(
+        extensionPointName: ExtensionPointName<T>,
+        pluginIds: Set<String>
+    ) {
+        val extensionPoint = Extensions.getRootArea().getExtensionPoint(extensionPointName)
+        unregisterExtensions(extensionPoint) { _, adapter -> adapter.pluginDescriptor.pluginId?.idString in pluginIds }
+    }
+
+    private fun <T : Any> unregisterExtensions(
+        extensionPoint: ExtensionPoint<T>,
+        predicate: (String, ExtensionComponentAdapter) -> Boolean
+    ) {
+        extensionPoint.unregisterExtensions(predicate.wrap(extensionPoint.name), false)
+    }
+
+    // TODO: drop this method as it forces all extensions to instantiate and then unregisters some of them.
+    @Suppress("DEPRECATION")
+    private fun <T : InspectionEP> unregisterExtensionInstances(
+            extensionPointName: ExtensionPointName<T>,
+            predicate: (T) -> Boolean
+    ) {
+        val extensionPoint = Extensions.getRootArea().getExtensionPoint(extensionPointName)
+        extensionPoint.unregisterExtensions(predicate.wrap(extensionPointName.name))
+    }
+
+    private fun <T : InspectionEP> ((T) -> Boolean).wrap(extensionPointName: String) =
+        Predicate<T> { extension ->
+            this(extension).also { result ->
+                if (result) LOG.warn("unregistering extension $extensionPointName, ${extension::class.java}, ${extension.pluginDescriptor}")
+            }
+        }.negate()
+
+    private fun ((String, ExtensionComponentAdapter) -> Boolean).wrap(extensionPointName: String) =
+        BiPredicate<String, ExtensionComponentAdapter> { className, adapter ->
+            this(className, adapter).also { result ->
+                if (result) LOG.warn("unregistering extension $extensionPointName, $className, ${adapter.pluginDescriptor}")
+            }
+        }.negate()
+}