Fix project build with platformVersion >= 2024 (#2492)

## Changes

1. Fixed package for `InlineCompletionSuggestion`
2. Added separate versions of `CodyInlineCompletionProvider` for IJ 2023
and 2024 (although 2024 version will be used only if `platformVersion`
is changed explicitly, e.g. using `-PplatformVersion=2024.2`).
3. Fixed build definition issues for IJ 2024, mostly connected with
missing VCS packages.

## Test plan

Verify that completions and opening Revision Diff in Sourcegraph Web
works:

* In IntelliJ 2023.2
* In IntelliJ 2024.2
* In IntelliJ 2024.2 in split mode (or using remote directly)

Author: pkukielka

build.gradle.kts

@@ -63,6 +63,7 @@ plugins {
 val platformVersion: String by project
 val platformType: String by project
 val javaVersion: String by project
+val majorPlatformVersion = platformVersion.split(".").first()
 
 group = properties("pluginGroup")!!
 
@@ -126,6 +127,10 @@ dependencies {
     instrumentationTools()
     pluginVerifier()
     testFramework(TestFrameworkType.Platform)
+
+    if (majorPlatformVersion.toInt() >= 2024) {
+      bundledModule("intellij.platform.vcs.dvcs.impl")
+    }
   }
 
   implementation("org.commonmark:commonmark:0.22.0")
@@ -257,6 +262,8 @@ fun Test.sharedIntegrationTestConfig(buildCodyDir: File, mode: String) {
 
   include("**/AllSuites.class")
 
+  maxHeapSize = "8G"
+
   jvmArgs(
       "-Djava.system.class.loader=com.intellij.util.lang.PathClassLoader",
       "--add-opens=java.desktop/java.awt.event=ALL-UNNAMED",
@@ -586,6 +593,8 @@ tasks {
   test { dependsOn(project.tasks.getByPath("buildCody")) }
 
   sourceSets {
+    main { kotlin.srcDir("src/intellij${majorPlatformVersion}/kotlin") }
+
     create("integrationTest") {
       kotlin.srcDir("src/integrationTest/kotlin")
       compileClasspath += main.get().output + configurations.testCompileClasspath.get()

src/main/kotlin/com/intellij/codeInsight/inline/completion/InlineCompletionEvent.kt renamed to src/intellij2023/kotlin/com/intellij/codeInsight/inline/completion/InlineCompletionEvent.kt

@@ -0,0 +1,34 @@
+package com.intellij.codeInsight.inline.completion.suggestion
+
+import com.intellij.codeInsight.inline.completion.elements.InlineCompletionElement
+import com.intellij.openapi.util.UserDataHolderBase
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.FlowCollector
+
+interface InlineCompletionSuggestion {
+
+  object Empty : InlineCompletionSuggestion {}
+}
+
+interface InlineCompletionSingleSuggestion : InlineCompletionSuggestion {
+
+  companion object {
+
+    /** @see [InlineCompletionVariant.build] */
+    fun build(
+        data: UserDataHolderBase = UserDataHolderBase(),
+        buildElements:
+            suspend FlowCollector<InlineCompletionElement>.(data: UserDataHolderBase) -> Unit
+    ): InlineCompletionSingleSuggestion {
+      return object : InlineCompletionSingleSuggestion {}
+    }
+
+    /** @see InlineCompletionVariant.build */
+    fun build(
+        data: UserDataHolderBase = UserDataHolderBase(),
+        elements: Flow<InlineCompletionElement>
+    ): InlineCompletionSingleSuggestion {
+      return object : InlineCompletionSingleSuggestion {}
+    }
+  }
+}

src/main/kotlin/com/intellij/codeInsight/inline/completion/InlineCompletionProviderID.kt renamed to src/intellij2023/kotlin/com/intellij/codeInsight/inline/completion/InlineCompletionProviderID.kt

@@ -2,6 +2,8 @@ package com.sourcegraph.cody.autocomplete
 
 import com.intellij.codeInsight.inline.completion.*
 import com.intellij.codeInsight.inline.completion.elements.InlineCompletionGrayTextElement
+import com.intellij.codeInsight.inline.completion.suggestion.InlineCompletionSingleSuggestion
+import com.intellij.codeInsight.inline.completion.suggestion.InlineCompletionSuggestion
 import com.intellij.openapi.application.ApplicationInfo
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.application.ReadAction
@@ -36,9 +38,9 @@ class CodyInlineCompletionProvider : InlineCompletionProvider {
   suspend fun getSuggestion(request: InlineCompletionRequest): InlineCompletionSuggestion {
     ApplicationManager.getApplication().assertIsNonDispatchThread()
     val editor = request.editor
-    val project = editor.project ?: return InlineCompletionSuggestion.empty()
+    val project = editor.project ?: return InlineCompletionSuggestion.Empty
     if (!isImplicitAutocompleteEnabledForEditor(editor)) {
-      return InlineCompletionSuggestion.empty()
+      return InlineCompletionSuggestion.Empty
     }
     val lookupString: String? = null // todo: can we use this provider for lookups?
 
@@ -56,9 +58,9 @@ class CodyInlineCompletionProvider : InlineCompletionProvider {
     val completions =
         fetchCompletions(project, editor, triggerKind, cancellationToken, lookupString)
             .completeOnTimeout(null, 1, TimeUnit.SECONDS)
-            .get() ?: return InlineCompletionSuggestion.empty()
+            .get() ?: return InlineCompletionSuggestion.Empty
 
-    return InlineCompletionSuggestion.withFlow {
+    return InlineCompletionSingleSuggestion.build {
       completions.items
           .firstNotNullOfOrNull {
             WriteCommandAction.runWriteCommandAction<InlineCompletionGrayTextElement?>(

src/main/kotlin/com/intellij/codeInsight/inline/completion/elements/InlineCompletionElement.kt renamed to src/intellij2023/kotlin/com/intellij/codeInsight/inline/completion/elements/InlineCompletionElement.kt

@@ -0,0 +1,147 @@
+package com.sourcegraph.cody.autocomplete
+
+import com.intellij.codeInsight.inline.completion.*
+import com.intellij.codeInsight.inline.completion.elements.InlineCompletionGrayTextElement
+import com.intellij.codeInsight.inline.completion.suggestion.InlineCompletionSingleSuggestion
+import com.intellij.codeInsight.inline.completion.suggestion.InlineCompletionSuggestion
+import com.intellij.openapi.application.ApplicationInfo
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.application.ReadAction
+import com.intellij.openapi.client.ClientSessionsManager
+import com.intellij.openapi.command.WriteCommandAction
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.editor.event.DocumentEvent
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.TextRange
+import com.intellij.util.concurrency.annotations.RequiresReadLock
+import com.sourcegraph.cody.agent.CodyAgentService
+import com.sourcegraph.cody.agent.protocol.AutocompleteResult
+import com.sourcegraph.cody.agent.protocol.CompletionItemParams
+import com.sourcegraph.cody.statusbar.CodyStatusService.Companion.resetApplication
+import com.sourcegraph.cody.vscode.CancellationToken
+import com.sourcegraph.cody.vscode.InlineCompletionTriggerKind
+import com.sourcegraph.cody.vscode.IntelliJTextDocument
+import com.sourcegraph.config.ConfigUtil
+import com.sourcegraph.utils.CodyEditorUtil.getTextRange
+import com.sourcegraph.utils.CodyEditorUtil.isImplicitAutocompleteEnabledForEditor
+import com.sourcegraph.utils.CodyFormatter
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicReference
+
+class CodyInlineCompletionProvider : InlineCompletionProvider {
+  private val logger = Logger.getInstance(CodyInlineCompletionProvider::class.java)
+  private val currentJob = AtomicReference(CancellationToken())
+  override val id = InlineCompletionProviderID("Cody")
+
+  override suspend fun getSuggestion(request: InlineCompletionRequest): InlineCompletionSuggestion {
+    ApplicationManager.getApplication().assertIsNonDispatchThread()
+    val editor = request.editor
+    val project = editor.project ?: return InlineCompletionSuggestion.Empty
+    if (!isImplicitAutocompleteEnabledForEditor(editor)) {
+      return InlineCompletionSuggestion.Empty
+    }
+    val lookupString: String? = null // todo: can we use this provider for lookups?
+
+    cancelCurrentJob(project)
+    val cancellationToken = CancellationToken()
+    currentJob.set(cancellationToken)
+
+    val triggerKind =
+        if (request.event is InlineCompletionEvent.DirectCall) {
+          InlineCompletionTriggerKind.INVOKE
+        } else {
+          InlineCompletionTriggerKind.AUTOMATIC
+        }
+
+    val completions =
+        fetchCompletions(project, editor, triggerKind, cancellationToken, lookupString)
+            .completeOnTimeout(null, 1, TimeUnit.SECONDS)
+            .get() ?: return InlineCompletionSuggestion.Empty
+
+    return InlineCompletionSingleSuggestion.build {
+      completions.items
+          .firstNotNullOfOrNull {
+            WriteCommandAction.runWriteCommandAction<InlineCompletionGrayTextElement?>(
+                editor.project) {
+                  val range = getTextRange(editor.document, it.range)
+                  val originalText = editor.document.getText(range)
+
+                  val formattedCompletionText: String =
+                      if (System.getProperty("cody.autocomplete.enableFormatting") == "false") {
+                        it.insertText
+                      } else {
+                        CodyFormatter.formatStringBasedOnDocument(
+                            it.insertText, project, editor.document, range, request.endOffset)
+                      }
+
+                  val completionText = formattedCompletionText.removeSuffix(originalText)
+                  if (completionText.trim().isBlank()) {
+                    null
+                  } else {
+
+                    CodyAgentService.withAgent(project) { agent ->
+                      agent.server.completionSuggested(CompletionItemParams(it.id))
+                    }
+
+                    InlineCompletionGrayTextElement(completionText)
+                  }
+                }
+          }
+          ?.let { emit(it) }
+    }
+  }
+
+  @RequiresReadLock
+  private fun fetchCompletions(
+      project: Project,
+      editor: Editor,
+      triggerKind: InlineCompletionTriggerKind,
+      cancellationToken: CancellationToken,
+      lookupString: String?,
+  ): CompletableFuture<AutocompleteResult?> {
+    val textDocument = IntelliJTextDocument(editor, project)
+    val offset = ReadAction.compute<Int, Throwable> { editor.caretModel.offset }
+    val lineNumber = editor.document.getLineNumber(offset)
+    val caretPositionInLine = offset - editor.document.getLineStartOffset(lineNumber)
+    val originalText = editor.document.getText(TextRange(offset - caretPositionInLine, offset))
+
+    val result = CompletableFuture<AutocompleteResult?>()
+    Utils.triggerAutocompleteAsync(
+        project,
+        editor,
+        offset,
+        textDocument,
+        triggerKind,
+        cancellationToken,
+        lookupString,
+        originalText,
+        logger) { autocompleteResult ->
+          result.complete(autocompleteResult)
+        }
+    return result
+  }
+
+  private fun cancelCurrentJob(project: Project?) {
+    currentJob.get().abort()
+    project?.let { resetApplication(it) }
+  }
+
+  override fun isEnabled(event: InlineCompletionEvent): Boolean {
+    return isEnabled()
+  }
+
+  fun isEnabled(event: DocumentEvent): Boolean {
+    return isEnabled()
+  }
+
+  private fun isEnabled(): Boolean {
+    val ideVersion = ApplicationInfo.getInstance().build.baselineVersion
+    val isRemoteDev = ClientSessionsManager.getAppSession()?.isRemote ?: false
+    return ideVersion >= 233 &&
+        isRemoteDev &&
+        ConfigUtil.isCodyEnabled() &&
+        ConfigUtil.isCodyAutocompleteEnabled()
+  }
+}