feat(javascript): add callee lookup for JS functions #308

Implement `lookupCallee` and `findCallees` methods in `JavaScriptRelatedClassProvider` to find called functions within a JS function. Added corresponding test case in `JavaScriptRelatedClassProviderTest`.

Author: phodal

javascript/src/main/kotlin/cc/unitmesh/ide/javascript/provider/JavaScriptRelatedClassProvider.kt

@@ -2,10 +2,45 @@ package cc.unitmesh.ide.javascript.provider
 
 import cc.unitmesh.devti.provider.RelatedClassesProvider
 import cc.unitmesh.ide.javascript.util.JSTypeResolver
+import com.intellij.lang.javascript.psi.JSCallExpression
+import com.intellij.lang.javascript.psi.JSFunction
+import com.intellij.lang.javascript.psi.JSRecursiveWalkingElementVisitor
+import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 
 class JavaScriptRelatedClassProvider : RelatedClassesProvider {
     override fun lookupIO(element: PsiElement): List<PsiElement> = JSTypeResolver.resolveByElement(element)
     override fun lookupIO(element: PsiFile): List<PsiElement> = JSTypeResolver.resolveByElement(element)
+
+    override fun lookupCallee(
+        project: Project,
+        element: PsiElement
+    ): List<PsiElement> {
+        return when (element) {
+            is JSFunction -> findCallees(project, element)
+            else -> emptyList()
+        }
+    }
+
+    fun findCallees(project: Project, method: JSFunction): List<JSFunction> {
+        val calledMethods = mutableSetOf<JSFunction>()
+        method.accept(object : JSRecursiveWalkingElementVisitor() {
+            override fun visitJSCallExpression(node: JSCallExpression) {
+//                if (node.isRequireCall) {
+//                    val path = CommonJSUtil.getModulePathIfRequireCall(node)
+//                    if (!path.isNullOrEmpty() && !JSFileReferencesUtil.isRelative(path)) {
+//                       //
+//                    }
+//                }
+                val psiRef = node.stubSafeMethodExpression?.reference ?: return
+                val resolve = psiRef?.resolve() ?: return
+                if (resolve is JSFunction) {
+                    calledMethods.add(resolve)
+                }
+            }
+        })
+
+        return calledMethods.toList()
+    }
 }

javascript/src/test/kotlin/cc/unitmesh/ide/javascript/provider/JavaScriptRelatedClassProviderTest.kt

@@ -0,0 +1,37 @@
+package cc.unitmesh.ide.javascript.provider
+
+import com.intellij.lang.javascript.psi.JSFunction
+import com.intellij.psi.PsiFileFactory
+import com.intellij.testFramework.LightPlatformTestCase
+import org.intellij.lang.annotations.Language
+
+class JavaScriptRelatedClassProviderTest : LightPlatformTestCase() {
+    @Language("JavaScript")
+    val code = """
+    function bar() {
+        console.log('bar');
+    }
+
+    function baz() {
+        console.log('baz');
+    }
+    
+    function foo() {
+        bar();
+        baz();
+    }
+    """.trimIndent()
+
+    fun testShouldReturnCorrectCallees() {
+        // given
+        val file = PsiFileFactory.getInstance(project).createFileFromText("test.js", code)
+        val lastFunction = file.children.last()
+
+        // when
+        val provider = JavaScriptRelatedClassProvider()
+        val result = provider.findCallees(project, lastFunction as JSFunction)
+
+        // then
+        assertEquals(2, result.size)
+    }
+}

javascript/src/test/kotlin/cc/unitmesh/ide/javascript/provider/testing/JSWriteTestServiceTest.kt

@@ -9,11 +9,12 @@ import com.intellij.psi.PsiFileFactory
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.testFramework.LightPlatformTestCase
 import junit.framework.TestCase
+import org.intellij.lang.annotations.Language
 import java.io.File
 
 class JSWriteTestServiceTest : LightPlatformTestCase() {
     fun testShouldReturnNullWhenFilePathEmpty() {
-        // given
+        @Language("JavaScript")
         val code = """
             export class Foo {
                 constructor() {