[lsp] filter code actions by kind

To avoid computing redundant actions

GitOrigin-RevId: f6129e204e3ff4a675c433086cfc453bc074b41d

Author: darthorimar

api.features/src/com/jetbrains/ls/api/features/codeActions/LSCodeActionProvider.kt

@@ -4,10 +4,18 @@ package com.jetbrains.ls.api.features.codeActions
 import com.jetbrains.ls.api.core.LSServer
 import com.jetbrains.ls.api.features.LSLanguageSpecificConfigurationEntry
 import com.jetbrains.lsp.protocol.CodeAction
+import com.jetbrains.lsp.protocol.CodeActionKind
 import com.jetbrains.lsp.protocol.CodeActionParams
 import kotlinx.coroutines.flow.Flow
 
 interface LSCodeActionProvider : LSLanguageSpecificConfigurationEntry {
+    /**
+     * Only code actions of these kinds will be provided. Cannot be empty.
+     *
+     * [getCodeActions] cannot provide kinds not listed in [providesOnlyKinds]. Otherwise, it an exception will be thrown.
+     */
+    val providesOnlyKinds: Set<CodeActionKind>
+
     context(LSServer)
     fun getCodeActions(params: CodeActionParams): Flow<CodeAction>
 }

api.features/src/com/jetbrains/ls/api/features/codeActions/LSCodeActions.kt

@@ -6,17 +6,41 @@ import com.jetbrains.ls.api.features.LSConfiguration
 import com.jetbrains.ls.api.features.partialResults.LSConcurrentResponseHandler
 import com.jetbrains.lsp.implementation.LspHandlerContext
 import com.jetbrains.lsp.protocol.CodeAction
+import com.jetbrains.lsp.protocol.CodeActionKind
 import com.jetbrains.lsp.protocol.CodeActionParams
+import kotlinx.coroutines.flow.onEach
 
 object LSCodeActions {
     context(LSServer, LSConfiguration, LspHandlerContext)
     suspend fun getCodeActions(params: CodeActionParams): List<CodeAction> {
         return LSConcurrentResponseHandler.streamResultsIfPossibleOrRespondDirectly(
             params.partialResultToken,
             CodeAction.serializer(),
-            entriesFor<LSCodeActionProvider>(params.textDocument),
-        ) {
-            it.getCodeActions(params)
+            getProviders(params),
+        ) { provider ->
+            provider.getCodeActions(params)
+                .onEach { it.ensureCanBeProvidedBy(provider) }
+        }
+    }
+
+    context(LSConfiguration)
+    fun supportedCodeActionKinds(): List<CodeActionKind> {
+        return entries<LSCodeActionProvider>().flatMapTo(mutableSetOf()) { it.providesOnlyKinds }.toList()
+    }
+
+
+    private fun CodeAction.ensureCanBeProvidedBy(provider: LSCodeActionProvider) {
+        check(kind in provider.providesOnlyKinds) {
+            "Code action $title is not supported by ${provider.javaClass.name}. The only supported kinds are: ${provider.providesOnlyKinds.joinToString()}"
+        }
+    }
+
+    context(LSConfiguration)
+    private fun getProviders(params: CodeActionParams): List<LSCodeActionProvider> {
+        val all = entriesFor<LSCodeActionProvider>(params.textDocument)
+        val only = params.context.only?.toSet() ?: return all
+        return all.filter { provider ->
+            provider.providesOnlyKinds.any { it in only }
         }
     }
 }

api.features/src/com/jetbrains/ls/api/features/codeActions/LSSimpleCodeActionProvider.kt

