Merge branch 'feature/q-lsp' into feature/q-lsp

Author: leigaol

.changes/next-release/bugfix-f31946b6-3709-44a5-b23f-9fa202bd5cb5.json

@@ -0,0 +1,4 @@
+{
+  "type" : "bugfix",
+  "description" : "Fix infinite loop when workspace indexing server fails to initialize"
+}

plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/util/WorkspaceFolderUtil.kt

@@ -3,8 +3,9 @@
 
 package software.aws.toolkits.jetbrains.services.amazonq.lsp.util
 
+import com.intellij.openapi.module.ModuleManager
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.roots.ProjectRootManager
+import com.intellij.openapi.roots.ModuleRootManager
 import org.eclipse.lsp4j.WorkspaceFolder
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.util.FileUriUtil.toUriString
 
@@ -13,10 +14,12 @@ object WorkspaceFolderUtil {
         if (project.isDefault) {
             emptyList()
         } else {
-            ProjectRootManager.getInstance(project).contentRoots.map { contentRoot ->
-                WorkspaceFolder().apply {
-                    name = contentRoot.name
-                    this.uri = toUriString(contentRoot)
+            ModuleManager.getInstance(project).modules.mapNotNull { module ->
+                ModuleRootManager.getInstance(module).contentRoots.firstOrNull()?.let { contentRoot ->
+                    WorkspaceFolder().apply {
+                        name = module.name
+                        uri = toUriString(contentRoot)
+                    }
                 }
             }
         }

plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/project/ProjectContextProvider.kt

@@ -116,10 +116,14 @@ class ProjectContextProvider(val project: Project, private val encoderServer: En
                     logger.info { "project context index starting" }
                     delay(300)
                     val isIndexSuccess = index()
-                    if (isIndexSuccess) isIndexComplete.set(true)
+                    if (isIndexSuccess) {
+                        isIndexComplete.set(true)
+                    }
                     return
                 }
+                retryCount.incrementAndGet()
             } catch (e: Exception) {
+                logger.warn(e) { "failed to init project context" }
                 if (e.stackTraceToString().contains("Connection refused")) {
                     retryCount.incrementAndGet()
                     delay(10000)
@@ -133,6 +137,7 @@ class ProjectContextProvider(val project: Project, private val encoderServer: En
     private suspend fun initEncryption(): Boolean {
         val request = encoderServer.getEncryptionRequest()
         val response = sendMsgToLsp(LspMessage.Initialize, request)
+        logger.info { "received response to init encryption: $response" }
         return response?.responseCode == 200
     }
 

plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/util/WorkspaceFolderUtilTest.kt

@@ -3,32 +3,39 @@
 
 package software.aws.toolkits.jetbrains.services.amazonq.lsp.util
 
+import com.intellij.openapi.module.Module
+import com.intellij.openapi.module.ModuleManager
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.roots.ProjectRootManager
+import com.intellij.openapi.roots.ModuleRootManager
 import com.intellij.openapi.vfs.VirtualFile
 import io.mockk.every
 import io.mockk.mockk
+import io.mockk.mockkStatic
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
 import java.net.URI
-import java.nio.file.Path
 
 class WorkspaceFolderUtilTest {
 
     @Test
-    fun `createWorkspaceFolders returns empty list when no workspace folders`() {
+    fun `createWorkspaceFolders returns empty list when project is default`() {
         val mockProject = mockk<Project>()
         every { mockProject.isDefault } returns true
 
         val result = WorkspaceFolderUtil.createWorkspaceFolders(mockProject)
 
-        assertThat(result).isEqualTo(emptyList<VirtualFile>())
+        assertThat(result).isEmpty()
     }
 
     @Test
-    fun `createWorkspaceFolders returns workspace folders for non-default project`() {
+    fun `createWorkspaceFolders returns workspace folders for non-default project with modules`() {
         val mockProject = mockk<Project>()
-        val mockProjectRootManager = mockk<ProjectRootManager>()
+        val mockModuleManager = mockk<ModuleManager>()
+        val mockModule1 = mockk<Module>()
+        val mockModule2 = mockk<Module>()
+        val mockModuleRootManager1 = mockk<ModuleRootManager>()
+        val mockModuleRootManager2 = mockk<ModuleRootManager>()
+
         val mockContentRoot1 = createMockVirtualFile(
             URI("file:///path/to/root1"),
             name = "root1"
@@ -38,58 +45,65 @@ class WorkspaceFolderUtilTest {
             name = "root2"
         )
 
+        mockkStatic(ModuleManager::class, ModuleRootManager::class)
+
         every { mockProject.isDefault } returns false
-        every { ProjectRootManager.getInstance(mockProject) } returns mockProjectRootManager
-        every { mockProjectRootManager.contentRoots } returns arrayOf(mockContentRoot1, mockContentRoot2)
+        every { ModuleManager.getInstance(mockProject) } returns mockModuleManager
+        every { mockModuleManager.modules } returns arrayOf(mockModule1, mockModule2)
+        every { mockModule1.name } returns "module1"
+        every { mockModule2.name } returns "module2"
+        every { ModuleRootManager.getInstance(mockModule1) } returns mockModuleRootManager1
+        every { ModuleRootManager.getInstance(mockModule2) } returns mockModuleRootManager2
+        every { mockModuleRootManager1.contentRoots } returns arrayOf(mockContentRoot1)
+        every { mockModuleRootManager2.contentRoots } returns arrayOf(mockContentRoot2)
 
         val result = WorkspaceFolderUtil.createWorkspaceFolders(mockProject)
 
         assertThat(result).hasSize(2)
         assertThat(result[0].uri).isEqualTo(normalizeFileUri("file:///path/to/root1"))
         assertThat(result[1].uri).isEqualTo(normalizeFileUri("file:///path/to/root2"))
-        assertThat(result[0].name).isEqualTo("root1")
-        assertThat(result[1].name).isEqualTo("root2")
+        assertThat(result[0].name).isEqualTo("module1")
+        assertThat(result[1].name).isEqualTo("module2")
     }
 
     @Test
-    fun `createWorkspaceFolders returns empty list when project has no content roots`() {
+    fun `createWorkspaceFolders handles modules with no content roots`() {
         val mockProject = mockk<Project>()
-        val mockProjectRootManager = mockk<ProjectRootManager>()
+        val mockModuleManager = mockk<ModuleManager>()
+        val mockModule = mockk<Module>()
+        val mockModuleRootManager = mockk<ModuleRootManager>()
+
+        mockkStatic(ModuleManager::class, ModuleRootManager::class)
 
         every { mockProject.isDefault } returns false
-        every { ProjectRootManager.getInstance(mockProject) } returns mockProjectRootManager
-        every { mockProjectRootManager.contentRoots } returns emptyArray()
+        every { ModuleManager.getInstance(mockProject) } returns mockModuleManager
+        every { mockModuleManager.modules } returns arrayOf(mockModule)
+        every { ModuleRootManager.getInstance(mockModule) } returns mockModuleRootManager
+        every { mockModuleRootManager.contentRoots } returns emptyArray()
 
         val result = WorkspaceFolderUtil.createWorkspaceFolders(mockProject)
 
-        assertThat(result).isEqualTo(emptyList<VirtualFile>())
+        assertThat(result).isEmpty()
     }
 
-    private fun createMockVirtualFile(uri: URI, name: String): VirtualFile {
-        val path = mockk<Path> {
-            every { toUri() } returns uri
-        }
-        return mockk<VirtualFile> {
+    private fun createMockVirtualFile(uri: URI, name: String): VirtualFile =
+        mockk<VirtualFile> {
             every { url } returns uri.toString()
             every { getName() } returns name
-            every { toNioPath() } returns path
             every { isDirectory } returns false
             every { fileSystem } returns mockk {
                 every { protocol } returns "file"
             }
         }
-    }
 
     // for windows unit tests
     private fun normalizeFileUri(uri: String): String {
         if (!System.getProperty("os.name").lowercase().contains("windows")) {
             return uri
         }
-
         if (!uri.startsWith("file:///")) {
             return uri
         }
-
         val path = uri.substringAfter("file:///")
         return "file:///C:/$path"
     }