feat(go): add GoVersionChatContextProvider and GoWriteTestService

- Add `com.intellij.openapi.application.ReadAction` and `com.intellij.openapi.application.runReadAction` imports to `GoVersionChatContextProvider.kt` for better performance.
- Wrap the code inside `ReadAction.compute` to execute it in a read action.
- Update the return statement to return the result of `ReadAction.compute`.
- Add `GoVersionChatContextProvider` class to provide chat context for Go versions.
- Add `GoWriteTestService` class to provide test file context for Go tests.
- Implement `runConfigurationClass` and `isApplicable` methods in `JavaWriteTestService.kt` using expression

build.gradle.kts

@@ -91,7 +91,7 @@ val webstormVersion = prop("webstormVersion")
 val baseVersion = when (baseIDE) {
     "idea" -> ideaVersion
     "pycharm" -> pycharmVersion
-    "go" -> golandVersion
+    "goland" -> golandVersion
     "clion" -> clionVersion
     "rider" -> riderVersion
     "javascript" -> webstormVersion

goland/src/main/kotlin/cc/unitmesh/go/provider/GoVersionChatContextProvider.kt

@@ -7,6 +7,8 @@ import com.goide.psi.GoFile
 import com.goide.sdk.GoSdkService
 import com.goide.sdk.GoTargetSdkVersionProvider
 import com.goide.util.GoUtil
+import com.intellij.openapi.application.ReadAction
+import com.intellij.openapi.application.runReadAction
 import com.intellij.openapi.project.Project
 
 class GoVersionChatContextProvider : ChatContextProvider {
@@ -17,15 +19,17 @@ class GoVersionChatContextProvider : ChatContextProvider {
     override suspend fun collect(project: Project, creationContext: ChatCreationContext): List<ChatContextItem> {
         val sourceFile = creationContext.sourceFile ?: return emptyList()
 
-        val goVersion = GoSdkService.getInstance(project).getSdk(GoUtil.module(sourceFile)).version
-        val targetVersion = GoTargetSdkVersionProvider.getTargetGoSdkVersion(sourceFile).toString()
+        return ReadAction.compute<List<ChatContextItem>, Throwable> {
+            val goVersion = GoSdkService.getInstance(project).getSdk(GoUtil.module(sourceFile)).version
+            val targetVersion = GoTargetSdkVersionProvider.getTargetGoSdkVersion(sourceFile).toString()
 
-        return listOf(
-            ChatContextItem(
-                GoVersionChatContextProvider::class,
-                "Go Version: $goVersion, Target Version: $targetVersion"
+            listOf(
+                ChatContextItem(
+                    GoVersionChatContextProvider::class,
+                    "Go Version: $goVersion, Target Version: $targetVersion"
+                )
             )
-        )
+        }
     }
 }
 

goland/src/main/kotlin/cc/unitmesh/go/provider/testing/GoWriteTestService.kt

@@ -3,10 +3,13 @@ package cc.unitmesh.go.provider.testing
 import cc.unitmesh.devti.context.ClassContext
 import cc.unitmesh.devti.provider.WriteTestService
 import cc.unitmesh.devti.provider.context.TestFileContext
+import cc.unitmesh.go.context.GoMethodContextBuilder
+import cc.unitmesh.go.context.GoStructContextBuilder
+import cc.unitmesh.go.util.GoPsiUtil
 import com.goide.execution.testing.GoTestRunConfiguration
-import com.goide.psi.GoFile
-import com.goide.psi.GoFunctionOrMethodDeclaration
+import com.goide.psi.*
 import com.intellij.execution.configurations.RunProfile
+import com.intellij.openapi.application.runReadAction
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.TestSourcesFilter
 import com.intellij.psi.PsiElement
@@ -20,11 +23,51 @@ class GoWriteTestService : WriteTestService() {
     override fun runConfigurationClass(project: Project): Class<out RunProfile> = GoTestRunConfiguration::class.java
 
     override fun lookupRelevantClass(project: Project, element: PsiElement): List<ClassContext> {
-        TODO("Not yet implemented")
+        return listOf()
     }
 
     override fun findOrCreateTestFile(sourceFile: PsiFile, project: Project, element: PsiElement): TestFileContext? {
-        TODO("Not yet implemented")
+        val underTestElement = getElementForTests(element) ?: return null
+        val name = GoPsiUtil.getDeclarationName(underTestElement) ?: return null
+        val testFileName = toTestFileName(name)
+        val underTestFile = underTestElement.containingFile as? GoFile ?: return null
+
+        val relatedModels = lookupRelevantClass(project, underTestElement).distinctBy { it.name }
+
+        val imports = runReadAction {
+            val importList = PsiTreeUtil.getChildrenOfTypeAsList(underTestFile, GoImportDeclaration::class.java)
+            importList.map { it.text }
+        }
+
+        val currentObject = when (underTestElement) {
+            is GoTypeDeclaration,
+            is GoTypeSpec -> {
+                GoStructContextBuilder().getClassContext(underTestElement, false)?.format()
+            }
+
+            is GoFunctionOrMethodDeclaration -> GoMethodContextBuilder().getMethodContext(
+                underTestElement,
+                false,
+                false
+            )
+                ?.format()
+
+            else -> null
+        }
+
+        return TestFileContext(
+            true,
+            underTestFile.virtualFile,
+            relatedModels,
+            testFileName,
+            underTestFile.language,
+            currentObject,
+            imports
+        )
+    }
+
+    fun toTestFileName(underTestFileName: String): String {
+        return underTestFileName + "_test.go"
     }
 
     fun getElementForTests(elementAtCaret: PsiElement): PsiElement? {

java/src/main/kotlin/cc/unitmesh/idea/service/JavaWriteTestService.kt

@@ -22,18 +22,13 @@ import org.jetbrains.plugins.gradle.service.execution.GradleRunConfiguration
 import java.io.File
 
 class JavaWriteTestService : WriteTestService() {
-    override fun runConfigurationClass(project: Project): Class<out RunProfile> {
-        return GradleRunConfiguration::class.java
-    }
-
-    override fun isApplicable(element: PsiElement): Boolean {
-        return element.language is JavaLanguage
-    }
+    override fun runConfigurationClass(project: Project): Class<out RunProfile> = GradleRunConfiguration::class.java
+    override fun isApplicable(element: PsiElement): Boolean = element.language is JavaLanguage
 
     override fun findOrCreateTestFile(sourceFile: PsiFile, project: Project, element: PsiElement): TestFileContext? {
         val sourceFilePath = sourceFile.virtualFile
         val parentDir = sourceFilePath.parent
-        val className = sourceFile.name.replace(".java", "") + "Test"
+        val testFileName = sourceFile.name.replace(".java", "") + "Test"
 
         val packageName = ReadAction.compute<String, Throwable> {
             (sourceFile as PsiJavaFile).packageName
@@ -89,7 +84,7 @@ class JavaWriteTestService : WriteTestService() {
         }
 
         return if (testFile != null) {
-            TestFileContext(isNewFile, testFile, relatedModels, className, sourceFile.language, null, imports)
+            TestFileContext(isNewFile, testFile, relatedModels, testFileName, sourceFile.language, null, imports)
         } else {
             val targetFile = createTestFile(sourceFile, testDir!!, packageName, project)
             TestFileContext(isNewFile = true, targetFile, relatedModels, "", sourceFile.language, null, imports)