@@ -20,10 +20,12 @@ import kotlinx.serialization.json.encodeToJsonElement
 
 abstract class LSSimpleCodeActionProvider<P : Any> : LSCodeActionProvider, LSCommandDescriptorProvider {
     protected abstract val title: String
-    protected open val kind: CodeActionKind? = null
+    protected abstract val kind: CodeActionKind
     protected open val isPreferred: Boolean? = null
     protected open val commandName: String get() = title
 
+    final override val providesOnlyKinds: Set<CodeActionKind> get ()= setOf(kind)
+
     abstract val dataSerializer: KSerializer<P>
 
     context(LSServer, LSAnalysisContext)

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/diagnostics/inspections/LSInspectionDiagnosticProviderImpl.kt

@@ -59,7 +59,7 @@ class LSInspectionDiagnosticProviderImpl(
         BlackListEntry.InspectionClass("org.jetbrains.kotlin.idea.k2.codeinsight.inspections.K2MemberVisibilityCanBePrivateInspection", "slow, performs find usages"),
         BlackListEntry.InspectionClass("org.jetbrains.kotlin.idea.k2.codeinsight.inspections.diagnosticBased.VariableNeverReadInspection", "very slow, uses extended checkers"),
         BlackListEntry.InspectionClass("org.jetbrains.kotlin.idea.k2.codeinsight.inspections.diagnosticBased.AssignedValueIsNeverReadInspection", "very slow, uses extended checkers"),
-    
+
         BlackListEntry.InspectionClass("org.jetbrains.kotlin.idea.k2.codeinsight.inspections.expressions.ExplicitThisInspection", "too noisy https://github.com/Kotlin/kotlin-lsp/issues/20"),
         BlackListEntry.InspectionClass("org.jetbrains.kotlin.idea.k2.codeinsight.inspections.ImplicitThisInspection", "too noisy https://github.com/Kotlin/kotlin-lsp/issues/20"),
         BlackListEntry.InspectionClass("org.jetbrains.kotlin.idea.k2.codeinsight.inspections.PublicApiImplicitTypeInspection", "too noisy https://github.com/Kotlin/kotlin-lsp/issues/4"),

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/diagnostics/inspections/LSInspectionFixesCodeActionProvider.kt

@@ -26,9 +26,10 @@ class LSInspectionFixesCodeActionProvider(
     override val supportedLanguages: Set<LSLanguage>,
 ) : LSCodeActionProvider, LSCommandDescriptorProvider {
 
+    override val providesOnlyKinds: Set<CodeActionKind> = setOf(CodeActionKind.QuickFix)
+
     context(LSServer)
     override fun getCodeActions(params: CodeActionParams): Flow<CodeAction> = flow {
-        if (!params.shouldProvideKind(CodeActionKind.QuickFix)) return@flow
         val diagnosticData = params.diagnosticData<InspectionDiagnosticData>().ifEmpty { return@flow }
 
         withAnalysisContext {

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/common/kotlin/codeActions/LSOrganizeImportsCodeActionProviderKotlinImpl.kt

@@ -24,7 +24,7 @@ internal object LSOrganizeImportsCodeActionProviderKotlinImpl : LSSimpleCodeActi
     override val supportedLanguages: Set<LSLanguage> get() = setOf(LSKotlinLanguage)
 
     override val title: String get() = "Organize Imports"
-    override val kind: CodeActionKind? get() = CodeActionKind.SourceOrganizeImports
+    override val kind: CodeActionKind get() = CodeActionKind.SourceOrganizeImports
     override val dataSerializer: KSerializer<NoData> get() = NoData.serializer()
 
     context(LSServer, LSAnalysisContext)

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/common/kotlin/diagnostics/compiler/LSKotlinCompilerDiagnosticsFixesCodeActionProvider.kt

@@ -36,10 +36,10 @@ import org.jetbrains.kotlin.psi.KtFile
 
 internal object LSKotlinCompilerDiagnosticsFixesCodeActionProvider : LSCodeActionProvider, LSCommandDescriptorProvider {
     override val supportedLanguages: Set<LSLanguage> = setOf(LSKotlinLanguage)
+    override val providesOnlyKinds: Set<CodeActionKind> = setOf(CodeActionKind.QuickFix)
 
     context(LSServer)
     override fun getCodeActions(params: CodeActionParams): Flow<CodeAction> = flow {
-        if (!params.shouldProvideKind(CodeActionKind.QuickFix)) return@flow
         val diagnosticData = params.diagnosticData<KotlinCompilerDiagnosticData>().ifEmpty { return@flow }
 
         val uri = params.textDocument.uri.uri

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/common/kotlin/diagnostics/intentions/LSKotlinIntentionCodeActionProviderImpl.kt

@@ -51,6 +51,7 @@ import java.util.function.Function
 
 internal object LSKotlinIntentionCodeActionProviderImpl : LSCodeActionProvider, LSCommandDescriptorProvider {
     override val supportedLanguages: Set<LSLanguage> get() = setOf(LSKotlinLanguage)
+    override val providesOnlyKinds: Set<CodeActionKind> = setOf(CodeActionKind.QuickFix)
 
     private fun createActions(): List<KotlinApplicableModCommandAction<*, *>> {
         return listOf(
@@ -61,7 +62,6 @@ internal object LSKotlinIntentionCodeActionProviderImpl : LSCodeActionProvider,
 
     context(LSServer)
     override fun getCodeActions(params: CodeActionParams): Flow<CodeAction> = flow {
-        if (!params.shouldProvideKind(CodeActionKind.QuickFix)) return@flow
         val uri = params.textDocument.uri.uri
         withAnalysisContext {
             runReadAction {

kotlin-lsp/src/com/jetbrains/ls/kotlinLsp/requests/core/initialize.kt

@@ -7,6 +7,7 @@ import com.jetbrains.ls.api.core.util.jarLibraries
 import com.jetbrains.ls.api.core.util.toLspUri
 import com.jetbrains.ls.api.core.util.updateWorkspaceModel
 import com.jetbrains.ls.api.features.LSConfiguration
+import com.jetbrains.ls.api.features.codeActions.LSCodeActions
 import com.jetbrains.ls.api.features.completion.LSCompletionProvider
 import com.jetbrains.ls.api.features.semanticTokens.LSSemanticTokens
 import com.jetbrains.ls.imports.api.WorkspaceImportException
@@ -84,7 +85,7 @@ internal fun LspHandlersBuilder.initializeRequest() {
                 ),
                 codeActionProvider = OrBoolean.of(
                     CodeActionOptions(
-                        codeActionKinds = CodeActionKind.entries,
+                        codeActionKinds = LSCodeActions.supportedCodeActionKinds(),
                         resolveProvider = false,
                         workDoneProgress = false,
                     )