cleanup

Author: MForest7

usvm-ts-dataflow/src/main/kotlin/org/usvm/dataflow/ts/infer/ForwardAnalyzer.kt

@@ -35,24 +35,26 @@ class ForwardAnalyzer(
     }
 
     private val liveVariablesCache = hashMapOf<EtsMethod, LiveVariables>()
-    private fun liveVariables(method: EtsMethod) =
+    private fun liveVariables(method: EtsMethod): LiveVariables =
         liveVariablesCache.computeIfAbsent(method) {
             if (doLiveVariablesAnalysis) LiveVariables.from(method) else AlwaysAlive
         }
 
+    private fun variableIsDying(fact: ForwardTypeDomainFact, stmt: EtsStmt): Boolean {
+        if (fact !is ForwardTypeDomainFact.TypedVariable) return false
+        val base = fact.variable.base
+        if (base !is AccessPathBase.Local) return false
+        return !liveVariables(stmt.method).isAliveAt(base.name, stmt)
+    }
+
     override fun handleNewEdge(edge: Edge<ForwardTypeDomainFact, EtsStmt>): List<AnalyzerEvent> {
         val (startVertex, currentVertex) = edge
         val (current, currentFact) = currentVertex
         val method = graph.methodOf(current)
         val currentIsExit = current in graph.exitPoints(method) ||
             (current is EtsNopStmt && graph.successors(current).none())
 
-        val variableIsDying = (currentFact as? ForwardTypeDomainFact.TypedVariable)?.let {
-            val base = it.variable.base
-            base is AccessPathBase.Local && (!liveVariables(method).isAliveAt(base.name, current))
-        } ?: false
-
-        if (currentIsExit || variableIsDying) {
+        if (currentIsExit || variableIsDying(currentFact, current)) {
             return listOf(
                 ForwardSummaryAnalyzerEvent(
                     method = method,

usvm-ts-dataflow/src/main/kotlin/org/usvm/dataflow/ts/infer/TypeInferenceManager.kt

@@ -344,8 +344,7 @@ class TypeInferenceManager(
             .entries.groupByTo(hashMapOf()) { (method, _) -> method.enclosingClass }
 
         return graph.cp.projectClasses.mapNotNull { cls ->
-            val clsMethods = (cls.methods + cls.ctor).toHashSet()
-            val combinedBackwardType = clsMethods
+            val combinedBackwardType = (cls.methods + cls.ctor)
                 .mapNotNull { methodTypeScheme[it] }
                 .mapNotNull { facts -> facts[AccessPathBase.This] }.reduceOrNull { acc, type ->
                     typeProcessor.intersect(acc, type) ?: run {

usvm-ts-dataflow/src/main/kotlin/org/usvm/dataflow/ts/util/EtsTraits.kt

@@ -27,7 +27,6 @@ import org.jacodb.ets.base.EtsAssignStmt
 import org.jacodb.ets.base.EtsBinaryExpr
 import org.jacodb.ets.base.EtsBooleanConstant
 import org.jacodb.ets.base.EtsCallExpr
-import org.jacodb.ets.base.EtsCallStmt
 import org.jacodb.ets.base.EtsCastExpr
 import org.jacodb.ets.base.EtsClassType
 import org.jacodb.ets.base.EtsConstant
@@ -99,11 +98,7 @@ class EtsTraits : Traits<EtsMethod, EtsStmt> {
     }
 
     override fun getCallExpr(statement: EtsStmt): EtsCallExpr? {
-        return when (statement) {
-            is EtsAssignStmt -> statement.rhv as? EtsCallExpr
-            is EtsCallStmt -> statement.expr
-            else -> null
-        }
+        return statement.callExpr
     }
 
     override fun getValues(expr: CommonExpr): Set<CommonValue> {

usvm-ts-dataflow/src/test/kotlin/org/usvm/dataflow/ts/test/EtsTypeResolverPerformanceTest.kt

@@ -28,8 +28,8 @@ import java.io.File
 @Disabled
 class EtsTypeResolverPerformanceTest {
     companion object {
-        const val WARMUP_ITERATIONS = 0
-        const val TEST_ITERATIONS = 10
+        const val WARMUP_ITERATIONS = 5
+        const val TEST_ITERATIONS = 5
         const val OUTPUT_FILE = "performance_report.md"
 
         @JvmStatic