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)
- }
 }