remove unuse and not needed functions in FileCrawler interface

plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/util/CodeWhispererFileContextProvider.kt

@@ -136,19 +136,23 @@ class DefaultCodeWhispererFileContextProvider(private val project: Project) : Fi
 
         return supplementalContext?.let {
             if (it.contents.isNotEmpty()) {
-                LOG.info { "Successfully fetched supplemental context." }
-                it.contents.forEachIndexed { index, chunk ->
-                    LOG.info {
-                        """
-                            |---------------------------------------------------------------
-                            | Chunk $index:
+                val logStr = buildString {
+                    append("Successfully fetched supplemental context.")
+                    it.contents.forEachIndexed { index, chunk ->
+                        append(
+                            """
+                            |
+                            | Chunk ${index + 1}:
                             |    path = ${chunk.path},
                             |    score = ${chunk.score},
-                            |    content = ${chunk.content}
-                            |----------------------------------------------------------------
-                        """.trimMargin()
+                            |    contentLength = ${chunk.content.length}
+                            |
+                            """.trimMargin()
+                        )
                     }
                 }
+
+                LOG.info { logStr }
             } else {
                 LOG.warn { "Failed to fetch supplemental context, empty list." }
             }

plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/util/CodeWhispererFileCrawler.kt

@@ -20,21 +20,8 @@ import software.aws.toolkits.jetbrains.services.codewhisperer.model.ListUtgCandi
  * since different language has its own way importing other files or its own naming style for test file
  */
 interface FileCrawler {
-    /**
-     * parse the import statements provided a file
-     * @param psiFile of the file we are search with
-     * @return list of file reference from the import statements
-     */
-    suspend fun listFilesImported(psiFile: PsiFile): List<VirtualFile>
-
     fun listFilesUnderProjectRoot(project: Project): List<VirtualFile>
 
-    /**
-     * @param psiFile the file we are searching with, aka target file
-     * @return Files under the same package as the given file and exclude the given file
-     */
-    fun listFilesWithinSamePackage(psiFile: PsiFile): List<VirtualFile>
-
     /**
      * should be invoked at test files e.g. MainTest.java, or test_main.py
      * @param target psi of the test file we are searching with, e.g. MainTest.java
@@ -59,12 +46,9 @@ interface FileCrawler {
 }
 
 class NoOpFileCrawler : FileCrawler {
-    override suspend fun listFilesImported(psiFile: PsiFile): List<VirtualFile> = emptyList()
-
     override fun listFilesUnderProjectRoot(project: Project): List<VirtualFile> = emptyList()
-    override fun listUtgCandidate(target: PsiFile) = ListUtgCandidateResult(null, UtgStrategy.Empty)
 
-    override fun listFilesWithinSamePackage(psiFile: PsiFile): List<VirtualFile> = emptyList()
+    override fun listUtgCandidate(target: PsiFile) = ListUtgCandidateResult(null, UtgStrategy.Empty)
 
     override fun listCrossFileCandidate(target: PsiFile): List<VirtualFile> = emptyList()
 
@@ -99,17 +83,6 @@ abstract class CodeWhispererFileCrawler : FileCrawler {
         }
     }.orEmpty()
 
-    override fun listFilesWithinSamePackage(psiFile: PsiFile): List<VirtualFile> = runReadAction {
-        psiFile.containingDirectory?.files?.mapNotNull {
-            // exclude target file
-            if (it != psiFile) {
-                it.virtualFile
-            } else {
-                null
-            }
-        }.orEmpty()
-    }
-
     override fun listCrossFileCandidate(target: PsiFile): List<VirtualFile> {
         val targetFile = target.virtualFile
 
@@ -123,7 +96,7 @@ abstract class CodeWhispererFileCrawler : FileCrawler {
 
         val fileToFileDistanceList = runReadAction {
             openedFiles.map {
-                return@map it to CodeWhispererFileCrawler.getFileDistance(targetFile = targetFile, candidateFile = it)
+                return@map it to CodeWhispererFileCrawler.getFileDistance(fileA = targetFile, fileB = it)
             }
         }
 
@@ -202,15 +175,14 @@ abstract class CodeWhispererFileCrawler : FileCrawler {
             }
         }
 
-        // TODO: move to CodeWhispererUtils.kt
         /**
          * For [LocalFileSystem](implementation of virtual file system), the path will be an absolute file path with file separator characters replaced
          * by forward slash "/"
          * @see [VirtualFile.getPath]
          */
-        fun getFileDistance(targetFile: VirtualFile, candidateFile: VirtualFile): Int {
-            val targetFilePaths = targetFile.path.split("/").dropLast(1)
-            val candidateFilePaths = candidateFile.path.split("/").dropLast(1)
+        fun getFileDistance(fileA: VirtualFile, fileB: VirtualFile): Int {
+            val targetFilePaths = fileA.path.split("/").dropLast(1)
+            val candidateFilePaths = fileB.path.split("/").dropLast(1)
 
             var i = 0
             while (i < minOf(targetFilePaths.size, candidateFilePaths.size)) {

plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/util/JavaCodeWhispererFileCrawler.kt

@@ -3,17 +3,11 @@
 
 package software.aws.toolkits.jetbrains.services.codewhisperer.util
 
-import com.intellij.openapi.application.runReadAction
-import com.intellij.openapi.fileEditor.FileEditorManager
 import com.intellij.openapi.module.ModuleUtilCore
 import com.intellij.openapi.project.rootManager
 import com.intellij.openapi.vfs.VfsUtil
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiFile
-import com.intellij.psi.PsiJavaFile
-import com.intellij.psi.PsiPackage
-import com.intellij.psi.search.GlobalSearchScope
-import kotlinx.coroutines.yield
 import org.jetbrains.jps.model.java.JavaModuleSourceRootTypes
 import software.aws.toolkits.core.utils.getLogger
 import software.aws.toolkits.core.utils.warn
@@ -29,48 +23,6 @@ object JavaCodeWhispererFileCrawler : CodeWhispererFileCrawler() {
         Regex("""^(.+)Tests(\.java)$""")
     )
 
-    override suspend fun listFilesImported(psiFile: PsiFile): List<VirtualFile> {
-        if (psiFile !is PsiJavaFile) return emptyList()
-        val result = mutableListOf<VirtualFile>()
-        val imports = runReadAction { psiFile.importList?.allImportStatements }
-        val activeFiles = FileEditorManager.getInstance(psiFile.project).openFiles.toSet()
-
-        // only consider imported files which belong users' own package, thus [isInLocalFileSystem && isWritable]
-        val fileHandleLambda = { virtualFile: VirtualFile ->
-            if (virtualFile.isInLocalFileSystem && virtualFile.isWritable) {
-                // prioritize active files on users' editor
-                if (activeFiles.contains(virtualFile)) {
-                    result.add(0, virtualFile)
-                } else {
-                    result.add(virtualFile)
-                }
-            }
-        }
-
-        imports?.forEach {
-            yield()
-            runReadAction { it.resolve() }?.let { psiElement ->
-                // case like import javax.swing.*;
-                if (psiElement is PsiPackage) {
-                    val filesInPackage = psiElement.getFiles(GlobalSearchScope.allScope(psiFile.project)).mapNotNull { it.virtualFile }
-                    filesInPackage.forEach { file ->
-                        fileHandleLambda(file)
-                    }
-                } else {
-                    // single file import
-                    runReadAction {
-                        psiElement.containingFile.virtualFile?.let { virtualFile ->
-                            // file within users' project
-                            fileHandleLambda(virtualFile)
-                        }
-                    }
-                }
-            }
-        }
-
-        return result
-    }
-
     // psiFile = "MainTest.java", targetFileName = "Main.java"
     override fun findSourceFileByName(target: PsiFile): VirtualFile? =
         guessSourceFileName(target.virtualFile.name)?.let { srcName ->

plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/util/JavascriptCodeWhispererFileCrawler.kt

@@ -14,8 +14,6 @@ object JavascriptCodeWhispererFileCrawler : CodeWhispererFileCrawler() {
         Regex("""^(.+)\.(?i:s)pec(\.js|\.jsx)$""")
     )
 
-    override suspend fun listFilesImported(psiFile: PsiFile): List<VirtualFile> = emptyList()
-
     override fun findSourceFileByName(target: PsiFile): VirtualFile? = null
 
     override fun findSourceFileByContent(target: PsiFile): VirtualFile? = null

plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/util/PythonCodeWhispererFileCrawler.kt

@@ -17,8 +17,6 @@ object PythonCodeWhispererFileCrawler : CodeWhispererFileCrawler() {
         Regex("""^(.+)_test(\.py)$""")
     )
 
-    override suspend fun listFilesImported(psiFile: PsiFile): List<VirtualFile> = emptyList()
-
     override fun findSourceFileByName(target: PsiFile): VirtualFile? = super.listFilesUnderProjectRoot(target.project).find {
         !it.isDirectory &&
             it.isWritable &&

plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/util/TypescriptCodeWhispererFileCrawler.kt

@@ -14,8 +14,6 @@ object TypescriptCodeWhispererFileCrawler : CodeWhispererFileCrawler() {
         Regex("""^(.+)\.(?i:s)pec(\.ts|\.tsx)$""")
     )
 
-    override suspend fun listFilesImported(psiFile: PsiFile): List<VirtualFile> = emptyList()
-
     override fun findSourceFileByName(target: PsiFile): VirtualFile? = null
 
     override fun findSourceFileByContent(target: PsiFile): VirtualFile? = null

plugins/amazonq/codewhisperer/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/codewhisperer/CodeWhispererFileCrawlerTest.kt

@@ -6,13 +6,11 @@ package software.aws.toolkits.jetbrains.services.codewhisperer
 import com.intellij.openapi.application.runReadAction
 import com.intellij.openapi.editor.EditorFactory
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiFile
 import com.intellij.testFramework.DisposableRule
 import com.intellij.testFramework.ExtensionTestUtil
 import com.intellij.testFramework.fixtures.CodeInsightTestFixture
 import com.intellij.testFramework.runInEdtAndWait
-import kotlinx.coroutines.runBlocking
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.Before
 import org.junit.Rule
@@ -262,81 +260,6 @@ class JavaCodeWhispererFileCrawlerTest {
         }
     }
 
-    @Test
-    fun `listFilesWithinSamePackage`() {
-        val targetFile = fixture.addFileToProject("/utils/AnotherClass.java", "")
-        val file2Package1 = fixture.addFileToProject("/utils/NotImported.java", "")
-        val file3Package1 = fixture.addFileToProject("/utils/NotImported2.java", "")
-        fixture.addFileToProject("Main.java", "")
-        fixture.addFileToProject("service/controllers/MyController.java", "")
-
-        runReadAction {
-            val actual = sut.listFilesWithinSamePackage(targetFile)
-            val expected = listOf<PsiFile>(file2Package1, file3Package1)
-                .map { it.virtualFile }
-                .toSet()
-
-            assertThat(actual).hasSize(expected.size)
-            actual.forEach {
-                assertThat(expected.contains(it)).isTrue
-            }
-        }
-    }
-
-    @Test
-    fun `findFilesImported`() {
-        val mainClass = fixture.addFileToProject(
-            "Main.java",
-            """
-            package com.cw.file_crawler_test;
-
-            import java.util.Map;
-            import java.util.regex.Pattern;
-
-            import com.cw.file_crawler_test.utils.AnotherClass;
-            import com.cw.file_crawler_test.service.controllers.MyController;
-
-            public class Main {
-            };
-            """.trimIndent()
-        )
-
-        val controllerClass = fixture.addFileToProject(
-            "service/controllers/MyController.java",
-            """
-                package com.cw.file_crawler_test.service.controllers;
-
-                public class MyController {}
-            """.trimIndent()
-        )
-
-        val anotherClass = fixture.addFileToProject(
-            "/utils/AnotherClass.java",
-            """
-                package com.cw.file_crawler_test.utils;
-
-                public class AnotherClass {}
-            """.trimIndent()
-        )
-
-        fun assertCrawlerFindCorrectFiles(sut: CodeWhispererFileCrawler) {
-            runReadAction {
-                val expected = setOf<VirtualFile>(controllerClass.virtualFile, anotherClass.virtualFile)
-                val actualFiles = runBlocking { sut.listFilesImported(mainClass) }
-
-                assertThat(actualFiles).hasSize(2)
-                actualFiles.forEach {
-                    assertThat(expected).contains(it)
-                }
-            }
-        }
-
-        assertCrawlerFindCorrectFiles(JavaCodeWhispererFileCrawler)
-        // can't make it work right since the temp file created is not in the real file system
-        // Naive crawler will actually read the file system thun unable to find files
-        //        assertCrawlerFindCorrectFiles(NaiveJavaCodeWhispererFileCrawler(project))
-    }
-
     @Test
     fun `listUtgCandidate by name`() {
         val mainPsi = fixture.addFileToProject("Main.java", aString())