Yet another bug with local variables

Author: DaniilStepanov

jacodb-core/src/main/kotlin/org/jacodb/impl/cfg/RawInstListBuilder.kt

@@ -159,6 +159,33 @@ private val AbstractInsnNode.isBranchingInst
 private val AbstractInsnNode.isTerminateInst
     get() = this is InsnNode && (this.opcode == Opcodes.ATHROW || this.opcode in Opcodes.IRETURN..Opcodes.RETURN)
 
+private fun LabelNode.isBetween(labelStart: LabelNode, labelEnd: LabelNode): Boolean {
+    var curNode: AbstractInsnNode? = this
+    var left = false
+    var right = false
+    while (curNode != null) {
+        if (curNode == labelStart) {
+            left = true
+            break
+        }
+        if (curNode == labelEnd && curNode != this) {
+            return false
+        }
+        curNode = curNode.previous
+
+    }
+    if (!left) return false
+    curNode = this
+    while (curNode != null) {
+        if (curNode == labelEnd) {
+            right = true
+            break
+        }
+        curNode = curNode.next
+    }
+    return right
+}
+
 private val TryCatchBlockNode.typeOrDefault get() = this.type ?: THROWABLE_CLASS
 
 private val Collection<TryCatchBlockNode>.commonTypeOrDefault
@@ -381,30 +408,6 @@ class RawInstListBuilder(
         return currentFrame.locals.getValue(variable)
     }
 
