Comparison with zero finally fixed

Author: DaniilStepanov

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

@@ -264,42 +264,38 @@ class MethodNodeBuilder(
                 cond.lhv.typeName.isPrimitive -> Triple(JcRawInt(0), Opcodes.IFNE, Opcodes.IF_ICMPNE)
                 else -> Triple(JcRawNull(), Opcodes.IFNONNULL, Opcodes.IF_ACMPNE)
             }
-
-            is JcRawGeExpr -> Triple(JcRawInt(0), Opcodes.IFGE, Opcodes.IF_ICMPGE).also { shouldReverse = true }
-            is JcRawGtExpr -> Triple(JcRawInt(0), Opcodes.IFGT, Opcodes.IF_ICMPGT).also { shouldReverse = true }
-            is JcRawLeExpr -> Triple(JcRawInt(0), Opcodes.IFLE, Opcodes.IF_ICMPLE).also { shouldReverse = true }
-            is JcRawLtExpr -> Triple(JcRawInt(0), Opcodes.IFLT, Opcodes.IF_ICMPLT).also { shouldReverse = true }
+            is JcRawGeExpr -> Triple(JcRawInt(0), Opcodes.IFGE, Opcodes.IF_ICMPGE)
+            is JcRawGtExpr -> Triple(JcRawInt(0), Opcodes.IFGT, Opcodes.IF_ICMPGT)
+            is JcRawLeExpr -> Triple(JcRawInt(0), Opcodes.IFLE, Opcodes.IF_ICMPLE)
+            is JcRawLtExpr -> Triple(JcRawInt(0), Opcodes.IFLT, Opcodes.IF_ICMPLT)
             else -> error("Unknown condition expr: $cond")
         }
-        val elseBranchTarget: LabelNode
         currentInsnList.add(
             when {
                 cond.lhv == zeroValue -> {
                     cond.rhv.accept(this)
-                    if (shouldReverse) {
-                        elseBranchTarget = trueTarget
-                        JumpInsnNode(zeroCmpOpcode, falseTarget)
-                    } else {
-                        elseBranchTarget = falseTarget
-                        JumpInsnNode(zeroCmpOpcode, trueTarget)
-                    }
+                    val invertedZeroCmpOpcode =
+                        when (zeroCmpOpcode) {
+                            Opcodes.IFGE -> Opcodes.IFLE
+                            Opcodes.IFGT -> Opcodes.IFLT
+                            Opcodes.IFLE -> Opcodes.IFGE
+                            Opcodes.IFLT -> Opcodes.IFGT
+                            else -> zeroCmpOpcode
+                        }
+                    JumpInsnNode(invertedZeroCmpOpcode, trueTarget)
                 }
-
                 cond.rhv == zeroValue -> {
                     cond.lhv.accept(this)
-                    elseBranchTarget = falseTarget
                     JumpInsnNode(zeroCmpOpcode, trueTarget)
                 }
-
                 else -> {
                     cond.lhv.accept(this)
                     cond.rhv.accept(this)
-                    elseBranchTarget = falseTarget
                     JumpInsnNode(defaultOpcode, trueTarget)
                 }
             }
         )
-        currentInsnList.add(JumpInsnNode(Opcodes.GOTO, elseBranchTarget))
+        currentInsnList.add(JumpInsnNode(Opcodes.GOTO, falseTarget))
         updateStackInfo(-stackSize)
     }
 

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

@@ -296,7 +296,7 @@ class InstructionsTest : BaseInstructionsTest() {
     }
 
     @Test
-    @Disabled("Unexpected behavior on java 8 and 11")
+    @DisabledOnJre(JRE.JAVA_8, JRE.JAVA_11)
     fun `instance method ref bug`() {
         val clazz = cp.findClass<Close>()
         val javaClazz = testAndLoadClass(clazz)

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

@@ -41,9 +41,9 @@ class KotlinInstructionsTest: BaseInstructionsTest() {
     @Test
     fun `kotlin range test`() = runKotlinTest(Ranges::class.java.name)
 
-//    @Test
-//    fun `kotlin range test 2`() = runKotlinTest(Ranges2::class.java.name)
-//
+    @Test
+    fun `kotlin range test 2`() = runKotlinTest(Ranges2::class.java.name)
+
 //    @Test
 //    fun `kotlin overloading test`() = runKotlinTest(Overloading::class.java.name)
 

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

@@ -26,6 +26,8 @@ import org.jacodb.testing.WithGlobalDB
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.condition.DisabledOnJre
+import org.junit.jupiter.api.condition.JRE
 
 class LoopsTest : BaseTest() {
 
@@ -86,13 +88,17 @@ class LoopsTest : BaseTest() {
         }
     }
 
+    //Disabled on JAVA_8 because of different bytecode and different lineNumbers for loops
     @Test
+    @DisabledOnJre(JRE.JAVA_8)
     fun `combined loops`() {
         val clazz = cp.findClass<JavaTasks>()
         with(clazz.findMethod("sortTimes").loops) {
             assertEquals(3, size)
             with(first()) {
-                Assertions.assertTrue(head.lineNumber == 53 || head.lineNumber == 51)
+                assertEquals(53, head.lineNumber)
+                assertEquals(listOf(53, 61, 73), exits.map { it.lineNumber }.toSet().sorted())
+                assertSources(53, 75)
             }
 
             with(get(1)) {

jacodb-core/src/testFixtures/kotlin/org/jacodb/testing/cfg/Ranges.kt

@@ -72,26 +72,52 @@ class Ranges {
 
 class Ranges2 {
 
-    fun isDigit(a: Int) : String {
-        val aa = ArrayList<Int> ()
-        aa.add(239)
-
-        return when(a) {
-            in aa -> "array list"
+    fun assertDigit(i: Int): String {
+        val res = when (i) {
             in 0..9 -> "digit"
-            !in 0..100 -> "not small"
+            !in 0..100 -> "not small1 $i"
+            else -> "something $i"
+        }
+        if (res == "digit") return "OK"
+        return "fail $res"
+    }
+
+    fun assertDigit2(i: Int): String {
+        val res = when (i) {
+            in 9 downTo 0 -> "digit"
+            !in 0..100 -> "not small2 $i"
             else -> "something"
         }
+        if (res == "digit") return "OK"
+        return "fail $res"
     }
 
-    fun assertDigit(i: Int, expected: String): String {
-        val result = isDigit(i)
-        return if (result == expected) "" else "fail: isDigit($i) = \"$result\""
+    fun assertDigit3(i: Int): String {
+        val res = when (i) {
+            !in 0..9 -> "f1 $i"
+            else -> "d"
+        }
+        if (res == "d") return "OK"
+        return "fail $res"
     }
 
+    fun assertDigit4(i: Int): String {
+        val res = when (i) {
+            !in 9 downTo 0 -> "f2 $i"
+            else -> "d"
+        }
+        if (res == "d") return "OK"
+        return "fail $res"
+    }
+
+
     fun box(): String {
-        val result = assertDigit(0, "digit")
-        if (result == "") return "OK"
-        return result
+        (0..9 step 2).map {
+            assertDigit(it).let { if (it != "OK") return it }
+            assertDigit2(it).let { if (it != "OK") return it }
+            assertDigit3(it).let { if (it != "OK") return it }
+            assertDigit4(it).let { if (it != "OK") return it }
+        }
+        return "OK"
     }
 }