refactor(kotlin): try to add handle for test package issue

Author: phodal

chapi-ast-kotlin/src/main/kotlin/chapi/ast/kotlinast/KotlinFullIdentListener.kt

@@ -7,28 +7,31 @@ import chapi.domain.core.CodeDataStruct
 import chapi.domain.core.CodeField
 import chapi.domain.core.CodeImport
 import chapi.domain.core.CodeProperty
+import java.io.File
+
+private const val PRIMARY_CONSTRUCTOR = "PrimaryConstructor"
 
 /**
- * listen to full identifier with complex type and sceneries, such as:
+ * listen to full identifier with a complex type and sceneries, such as:
  * - call relationship
  * - lambda expression
  * - coroutine
  */
-open class KotlinFullIdentListener(fileName: String) : KotlinBasicIdentListener(fileName) {
+open class KotlinFullIdentListener(val fileName: String) : KotlinBasicIdentListener(fileName) {
 
     private val postClassHandler = mutableListOf<(CodeDataStruct) -> Unit>()
-    private var VARIABLE_POOL: MutableMap<String, String> = mutableMapOf()
+    private var variablePool: MutableMap<String, String> = mutableMapOf()
 
     override fun enterPropertyDeclaration(ctx: KotlinParser.PropertyDeclarationContext?) {
         if (ctx!!.variableDeclaration() != null) {
             val varDecl = ctx.variableDeclaration()
             val key = varDecl.simpleIdentifier().text
             if (ctx.ASSIGNMENT() != null) {
                 if (ctx.propertyDelegate() != null) {
-                    VARIABLE_POOL[key] = ctx.propertyDelegate().text
+                    variablePool[key] = ctx.propertyDelegate().text
                 }
                 if (ctx.expression() != null) {
-                    VARIABLE_POOL[key] = ctx.expression().text
+                    variablePool[key] = ctx.expression().text
                 }
             }
 
@@ -58,16 +61,16 @@ open class KotlinFullIdentListener(fileName: String) : KotlinBasicIdentListener(
         // if a argument/parameter type is not a string and not a number, it could be a variable
         // so, try to load value from VARIABLE_POOL
         if (typeType == "") {
-            if (VARIABLE_POOL[value] != null) {
-                value = VARIABLE_POOL[value].toString()
+            if (variablePool[value] != null) {
+                value = variablePool[value].toString()
 
                 // value contains with String
                 val matches = VAR_IN_STRING.find(value)
                 matches?.groups?.forEach {
                     if (it?.value != null) {
                         val variable = it.value
                         val withoutVariable = variable.removePrefix("$")
-                        val pool = VARIABLE_POOL[withoutVariable]
+                        val pool = variablePool[withoutVariable]
                         if (pool != null) {
                             var poolText = pool
                             if (poolText.startsWith("\"") && poolText.endsWith("\"")) {
@@ -85,6 +88,8 @@ open class KotlinFullIdentListener(fileName: String) : KotlinBasicIdentListener(
         return CodeProperty(TypeType = typeType, TypeValue = value)
     }
 
+    val testDir = listOf("src", "test", "kotlin").joinToString(File.separator)
+
     // correct the function info
     private fun CodeCall.refineIfExistsCreator(): CodeCall {
         // search the node in declared classes (for individual function)
@@ -109,12 +114,14 @@ open class KotlinFullIdentListener(fileName: String) : KotlinBasicIdentListener(
 
     // return null to quick exit
     private fun CodeCall.refineWithClass(it: CodeDataStruct): CodeCall? {
-        if (FunctionName.isNotEmpty() && it.NodeName == FunctionName && FunctionName.first().isUpperCase()) {
-            Type = CallType.CREATOR
-            Package = it.Package
-            NodeName = it.NodeName
-            this.FunctionName = "PrimaryConstructor"
-            return null
+        if (FunctionName[0].isUpperCase()) {
+            if (it.NodeName == FunctionName) {
+                Type = CallType.CREATOR
+                Package = it.Package
+                NodeName = it.NodeName
+                this.FunctionName = PRIMARY_CONSTRUCTOR
+                return null
+            }
         }
 
         return this
@@ -126,10 +133,13 @@ open class KotlinFullIdentListener(fileName: String) : KotlinBasicIdentListener(
             return null
         }
 
+        // for Kotlin, if the function name is same as the import name, it's a creator
         if (it.AsName == FunctionName && FunctionName[0].isUpperCase()) {
             Package = it.Source
             NodeName = FunctionName
-            return null;
+            FunctionName = PRIMARY_CONSTRUCTOR
+            Type = CallType.CREATOR
+            return null
         }
 
         if (it.AsName == FunctionName) {

chapi-ast-kotlin/src/test/kotlin/chapi/ast/kotlinast/KotlinFunctionCallTest.kt

@@ -23,4 +23,36 @@ class KotlinFunctionCallTest {
         assert(functionCall.FunctionName == "PrimaryConstructor")
         assert(functionCall.NodeName == "A")
     }
+
+    @Test
+    fun should_success_parse_test_usecase() {
+        val code = """
+        package cc.unitmesh.pick
+
+        class SingleProjectCodePickerTest {
+            @Test
+            fun shouldCheckoutTestCode() {
+                val picker = SingleProjectCodePicker(
+                    InsPickerOption(
+                        url = "https://github.com/unit-mesh/unit-eval-testing",
+                        completionTypeSize = 10,
+                        maxCharInCode = 100,
+                    )
+                )
+        
+                val outputFile = File("test.jsonl")
+                runBlocking {
+                    val output: MutableList<Instruction> = picker.execute()
+                    outputFile.writeText(output.joinToString("\n") {
+                        Json.encodeToString(it)
+                    })
+                }
+            }
+        }""".trimIndent()
+
+        val codeContainer = KotlinAnalyser().analysis(code, "Test.kt", ParseMode.Full)
+        val dataStructures = codeContainer.DataStructures.filter { it.NodeName == "SingleProjectCodePickerTest" }
+        val functionCall = dataStructures[0].Functions[0].FunctionCalls[0]
+        println(functionCall)
+    }
 }