fix: improper caching in JcTestVisitor inheritors (UnitTestBot#17)

* fix: improper caching in JcTestVisitor inheritors

* sytle fixes

Author: petrukhinandrew

usvm-jvm-rendering/src/main/kotlin/org/usvm/jvm/rendering/testRenderer/JcTestRenderer.kt

@@ -14,6 +14,7 @@ import org.usvm.test.api.UTestConstExpression
 import org.usvm.test.api.UTestExpression
 import java.util.IdentityHashMap
 import org.jacodb.api.jvm.JcClasspath
+import org.usvm.test.api.UTestInst
 
 open class JcTestRenderer(
     private val test: UTest,
@@ -53,14 +54,15 @@ open class JcTestRenderer(
 
     inner class JcExprUsageVisitor: JcTestVisitor() {
 
-        private val exprCache: MutableSet<UTestExpression> = Collections.newSetFromMap(IdentityHashMap())
+        private fun shouldDeclareVarCheck(expr: UTestExpression): Boolean {
+            return !preventVarDeclarationOf(expr) && isVisited(expr) || requireVarDeclarationOf(expr)
+        }
 
-        override fun visit(expr: UTestExpression) {
-            if (!preventVarDeclarationOf(expr) && !exprCache.add(expr) || requireVarDeclarationOf(expr))
-                // Multiple usage of expression
-                shouldDeclareVar.add(expr)
+        override fun visit(inst: UTestInst) {
+            if (inst is UTestExpression && shouldDeclareVarCheck(inst))
+                shouldDeclareVar.add(inst)
 
-            super.visit(expr)
+            super.visit(inst)
         }
     }
 

usvm-jvm-rendering/src/main/kotlin/org/usvm/jvm/rendering/testRenderer/JcTestVisitor.kt

@@ -41,11 +41,13 @@ open class JcTestVisitor {
 
     private val cache: MutableSet<UTestInst> = Collections.newSetFromMap<UTestInst>(IdentityHashMap())
 
+    protected fun isVisited(inst: UTestInst) = cache.contains(inst)
+
     fun visit(test: UTest) {
         for (inst in test.initStatements)
             visit(inst)
 
-        visitCall(test.callMethodExpression)
+        visit(test.callMethodExpression as UTestInst)
     }
 
     open fun visit(inst: UTestInst) {

usvm-jvm-rendering/src/main/kotlin/org/usvm/jvm/rendering/testTransformers/JcDeadCodeTransformer.kt

@@ -17,13 +17,14 @@ import org.usvm.test.api.UTestStatement
 class JcDeadCodeTransformer: JcTestTransformer() {
     private val roots: MutableSet<UTestExpression> = Collections.newSetFromMap(IdentityHashMap())
     private val reachable: MutableSet<UTestExpression> = Collections.newSetFromMap(IdentityHashMap())
-    private lateinit var rootFetcher: ReachabilityRootFetcher
+
+    private val rootFetcher get() = ReachabilityRootFetcher(roots)
+
     private class ReachabilityRootFetcher(val roots: MutableSet<UTestExpression>): JcTestVisitor() {
         val fetched: MutableSet<UTestExpression> = Collections.newSetFromMap(IdentityHashMap())
 
         fun fetchFrom(expr: UTestExpression): MutableSet<UTestExpression> = fetchFrom(listOf(expr))
         fun fetchFrom(exprs: List<UTestExpression>): MutableSet<UTestExpression> {
-            fetched.clear()
 
             for (expr in exprs) {
                 visitExpr(expr)
@@ -42,31 +43,14 @@ class JcDeadCodeTransformer: JcTestTransformer() {
     }
 
     private class ReachabilityCollector(
-        val test: UTest,
         val roots: MutableSet<UTestExpression>,
         val reachable: MutableSet<UTestExpression>
     ) : JcTestVisitor() {
         private var marker = false
 
-        fun prepareRootFetcher(): ReachabilityRootFetcher {
-            super.visit(test)
-            propagateWhilePossible(test)
-            return ReachabilityRootFetcher(roots)
-        }
-
-        private fun propagateWhilePossible(test: UTest) {
-            val clone: MutableSet<UTestExpression> = Collections.newSetFromMap(IdentityHashMap())
-
-            do {
-                clone.clear()
-                clone.addAll(reachable)
-                check(clone.size == reachable.size)
-                (test.initStatements + test.callMethodExpression).forEach { inst ->
-                    marker = false
-                    visit(inst)
-                }
-
-            } while (clone.size != reachable.size)
+        override fun visit(inst: UTestInst) {
+            marker = false
+            super.visit(inst)
         }
 
         override fun visit(stmt: UTestSetStaticFieldStatement) {
@@ -140,8 +124,10 @@ class JcDeadCodeTransformer: JcTestTransformer() {
     }
 
     override fun transform(test: UTest): UTest {
+        roots.clear()
+        reachable.clear()
 
-        rootFetcher = ReachabilityCollector(test, roots, reachable).prepareRootFetcher()
+        propagateReachabilityIn(test)
 
         val filteredInitInstList = test.initStatements.flatMap {
             transformInstProxy(it)
@@ -152,6 +138,17 @@ class JcDeadCodeTransformer: JcTestTransformer() {
         return UTest(filteredInitInstList, callMethodExpression)
     }
 
+    private fun propagateReachabilityIn(test: UTest) {
+        val clone: MutableSet<UTestExpression> = Collections.newSetFromMap(IdentityHashMap())
+
+        do {
+            clone.clear()
+            clone.addAll(reachable)
+            check(clone.size == reachable.size)
+            ReachabilityCollector(roots, reachable).visit(test)
+        } while (clone.size != reachable.size)
+    }
+
     private fun transformExprs(expr: UTestExpression): List<UTestInst?>{
         if (expr in reachable)
             return listOf(expr)