cleanup

Author: MForest7

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

@@ -37,10 +37,7 @@ class ForwardAnalyzer(
     private val liveVariablesCache = hashMapOf<EtsMethod, LiveVariables>()
     private fun liveVariables(method: EtsMethod) =
         liveVariablesCache.computeIfAbsent(method) {
-            if (doLiveVariablesAnalysis)
-                LiveVariables.from(method)
-            else
-                AlwaysAlive
+            if (doLiveVariablesAnalysis) LiveVariables.from(method) else AlwaysAlive
         }
 
     override fun handleNewEdge(edge: Edge<ForwardTypeDomainFact, EtsStmt>): List<AnalyzerEvent> {

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

@@ -56,20 +56,22 @@ class ForwardFlowFunctions(
     private val aliasesCache: MutableMap<EtsMethod, List<StmtAliasInfo>> = hashMapOf()
     private fun getAliases(method: EtsMethod): List<StmtAliasInfo> {
         return aliasesCache.computeIfAbsent(method) {
-            if (doAliasAnalysis)
+            if (doAliasAnalysis) {
                 MethodAliasInfoImpl(method).computeAliases()
-            else
+            } else {
                 NoMethodAliasInfo(method).computeAliases()
+            }
         }
     }
 
     private val liveVariablesCache = hashMapOf<EtsMethod, LiveVariables>()
     private fun liveVariables(method: EtsMethod) =
         liveVariablesCache.computeIfAbsent(method) {
-            if (doLiveVariablesAnalysis)
+            if (doLiveVariablesAnalysis) {
                 LiveVariables.from(method)
-            else
+            } else {
                 AlwaysAlive
+            }
         }
 
     override fun obtainPossibleStartFacts(method: EtsMethod): Collection<ForwardTypeDomainFact> {
@@ -170,7 +172,7 @@ class ForwardFlowFunctions(
                 sequentFact(current, fact).myFilter()
                     .filter {
                         when (val base = it.variable.base) {
-                            is AccessPathBase.Local -> liveVars.isAliveAt(base.name, current) //|| liveVars.isAliveAt(base.name, next)
+                            is AccessPathBase.Local -> liveVars.isAliveAt(base.name, current)
                             else -> true
                         }
                     }
@@ -372,20 +374,27 @@ class ForwardFlowFunctions(
                 //       Using the cast type directly is just a temporary solution to satisfy simple tests.
                 if (current.rhv is EtsCastExpr) {
                     val path = AccessPath(lhv.base, fact.variable.accesses)
-                    // val type = EtsTypeFact.from((current.rhv as EtsCastExpr).type).intersect(fact.type) ?: fact.type
                     val type = EtsTypeFact.from((current.rhv as EtsCastExpr).type)
+
                     return listOf(fact, TypedVariable(path, type))
                 } else if (current.rhv is EtsAwaitExpr) {
                     val path = AccessPath(lhv.base, fact.variable.accesses)
                     val promiseType = fact.type
+
                     if (promiseType is EtsTypeFact.ObjectEtsTypeFact) {
                         val promiseClass = promiseType.cls
+
                         if (promiseClass is EtsClassType && promiseClass.signature.name == "Promise") {
-                            val type = EtsTypeFact.from(promiseClass.typeParameters.singleOrNull() ?: return listOf(fact))
+                            val type = EtsTypeFact.from(
+                                type = promiseClass.typeParameters.singleOrNull() ?: return listOf(fact)
+                            )
                             return listOf(fact, TypedVariable(path, type))
                         }
+
                         if (promiseClass is EtsUnclearRefType && promiseClass.name.startsWith("Promise")) {
-                            val type = EtsTypeFact.from(promiseClass.typeParameters.singleOrNull() ?: return listOf(fact))
+                            val type = EtsTypeFact.from(
+                                type = promiseClass.typeParameters.singleOrNull() ?: return listOf(fact)
+                            )
                             return listOf(fact, TypedVariable(path, type))
                         }
                     }

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

@@ -29,9 +29,7 @@ interface LiveVariables {
         private const val THRESHOLD: Int = 20
 
         fun from(method: EtsMethod): LiveVariables =
-            if (method.cfg.stmts.size > THRESHOLD)
-                LiveVariablesImpl(method)
-            else AlwaysAlive
+            if (method.cfg.stmts.size > THRESHOLD) LiveVariablesImpl(method) else AlwaysAlive
     }
 }
 
@@ -40,7 +38,7 @@ object AlwaysAlive : LiveVariables {
 }
 
 class LiveVariablesImpl(
-    val method: EtsMethod
+    val method: EtsMethod,
 ) : LiveVariables {
     companion object {
         private fun EtsEntity.used(): List<String> = when (this) {

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

@@ -12,7 +12,6 @@ import kotlinx.coroutines.newSingleThreadContext
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withTimeout
 import mu.KotlinLogging
-import org.jacodb.ets.base.ANONYMOUS_CLASS_PREFIX
 import org.jacodb.ets.base.CONSTRUCTOR_NAME
 import org.jacodb.ets.base.EtsReturnStmt
 import org.jacodb.ets.base.EtsStmt
@@ -193,7 +192,8 @@ class TypeInferenceManager(
             typeInfo,
             doAddKnownTypes,
             doAliasAnalysis = true,
-            doLiveVariablesAnalysis = true)
+            doLiveVariablesAnalysis = true,
+        )
 
         val forwardRunner = UniRunner(
             traits = traits,

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

@@ -76,13 +76,14 @@ class EtsTypeResolverPerformanceTest {
             )
         )
 
-        val file = File(OUTPUT_FILE)
-        file.writeText(buildString {
+        val reportStr = buildString {
             appendLine("|project|min time|max time|avg time|median time|%|")
             appendLine("|:--|:--|:--|:--|:--|:--|")
             reports.forEach {
                 appendLine(it.dumpToString())
             }
-        })
+        }
+        val file = File(OUTPUT_FILE)
+        file.writeText(reportStr)
     }
 }

usvm-ts-dataflow/src/test/kotlin/org/usvm/dataflow/ts/test/utils/PerformanceReport.kt

@@ -48,7 +48,7 @@ fun generateReportForProject(
     projectId: String,
     abcPath: String,
     warmupIterationsCount: Int,
-    runIterationsCount: Int
+    runIterationsCount: Int,
 ): PerformanceReport {
     val abcScene = AbcProjects.getAbcProject(abcPath)