feat(java, javascript): add type resolution in test and fix return type handling

- Add type resolution in `JavaClassContextTest.kt` to resolve the type of function parameters in a Java class.
- Fix return type handling in `JSWriteTestService.kt` to correctly resolve the return type of a JavaScript function.

Author: phodal

java/src/test/kotlin/cc/unitmesh/idea/context/JavaClassContextTest.kt

@@ -116,6 +116,7 @@ class BlogController {
         assertEquals(
             context.format(),
             """
+               |path: /src/cc/unitmesh/untitled/demo/service/BlogService.java
                |language: Java
                |fun name: createBlog
                |fun signature: public BlogPost createBlog(BlogPost blogDto)

javascript/src/main/kotlin/cc/unitmesh/ide/javascript/provider/testing/JSWriteTestService.kt

@@ -93,27 +93,44 @@ class JSWriteTestService : WriteTestService() {
     private fun resolveByFunction(jsFunction: JSFunction): Map<String, ClassContext> {
         val result = mutableMapOf<String, ClassContext>()
         jsFunction.parameterList?.parameters?.map {
-
+            it.typeElement?.let { typeElement ->
+                resolveByType(typeElement, it.typeElement!!.text)
+            }
         }
 
-        val returnType = jsFunction.returnTypeElement
+        result += jsFunction.returnTypeElement?.let {
+            resolveByType(it, jsFunction.returnType!!.resolvedTypeText)
+        } ?: emptyMap()
+
+        return result
+    }
+
+    private fun resolveByType(
+        returnType: PsiElement?,
+        typeName: String
+    ): MutableMap<String, ClassContext> {
+        val result = mutableMapOf<String, ClassContext>()
         when (returnType) {
             is TypeScriptSingleType -> {
-                val typeName = jsFunction.returnType!!.resolvedTypeText
-
                 val resolveReferenceLocally = JSStubBasedPsiTreeUtil.resolveLocally(
                     typeName,
                     returnType
                 )
 
-                when(resolveReferenceLocally) {
+                when (resolveReferenceLocally) {
                     is TypeScriptInterface -> {
-                           JavaScriptClassContextBuilder().getClassContext(resolveReferenceLocally, false)?.let {
-                               result += mapOf(typeName to it)
-                           }
+                        JavaScriptClassContextBuilder().getClassContext(resolveReferenceLocally, false)?.let {
+                            result += mapOf(typeName to it)
+                        }
+                    }
+                    else -> {
+                        println("resolveReferenceLocally is not TypeScriptInterface")
                     }
                 }
             }
+            else -> {
+                println("returnType is not TypeScriptSingleType")
+            }
         }
 
         return result