fix: control structure & path probability insights

Author: BFergerson

insight/src/main/kotlin/spp/jetbrains/insight/InsightExtensions.kt

@@ -34,7 +34,3 @@ fun ArtifactElement.getDuration(includingPredictions: Boolean = true): Long? {
 
     return getUserData(InsightKeys.FUNCTION_DURATION.asPsiKey())?.value
 }
-
-fun ArtifactElement.getPathExecutionProbability(): InsightValue<Double> {
-    return getUserData(InsightKeys.PATH_EXECUTION_PROBABILITY.asPsiKey())!!
-}

insight/src/main/kotlin/spp/jetbrains/insight/InsightKeys.kt

@@ -33,6 +33,7 @@ object InsightKeys {
     val PATH_EXECUTION_PROBABILITY = SourceKey<InsightValue<Double>>(InsightType.PATH_EXECUTION_PROBABILITY.name)
     val PATH_DURATION = SourceKey<InsightValue<Double>>(InsightType.PATH_DURATION.name)
     val RECURSIVE_CALL = SourceKey<InsightValue<Boolean>>(InsightType.RECURSIVE_CALL.name)
+    val CONDITION_EVALUATION = SourceKey<Boolean>("CONDITION_EVALUATION")
 
     val ALL_INSIGHTS: List<SourceKey<out InsightValue<out Any>>> = listOf(
         FUNCTION_DURATION,

insight/src/main/kotlin/spp/jetbrains/insight/ProceduralAnalyzer.kt

@@ -113,6 +113,8 @@ class ProceduralAnalyzer {
 
             if (artifactElement is IfArtifact) {
                 val bool = path.evaluations[boolIndex.getAndIncrement()]
+                artifactElement.data.put(InsightKeys.CONDITION_EVALUATION, bool)
+
                 if (bool) {
                     val childArtifacts = processArtifacts[index + 1] as List<Any>
                     processPath(path, artifactElement.childArtifacts, childArtifacts, boolIndex)

insight/src/main/kotlin/spp/jetbrains/insight/pass/artifact/RandomConditionalPass.kt

@@ -62,9 +62,14 @@ class RandomConditionalPass : ArtifactPass {
 
             else -> 0.0
         }.let { if (it > 1.0) 1.0 else if (it < 0.0) 0.0 else it }
-        ifArtifact.data.put(
-            InsightKeys.CONTROL_STRUCTURE_PROBABILITY,
-            InsightValue(InsightType.CONTROL_STRUCTURE_PROBABILITY, probability)
-        )
+
+        val conditionEvaluation = ifArtifact.getData(InsightKeys.CONDITION_EVALUATION)!!
+        if (conditionEvaluation) {
+            ifArtifact.data[InsightKeys.CONTROL_STRUCTURE_PROBABILITY] =
+                InsightValue(InsightType.CONTROL_STRUCTURE_PROBABILITY, probability)
+        } else {
+            ifArtifact.data[InsightKeys.CONTROL_STRUCTURE_PROBABILITY] =
+                InsightValue(InsightType.CONTROL_STRUCTURE_PROBABILITY, 1 - probability)
+        }
     }
 }

insight/src/main/kotlin/spp/jetbrains/insight/pass/path/PathProbabilityPass.kt

@@ -33,73 +33,56 @@ import spp.protocol.insight.InsightValue
  */
 class PathProbabilityPass : ProceduralPathPass {
 
-    private lateinit var conditionOrder: Iterator<Boolean>
-
     override fun analyze(path: ProceduralPath) {
-        conditionOrder = path.evaluations.iterator()
-
         path.artifacts.forEach {
+            it.data[InsightKeys.PATH_EXECUTION_PROBABILITY] =
+                InsightValue.of(PATH_EXECUTION_PROBABILITY, 1.0)
+
             if (it is IfArtifact) {
-                analyze(it, conditionOrder.next(), 1.0)
-            } else {
-                it.data.put(
-                    InsightKeys.PATH_EXECUTION_PROBABILITY,
-                    InsightValue.of(PATH_EXECUTION_PROBABILITY, 1.0)
-                )
+                analyze(it, it.getData(InsightKeys.CONDITION_EVALUATION)!!, 1.0)
             }
         }
     }
 
     private fun analyze(ifArtifact: IfArtifact, condition: Boolean, probability: Double) {
         val probability = calculateProbability(ifArtifact, probability, condition)
         ifArtifact.childArtifacts.forEach {
+            it.data[InsightKeys.PATH_EXECUTION_PROBABILITY] =
+                InsightValue.of(PATH_EXECUTION_PROBABILITY, probability)
+
             if (it is IfArtifact) {
-                analyze(it, conditionOrder.next(), probability)
-            } else {
-                it.data.put(
-                    InsightKeys.PATH_EXECUTION_PROBABILITY,
-                    InsightValue.of(PATH_EXECUTION_PROBABILITY, probability)
-                )
+                analyze(it, it.getData(InsightKeys.CONDITION_EVALUATION)!!, probability)
             }
         }
     }
 
     private fun calculateProbability(element: ArtifactElement, baseProbability: Double, condition: Boolean): Double {
         var selfProbability = Double.NaN
-        if (element.getUserData(InsightKeys.CONTROL_STRUCTURE_PROBABILITY.asPsiKey()) != null) {
-            selfProbability = element.getUserData(InsightKeys.CONTROL_STRUCTURE_PROBABILITY.asPsiKey())!!.value
-        } else if (element.getData(InsightKeys.CONTROL_STRUCTURE_PROBABILITY) != null) {
+        if (element.getData(InsightKeys.CONTROL_STRUCTURE_PROBABILITY) != null) {
             selfProbability = element.getData(InsightKeys.CONTROL_STRUCTURE_PROBABILITY)!!.value
         }
 
         //see if probability can be determined statically
-        if (element is IfArtifact) {
+        if (element is IfArtifact && selfProbability.isNaN()) {
             val staticProbability = element.getStaticProbability()
             if (!staticProbability.isNaN()) {
                 selfProbability = staticProbability
-            }
-        }
 
-        if (selfProbability.isNaN()) {
-            return baseProbability
-        }
+                //todo: move to getStaticProbability()
+                //flip self probability if condition is false
+                if (!condition) {
+                    selfProbability = 1 - selfProbability
+                }
 
-        //flip self probability if condition is false
-        if (!condition) {
-            selfProbability = 1 - selfProbability
+                element.data[InsightKeys.CONTROL_STRUCTURE_PROBABILITY] =
+                    InsightValue.of(CONTROL_STRUCTURE_PROBABILITY, selfProbability)
+            }
         }
 
-        element.putUserData(
-            InsightKeys.PATH_EXECUTION_PROBABILITY.asPsiKey(),
-            InsightValue.of(PATH_EXECUTION_PROBABILITY, baseProbability)
-        )
-
-        val childProbability = baseProbability * selfProbability
-        element.data.put(
-            InsightKeys.PATH_EXECUTION_PROBABILITY,
-            InsightValue.of(PATH_EXECUTION_PROBABILITY, childProbability)
-        )
-
-        return childProbability
+        return if (selfProbability.isNaN()) {
+            baseProbability
+        } else {
+            baseProbability * selfProbability
+        }
     }
 }

insight/src/main/kotlin/spp/jetbrains/insight/pass/pathset/SimplifyPathSetPass.kt

@@ -16,12 +16,10 @@
  */
 package spp.jetbrains.insight.pass.pathset
 
-import spp.jetbrains.artifact.model.ControlStructureArtifact
 import spp.jetbrains.artifact.model.IfArtifact
 import spp.jetbrains.insight.InsightKeys
 import spp.jetbrains.insight.ProceduralPath
 import spp.jetbrains.insight.pass.ProceduralPathSetPass
-import java.util.*
 
 /**
  * Removes paths caused by conditional branches that are never taken.
@@ -31,33 +29,20 @@ class SimplifyPathSetPass : ProceduralPathSetPass {
     override fun postProcess(pathSet: Set<ProceduralPath>): Set<ProceduralPath> {
         val simplifiedPaths = mutableSetOf<ProceduralPath>()
         for (path in pathSet) {
-            path.artifacts.removeIf {
+            val possiblePath = path.artifacts.all {
                 if (it is IfArtifact) {
-                    val probability = it.getData(InsightKeys.PATH_EXECUTION_PROBABILITY)
-                    probability?.value == 0.0 || it.childArtifacts.isEmpty()
+                    val probability = it.getData(InsightKeys.CONTROL_STRUCTURE_PROBABILITY)
+                    probability?.value != 0.0
                 } else {
-                    false
+                    true
                 }
             }
 
-            if (path.artifacts.isNotEmpty()) {
+            if (possiblePath) {
                 simplifiedPaths.add(path)
             }
         }
 
-        for (path in pathSet.toMutableSet()) {
-            //sublist check
-            val pathArtifacts = path.artifacts
-            val dupePath = simplifiedPaths.any {
-                it !== path && pathArtifacts.none { it is ControlStructureArtifact }
-                        && Collections.indexOfSubList(it.artifacts, pathArtifacts) != -1
-            }
-
-            if (dupePath) {
-                simplifiedPaths.remove(path)
-            }
-        }
-
         return simplifiedPaths
     }
 }

insight/src/main/kotlin/spp/jetbrains/insight/pass/pathset/StaticDfaPathSetPass.kt

@@ -60,7 +60,7 @@ class StaticDfaPathSetPass : ProceduralPathSetPass {
         }
 
         listener.constantConditions.forEach {
-            if (it.key is KotlinAnchor.KotlinExpressionAnchor) {
+            if (it.key is KotlinAnchor.KotlinExpressionAnchor && it.value != ConstantValue.UNKNOWN) {
                 val anchor = it.key as KotlinAnchor.KotlinExpressionAnchor
                 val value = it.value
                 val expression = anchor.expression
@@ -69,15 +69,19 @@ class StaticDfaPathSetPass : ProceduralPathSetPass {
                         if (it is IfArtifact) {
                             if (it.condition?.psiElement == expression) {
                                 val probability = if (value == ConstantValue.TRUE) 1.0 else 0.0
-                                it.data.put(
-                                    InsightKeys.CONTROL_STRUCTURE_PROBABILITY,
-                                    InsightValue.of(InsightType.CONTROL_STRUCTURE_PROBABILITY, probability)
-                                )
+                                val conditionEvaluation = it.getData(InsightKeys.CONDITION_EVALUATION)!!
+                                if (conditionEvaluation) {
+                                    it.data[InsightKeys.CONTROL_STRUCTURE_PROBABILITY] =
+                                        InsightValue(InsightType.CONTROL_STRUCTURE_PROBABILITY, probability)
+                                } else {
+                                    it.data[InsightKeys.CONTROL_STRUCTURE_PROBABILITY] =
+                                        InsightValue(InsightType.CONTROL_STRUCTURE_PROBABILITY, 1 - probability)
+                                }
                             }
                         }
                     }
                 }
-            } else if (it.key is JavaExpressionAnchor) {
+            } else if (it.key is JavaExpressionAnchor && it.value != ConstantValue.UNKNOWN) {
                 val anchor = it.key as JavaExpressionAnchor
                 val value = it.value
                 val expression = anchor.expression
@@ -86,10 +90,14 @@ class StaticDfaPathSetPass : ProceduralPathSetPass {
                         if (it is IfArtifact) {
                             if (it.condition?.psiElement == expression) {
                                 val probability = if (value == ConstantValue.TRUE) 1.0 else 0.0
-                                it.data.put(
-                                    InsightKeys.CONTROL_STRUCTURE_PROBABILITY,
-                                    InsightValue.of(InsightType.CONTROL_STRUCTURE_PROBABILITY, probability)
-                                )
+                                val conditionEvaluation = it.getData(InsightKeys.CONDITION_EVALUATION)!!
+                                if (conditionEvaluation) {
+                                    it.data[InsightKeys.CONTROL_STRUCTURE_PROBABILITY] =
+                                        InsightValue(InsightType.CONTROL_STRUCTURE_PROBABILITY, probability)
+                                } else {
+                                    it.data[InsightKeys.CONTROL_STRUCTURE_PROBABILITY] =
+                                        InsightValue(InsightType.CONTROL_STRUCTURE_PROBABILITY, 1 - probability)
+                                }
                             }
                         }
                     }

insight/src/test/kotlin/spp/jetbrains/insight/BranchProbabilityTest.kt

@@ -20,14 +20,11 @@ import com.intellij.testFramework.TestDataPath
 import com.intellij.testFramework.fixtures.BasePlatformTestCase
 import org.junit.jupiter.api.Test
 import spp.jetbrains.artifact.service.getCalls
-import spp.jetbrains.artifact.service.getChildIfs
 import spp.jetbrains.artifact.service.toArtifact
 import spp.jetbrains.marker.js.JavascriptLanguageProvider
 import spp.jetbrains.marker.jvm.JVMLanguageProvider
 import spp.jetbrains.marker.py.PythonLanguageProvider
 import spp.jetbrains.marker.service.*
-import spp.protocol.insight.InsightType
-import spp.protocol.insight.InsightValue
 
 @TestDataPath("\$CONTENT_ROOT/testData/")
 class BranchProbabilityTest : BasePlatformTestCase() {
@@ -55,23 +52,16 @@ class BranchProbabilityTest : BasePlatformTestCase() {
     private fun doOneFourthProbability(language: String, extension: String) {
         val psi = myFixture.configureByFile("$language/BranchProbability.$extension")
 
-        psi.getChildIfs().forEach {
-            it.putUserData(
-                InsightKeys.CONTROL_STRUCTURE_PROBABILITY.asPsiKey(),
-                InsightValue.of(InsightType.CONTROL_STRUCTURE_PROBABILITY, 0.5)
-            )
-        }
-
         val callExpression = psi.getCalls().find { it.text.contains("true", true) }!!
         val paths = ProceduralAnalyzer().analyzeUp(callExpression.toArtifact()!!)
         assertEquals(1, paths.size)
 
         val path = paths.first()
         assertEquals(4, path.descendants.size)
-        assertEquals(1.0, path.descendants[0].getPathExecutionProbability().value)
-        assertEquals(0.5, path.descendants[0].getData(InsightKeys.PATH_EXECUTION_PROBABILITY)?.value)
-        assertEquals(0.5, path.descendants[1].getPathExecutionProbability().value)
-        assertEquals(0.25, path.descendants[1].getData(InsightKeys.PATH_EXECUTION_PROBABILITY)?.value)
+        assertEquals(1.0, path.descendants[0].getData(InsightKeys.PATH_EXECUTION_PROBABILITY)?.value)
+        assertEquals(0.5, path.descendants[0].getData(InsightKeys.CONTROL_STRUCTURE_PROBABILITY)?.value)
+        assertEquals(0.5, path.descendants[1].getData(InsightKeys.PATH_EXECUTION_PROBABILITY)?.value)
+        assertEquals(0.5, path.descendants[1].getData(InsightKeys.CONTROL_STRUCTURE_PROBABILITY)?.value)
         assertEquals(0.25, path.descendants[2].getData(InsightKeys.PATH_EXECUTION_PROBABILITY)?.value)
     }
 }

insight/src/test/kotlin/spp/jetbrains/insight/InnerBranchProbabilityTest.kt

@@ -62,6 +62,7 @@ class InnerBranchProbabilityTest : BasePlatformTestCase() {
         val falsePath = ProceduralAnalyzer().apply {
             passProvider = InsightPassProvider.FULL_NO_SIMPLIFY
         }.analyzeUp(callExpression2.toArtifact()!!)
-        assertEquals(0.0, falsePath.first().artifacts.last().getData(InsightKeys.PATH_EXECUTION_PROBABILITY)?.value)
+        assertEquals(1.0, falsePath.first().artifacts.last().getData(InsightKeys.PATH_EXECUTION_PROBABILITY)?.value)
+        assertEquals(0.0, falsePath.first().artifacts.last().getData(InsightKeys.CONTROL_STRUCTURE_PROBABILITY)?.value)
     }
 }

insight/src/test/kotlin/spp/jetbrains/insight/pass/artifact/RandomConditionalPassTest.kt

@@ -55,9 +55,16 @@ class RandomConditionalPassTest : BasePlatformTestCase() {
     private fun doTest(language: String, extension: String) {
         val psi = myFixture.configureByFile("$language/RandomConditional.$extension")
         val paths = ProceduralAnalyzer().analyze(psi.getFunctions().first().toArtifact()!!)
-        assertEquals(1, paths.size)
+        assertEquals(2, paths.size)
 
-        val ifArtifact = paths.first().artifacts.first() as IfArtifact
-        assertEquals(0.26, ifArtifact.getData(InsightKeys.CONTROL_STRUCTURE_PROBABILITY)!!.value)
+        val falsePath = paths.first { !it.conditions.first().first }
+        val ifArtifactFalse = falsePath.artifacts.first() as IfArtifact
+        assertEquals(1.0, ifArtifactFalse.getData(InsightKeys.PATH_EXECUTION_PROBABILITY)!!.value)
+        assertEquals(0.74, ifArtifactFalse.getData(InsightKeys.CONTROL_STRUCTURE_PROBABILITY)!!.value)
+
+        val truePath = paths.first { it.conditions.first().first }
+        val ifArtifactTrue = truePath.artifacts.first() as IfArtifact
+        assertEquals(1.0, ifArtifactTrue.getData(InsightKeys.PATH_EXECUTION_PROBABILITY)!!.value)
+        assertEquals(0.26, ifArtifactTrue.getData(InsightKeys.CONTROL_STRUCTURE_PROBABILITY)!!.value)
     }
 }