-//    fun LabelNode.isBetween(labelStart: LabelNode, labelEnd: LabelNode): Boolean {
-//        var curNode: AbstractInsnNode = labelStart
-//        while (curNode != labelEnd && curNode != null) {
-//            if (this == curNode) {
-//                return true
-//            }
-//            curNode = curNode.next
-//        }
-//        return this == curNode
-//    }
-//
-//    val instrLabel = methodNode.instructions.takeWhile { it != insn }.last { it is LabelNode } as LabelNode
-//    val locals = methodNode.localVariables.filter { it.index == variable }
-//    locals.map { instrLabel.isBetween(it.start, it.end) }
-//    locals
-
-
-    //    val oldVar = currentFrame.locals[variable]?.let {
-//            if (expr.typeName.isPrimitive.xor(it.typeName.isPrimitive)) {
-//                null
-//            } else {
-//                it
-//            }
-//        }
     private fun local(
         variable: Int,
         expr: JcRawValue,
@@ -919,6 +922,8 @@ class RawInstListBuilder(
                     else -> {
                         val assignment = nextRegister(type)
                         for ((node, frame) in predFrames) {
+                            //TODO! Make anything with that (we should take into account subtyping)
+                            //assigment.isSubtypeOf(frame[variable]!!.typeName)
                             if (frame != null) {
                                 if (node.isBranchingInst) {
                                     addInstruction(node, JcRawAssignInst(method, assignment, frame[variable]!!), 0)
@@ -1191,17 +1196,26 @@ class RawInstListBuilder(
         }
     }
 
-    private fun mergeFrames(frames: Map<AbstractInsnNode, Frame>): Frame {
+    private fun mergeFrames(frames: Map<AbstractInsnNode, Frame>, curLabel: LabelNode): Frame {
         val frameSet = frames.values
         if (frames.isEmpty()) return currentFrame
         if (frames.size == 1) return frameSet.first()
 
         val allLocals = frameSet.flatMap { it.locals.keys }
         val localTypes = allLocals
             .filter { local -> frameSet.all { local in it.locals } }
-            .associateWith {
-                val types = frameSet.map { frame -> frame[it]!!.typeName }
-                types.firstOrNull { it != NULL } ?: NULL
+            .associateWith { ind ->
+                val types = frameSet.map { frame -> frame[ind]!!.typeName }
+                //If we have several variables types for one register we have to search right type in debug info otherwise we cannot guarantee anything
+                if (types.toSet().size != 1) {
+                    methodNode.localVariables
+                        .firstOrNull { curLabel.isBetween(it.start, it.end) && it.index == ind }
+                        ?.desc
+                        ?.let { TypeNameImpl(it) }
+                        ?: types.firstOrNull { it != NULL } ?: NULL
+                } else {
+                    types.firstOrNull { it != NULL } ?: NULL
+                }
             }
             .toSortedMap()
         val newLocals = localTypes.copyLocals(frames).toPersistentMap()
@@ -1227,7 +1241,7 @@ class RawInstListBuilder(
         if (predecessorFrames.size == 1) {
             currentFrame = predecessorFrames.first()
         } else if (predecessors.size == predecessorFrames.size) {
-            currentFrame = mergeFrames(predecessors.zip(predecessorFrames).toMap())
+            currentFrame = mergeFrames(predecessors.zip(predecessorFrames).toMap(), insnNode)
         }
         val catchEntries = methodNode.tryCatchBlocks.filter { it.handler == insnNode }
 

jacodb-core/src/test/kotlin/org/jacodb/testing/cfg/BaseInstructionsTest.kt

@@ -55,12 +55,12 @@ abstract class BaseInstructionsTest : BaseTest() {
     }
 
 
-    protected fun testClass(klass: JcClassOrInterface, validateLineNumbers: Boolean = true) {
-        testAndLoadClass(klass, false, validateLineNumbers)
+    protected fun testClass(klass: JcClassOrInterface, validateLineNumbers: Boolean = true, muteGraphChecker: Boolean = false) {
+        testAndLoadClass(klass, false, validateLineNumbers, muteGraphChecker)
     }
 
     protected fun testAndLoadClass(klass: JcClassOrInterface, muteGraphChecker: Boolean = false): Class<*> {
-        return testAndLoadClass(klass, true, validateLineNumbers = true)!!
+        return testAndLoadClass(klass, true, validateLineNumbers = true, muteGraphChecker = muteGraphChecker)!!
     }
 
     private fun testAndLoadClass(

jacodb-core/src/test/kotlin/org/jacodb/testing/cfg/IRTest.kt

@@ -301,7 +301,11 @@ class IRTest : BaseInstructionsTest() {
         runAlongLib(guavaLib)
     }
 
-    // todo: make this test green
+    @Test
+    fun `get ir of asm`() {
+        runAlongLib(asmLib, muteGraphChecker = true)
+    }
+
     @Test
     fun `get ir of kotlinx-coroutines`() {
         runAlongLib(kotlinxCoroutines, false)
@@ -320,7 +324,7 @@ class IRTest : BaseInstructionsTest() {
         }
     }
 
-    private fun runAlongLib(file: File, validateLineNumbers: Boolean = true) {
+    private fun runAlongLib(file: File, validateLineNumbers: Boolean = true, muteGraphChecker: Boolean = false) {
         println("Run along: ${file.absolutePath}")
 
         val classes = JarLocation(file, isRuntime = false, object : JavaVersion {
@@ -332,7 +336,7 @@ class IRTest : BaseInstructionsTest() {
             val clazz = cp.findClass(it.key)
             if (!clazz.isAnnotation && !clazz.isInterface) {
                 println("Testing class: ${it.key}")
-                testClass(clazz, validateLineNumbers)
+                testClass(clazz, validateLineNumbers, muteGraphChecker)
             }
         }
     }

jacodb-core/src/test/kotlin/org/jacodb/testing/cfg/KotlinInstructionsTest.kt

@@ -48,8 +48,8 @@ class KotlinInstructionsTest: BaseInstructionsTest() {
 //    fun `kotlin overloading test`() = runKotlinTest(Overloading::class.java.name)
 
     //We have to mute graph checker because of empty catch-es in try/catch blocks
-//    @Test
-//    fun `kotlin try catch finally`() = runKotlinTest(TryCatchFinally::class.java.name, muteGraphChecker = true)
+    @Test
+    fun `kotlin try catch finally`() = runKotlinTest(TryCatchFinally::class.java.name, muteGraphChecker = true)
 
     @Test
     fun `kotlin try catch finally 2`() = runKotlinTest(TryCatchFinally2::class.java.name, muteGraphChecker = true)

jacodb-core/src/testFixtures/kotlin/org/jacodb/testing/LibrariesMixin.kt

@@ -33,6 +33,14 @@ val guavaLib: File
         }
     }
 
+val asmLib: File
+    get() {
+        val asmUrl = classpath.first { it.contains("/asm/") }
+        return File(asmUrl).also {
+            Assertions.assertTrue(it.isFile && it.exists())
+        }
+    }
+
 val kotlinxCoroutines: File
     get() {
         val coroutines = classpath.first { it.contains("kotlinx-coroutines-") }