revert: implement Provider's concurrent execution

This reverts commit 6be7d4e

src/main/kotlin/com/github/lppedd/cc/CCExtensions.kt

@@ -19,8 +19,6 @@ import com.intellij.psi.PsiFile
 import com.intellij.ui.TextFieldWithAutoCompletionListProvider
 import java.awt.Robot
 import java.io.InputStream
-import java.util.concurrent.Callable
-import java.util.concurrent.Future
 import kotlin.internal.InlineOnly
 
 // region PsiFile
@@ -224,10 +222,6 @@ internal inline fun <T> safeRunWithCheckCanceled(noinline callable: () -> T): T
   }
 }
 
-@InlineOnly
-internal inline fun <T> executeOnPooledThread(task: Callable<T>): Future<T> =
-  ApplicationManager.getApplication().executeOnPooledThread(task)
-
 @InlineOnly
 internal inline fun invokeLaterOnEdt(noinline block: () -> Unit) {
   ApplicationManager.getApplication().invokeLater(block)

src/main/kotlin/com/github/lppedd/cc/api/CommitTokenProvider.kt

@@ -1,14 +1,9 @@
 package com.github.lppedd.cc.api
 
-import java.time.Duration
-
 /**
  * @author Edoardo Luppi
  */
 interface CommitTokenProvider {
   fun getId(): String
   fun getPresentation(): ProviderPresentation
-
-  @JvmDefault
-  fun timeout(): Duration = Duration.ofSeconds(1)
 }

src/main/kotlin/com/github/lppedd/cc/completion/providers/BodyCompletionProvider.kt

@@ -1,17 +1,17 @@
+@file:Suppress("DEPRECATION")
+
 package com.github.lppedd.cc.completion.providers
 
+import com.github.lppedd.cc.MAX_ITEMS_PER_PROVIDER
 import com.github.lppedd.cc.api.BODY_EP
-import com.github.lppedd.cc.api.CommitBody
 import com.github.lppedd.cc.api.CommitBodyProvider
 import com.github.lppedd.cc.completion.resultset.ResultSet
-import com.github.lppedd.cc.executeOnPooledThread
 import com.github.lppedd.cc.lookupElement.CommitBodyLookupElement
 import com.github.lppedd.cc.parser.CommitTokens
 import com.github.lppedd.cc.parser.FooterContext.FooterTypeContext
 import com.github.lppedd.cc.parser.ValidToken
 import com.github.lppedd.cc.psiElement.CommitBodyPsiElement
 import com.github.lppedd.cc.safeRunWithCheckCanceled
-import com.intellij.codeInsight.lookup.LookupElement
 import com.intellij.openapi.project.Project
 
 /**
@@ -27,35 +27,23 @@ internal class BodyCompletionProvider(
 
   override fun complete(resultSet: ResultSet) {
     val rs = resultSet.withPrefixMatcher(context.type)
-    providers.map {
+    providers.asSequence()
+      .flatMap { provider ->
         safeRunWithCheckCanceled {
-          val provider = BodyProviderWrapper(project, it)
-          val futureData = executeOnPooledThread {
-            it.getCommitBodies(
+          val wrapper = BodyProviderWrapper(project, provider)
+          provider.getCommitBodies(
               (commitTokens.type as? ValidToken)?.value,
               (commitTokens.scope as? ValidToken)?.value,
               (commitTokens.subject as? ValidToken)?.value
             )
-          }
-
-          provider with futureData
+            .asSequence()
+            .take(MAX_ITEMS_PER_PROVIDER)
+            .map { wrapper to it }
         }
       }
-      .asSequence()
-      .map { (provider, futureData) -> retrieveItems(provider, futureData) }
-      .sortedBy { (provider) -> provider.getPriority() }
-      .flatMap { (provider, types) -> buildLookupElements(provider, types, context.type) }
-      .distinctBy(LookupElement::getLookupString)
+      .map { it.first to CommitBodyPsiElement(project, it.second) }
+      .mapIndexed { i, (provider, psi) -> CommitBodyLookupElement(i, provider, psi, context.type) }
+      .distinctBy(CommitBodyLookupElement::getLookupString)
       .forEach(rs::addElement)
   }
-
-  private fun buildLookupElements(
-      provider: BodyProviderWrapper,
-      bodies: Collection<CommitBody>,
-      prefix: String,
-  ): Sequence<CommitBodyLookupElement> =
-    bodies.asSequence().mapIndexed { index, type ->
-      val psi = CommitBodyPsiElement(project, type)
-      CommitBodyLookupElement(index, provider, psi, prefix)
-    }
 }

src/main/kotlin/com/github/lppedd/cc/completion/providers/CompletionProvider.kt

@@ -1,12 +1,9 @@
+@file:Suppress("DEPRECATION")
+
 package com.github.lppedd.cc.completion.providers
 
-import com.github.lppedd.cc.MAX_ITEMS_PER_PROVIDER
-import com.github.lppedd.cc.api.CommitTokenElement
 import com.github.lppedd.cc.api.CommitTokenProvider
 import com.github.lppedd.cc.completion.resultset.ResultSet
-import java.util.concurrent.Future
-import java.util.concurrent.TimeUnit.MILLISECONDS
-import java.util.concurrent.TimeoutException
 
 /**
  * @author Edoardo Luppi
@@ -17,20 +14,3 @@ internal interface CompletionProvider<out T : CommitTokenProvider> {
 
   fun complete(resultSet: ResultSet)
 }
-
-internal fun <P : ProviderWrapper, T : CommitTokenElement> retrieveItems(
-    provider: P,
-    futureData: Future<Collection<T>>,
-): ResultCarrier<P, Collection<T>> {
-  try {
-    val timeout = provider.timeout().toMillis().coerceAtMost(2500)
-    val items = futureData.get(timeout, MILLISECONDS).take(MAX_ITEMS_PER_PROVIDER)
-    return provider with items
-  } catch (ignored: TimeoutException) {
-    futureData.cancel(true)
-  } catch (ignored: Exception) {
-    // We're not interested in any recovery logic for now
-  }
-
-  return provider with emptyList()
-}

src/main/kotlin/com/github/lppedd/cc/completion/providers/FooterTypeCompletionProvider.kt

@@ -1,15 +1,15 @@
+@file:Suppress("DEPRECATION")
+
 package com.github.lppedd.cc.completion.providers
 
-import com.github.lppedd.cc.api.CommitFooterType
+import com.github.lppedd.cc.MAX_ITEMS_PER_PROVIDER
 import com.github.lppedd.cc.api.CommitFooterTypeProvider
 import com.github.lppedd.cc.api.FOOTER_TYPE_EP
 import com.github.lppedd.cc.completion.resultset.ResultSet
-import com.github.lppedd.cc.executeOnPooledThread
 import com.github.lppedd.cc.lookupElement.CommitFooterTypeLookupElement
 import com.github.lppedd.cc.parser.FooterContext.FooterTypeContext
 import com.github.lppedd.cc.psiElement.CommitFooterTypePsiElement
 import com.github.lppedd.cc.safeRunWithCheckCanceled
-import com.intellij.codeInsight.lookup.LookupElement
 import com.intellij.openapi.project.Project
 
 /**
@@ -24,27 +24,19 @@ internal class FooterTypeCompletionProvider(
 
   override fun complete(resultSet: ResultSet) {
     val rs = resultSet.withPrefixMatcher(context.type)
-    providers.map {
+    providers.asSequence()
+      .flatMap { provider ->
         safeRunWithCheckCanceled {
-          val provider = FooterTypeProviderWrapper(project, it)
-          val futureData = executeOnPooledThread(it::getCommitFooterTypes)
-          provider with futureData
+          val wrapper = FooterTypeProviderWrapper(project, provider)
+          provider.getCommitFooterTypes()
+            .asSequence()
+            .take(MAX_ITEMS_PER_PROVIDER)
+            .map { wrapper to it }
         }
       }
-      .asSequence()
-      .map { (provider, futureData) -> retrieveItems(provider, futureData) }
-      .sortedBy { (provider) -> provider.getPriority() }
-      .flatMap { (provider, types) -> buildLookupElements(provider, types) }
-      .distinctBy(LookupElement::getLookupString)
+      .map { it.first to CommitFooterTypePsiElement(project, it.second) }
+      .mapIndexed { i, (provider, psi) -> CommitFooterTypeLookupElement(i, provider, psi) }
+      .distinctBy(CommitFooterTypeLookupElement::getLookupString)
       .forEach(rs::addElement)
   }
-
-  private fun buildLookupElements(
-      provider: FooterTypeProviderWrapper,
-      footerTypes: Collection<CommitFooterType>,
-  ): Sequence<CommitFooterTypeLookupElement> =
-    footerTypes.asSequence().mapIndexed { index, type ->
-      val psi = CommitFooterTypePsiElement(project, type)
-      CommitFooterTypeLookupElement(index, provider, psi)
-    }
 }

src/main/kotlin/com/github/lppedd/cc/completion/providers/FooterValueCompletionProvider.kt

@@ -1,14 +1,14 @@
-@file:Suppress("DEPRECATION")
+@file:Suppress("DEPRECATION", "UnstableApiUsage")
 
 package com.github.lppedd.cc.completion.providers
 
 import com.github.lppedd.cc.CCBundle
+import com.github.lppedd.cc.MAX_ITEMS_PER_PROVIDER
 import com.github.lppedd.cc.api.CommitFooterValue
 import com.github.lppedd.cc.api.CommitFooterValueProvider
 import com.github.lppedd.cc.api.DefaultCommitTokenProvider
 import com.github.lppedd.cc.api.FOOTER_VALUE_EP
 import com.github.lppedd.cc.completion.resultset.ResultSet
-import com.github.lppedd.cc.executeOnPooledThread
 import com.github.lppedd.cc.lookupElement.CommitFooterLookupElement
 import com.github.lppedd.cc.lookupElement.CommitLookupElement
 import com.github.lppedd.cc.lookupElement.ShowMoreCoAuthorsLookupElement
@@ -19,7 +19,6 @@ import com.github.lppedd.cc.psiElement.CommitFooterValuePsiElement
 import com.github.lppedd.cc.safeRunWithCheckCanceled
 import com.intellij.codeInsight.completion.CompletionProcess
 import com.intellij.codeInsight.completion.CompletionProgressIndicator
-import com.intellij.codeInsight.lookup.LookupElement
 import com.intellij.openapi.project.Project
 
 /**
@@ -38,26 +37,24 @@ internal class FooterValueCompletionProvider(
     val prefix = context.value.trimStart()
     val rs = resultSet.withPrefixMatcher(prefix)
 
-    providers.map {
+    providers.asSequence()
+      .flatMap { provider ->
         safeRunWithCheckCanceled {
-          val provider = FooterValueProviderWrapper(project, it)
-          val futureData = executeOnPooledThread {
-            it.getCommitFooterValues(
+          val wrapper = FooterValueProviderWrapper(project, provider)
+          provider.getCommitFooterValues(
               context.type,
               (commitTokens.type as? ValidToken)?.value,
               (commitTokens.scope as? ValidToken)?.value,
               (commitTokens.subject as? ValidToken)?.value
             )
-          }
-
-          provider with futureData
+            .asSequence()
+            .take(MAX_ITEMS_PER_PROVIDER)
+            .map { wrapper to it }
         }
       }
-      .asSequence()
-      .map { (provider, futureData) -> retrieveItems(provider, futureData) }
-      .sortedBy { (provider) -> provider.getPriority() }
-      .flatMap { (provider, types) -> buildLookupElements(provider, types, prefix) }
-      .distinctBy(LookupElement::getLookupString)
+      .map { it.first to CommitFooterValuePsiElement(project, it.second) }
+      .mapIndexed { i, (provider, psi) -> CommitFooterLookupElement(i, provider, psi, prefix) }
+      .distinctBy(CommitFooterLookupElement::getLookupString)
       .forEach(rs::addElement)
 
     if ("co-authored-by".equals(context.type, true)) {
@@ -67,16 +64,6 @@ internal class FooterValueCompletionProvider(
     rs.stopHere()
   }
 
-  private fun buildLookupElements(
-      provider: FooterValueProviderWrapper,
-      footerValues: Collection<CommitFooterValue>,
-      prefix: String,
-  ): Sequence<CommitFooterLookupElement> =
-    footerValues.asSequence().mapIndexed { index, type ->
-      val psi = CommitFooterValuePsiElement(project, type)
-      CommitFooterLookupElement(index, provider, psi, prefix)
-    }
-
   private fun buildShowMoreLookupElement(prefix: String): CommitLookupElement {
     val commitFooter = CommitFooterValue("", CCBundle["cc.config.coAuthors.description"])
     val psiElement = CommitFooterValuePsiElement(project, commitFooter)

src/main/kotlin/com/github/lppedd/cc/completion/providers/ScopeCompletionProvider.kt

@@ -1,15 +1,15 @@
+@file:Suppress("DEPRECATION")
+
 package com.github.lppedd.cc.completion.providers
 
-import com.github.lppedd.cc.api.CommitScope
+import com.github.lppedd.cc.MAX_ITEMS_PER_PROVIDER
 import com.github.lppedd.cc.api.CommitScopeProvider
 import com.github.lppedd.cc.api.SCOPE_EP
 import com.github.lppedd.cc.completion.resultset.ResultSet
-import com.github.lppedd.cc.executeOnPooledThread
 import com.github.lppedd.cc.lookupElement.CommitScopeLookupElement
 import com.github.lppedd.cc.parser.CommitContext.ScopeCommitContext
 import com.github.lppedd.cc.psiElement.CommitScopePsiElement
 import com.github.lppedd.cc.safeRunWithCheckCanceled
-import com.intellij.codeInsight.lookup.LookupElement
 import com.intellij.openapi.project.Project
 
 /**
@@ -24,27 +24,19 @@ internal class ScopeCompletionProvider(
 
   override fun complete(resultSet: ResultSet) {
     val rs = resultSet.withPrefixMatcher(context.scope.trim())
-    providers.map {
+    providers.asSequence()
+      .flatMap { provider ->
         safeRunWithCheckCanceled {
-          val provider = ScopeProviderWrapper(project, it)
-          val futureData = executeOnPooledThread { it.getCommitScopes(context.type) }
-          provider with futureData
+          val wrapper = ScopeProviderWrapper(project, provider)
+          provider.getCommitScopes(context.type)
+            .asSequence()
+            .take(MAX_ITEMS_PER_PROVIDER)
+            .map { wrapper to it }
         }
       }
-      .asSequence()
-      .map { (provider, futureData) -> retrieveItems(provider, futureData) }
-      .sortedBy { (provider) -> provider.getPriority() }
-      .flatMap { (provider, types) -> buildLookupElements(provider, types) }
-      .distinctBy(LookupElement::getLookupString)
+      .map { it.first to CommitScopePsiElement(project, it.second) }
+      .mapIndexed { i, (provider, psi) -> CommitScopeLookupElement(i, provider, psi) }
+      .distinctBy(CommitScopeLookupElement::getLookupString)
       .forEach(rs::addElement)
   }
-
-  private fun buildLookupElements(
-      provider: ScopeProviderWrapper,
-      types: Collection<CommitScope>,
-  ): Sequence<CommitScopeLookupElement> =
-    types.asSequence().mapIndexed { index, type ->
-      val psi = CommitScopePsiElement(project, type)
-      CommitScopeLookupElement(index, provider, psi)
-    }
 }