feat(analyzer): Introduce call resolution success fact propagation

core/opentaint-dataflow-core/opentaint-dataflow/src/main/kotlin/org/opentaint/dataflow/ap/ifds/MethodAnalyzerEdgeSearcher.kt

@@ -6,6 +6,7 @@ import org.opentaint.dataflow.ap.ifds.access.InitialFactAp
 import org.opentaint.dataflow.ap.ifds.analysis.AnalysisManager
 import org.opentaint.dataflow.ap.ifds.analysis.MethodAnalysisContext
 import org.opentaint.dataflow.ap.ifds.trace.MethodCallPrecondition.CallPrecondition
+import org.opentaint.dataflow.ap.ifds.trace.MethodCallPrecondition.CallPreconditionFact
 import org.opentaint.dataflow.ap.ifds.trace.MethodCallPrecondition.PreconditionFactsForInitialFact
 import org.opentaint.dataflow.ap.ifds.trace.MethodSequentPrecondition.SequentPrecondition
 import org.opentaint.dataflow.ap.ifds.trace.MethodSequentPrecondition.SequentPreconditionFacts

core/opentaint-dataflow-core/opentaint-dataflow/src/main/kotlin/org/opentaint/dataflow/ap/ifds/SummaryEdgeSubscription.kt

@@ -86,7 +86,7 @@ class SummaryEdgeSubscriptionManager(
         val calleeInitialFactAp = addedSubscription.callerPathEdge.factAp.rebase(addedSubscription.calleeInitialFactBase)
         val summaries = manager.findFactSummaryEdges(methodEntryPoint, calleeInitialFactAp)
 
-        val sub = ZeroToFactSub(addedSubscription.callerPathEdge, addedSubscription.calleeInitialFactBase)
+        val sub = ZeroToFactSub(addedSubscription.callerPathEdge)
 
         if (summaries.isNotEmpty()) {
             callerAnalyzer.handleZeroToFactMethodSummaryEdge(listOf(sub), summaries)
@@ -101,6 +101,7 @@ class SummaryEdgeSubscriptionManager(
         if (sideEffectSummaries.isNotEmpty()) {
             callerAnalyzer.handleZeroToFactMethodSideEffectSummary(
                 listOf(sub),
+                methodEntryPoint,
                 sideEffectSummaries
             )
         }
@@ -121,7 +122,7 @@ class SummaryEdgeSubscriptionManager(
         val calleeInitialFactAp = addedSubscription.callerPathEdge.factAp.rebase(addedSubscription.calleeInitialFactBase)
         val summaries = manager.findFactSummaryEdges(methodEntryPoint, calleeInitialFactAp)
 
-        val sub = FactToFactSub(addedSubscription.callerPathEdge, addedSubscription.calleeInitialFactBase)
+        val sub = FactToFactSub(addedSubscription.callerPathEdge)
 
         if (summaries.isNotEmpty()) {
             callerAnalyzer.handleFactToFactMethodSummaryEdge(listOf(sub), summaries)
@@ -136,7 +137,7 @@ class SummaryEdgeSubscriptionManager(
         if (sideEffectRequirements.isNotEmpty()) {
             callerAnalyzer.handleMethodSideEffectRequirement(
                 addedSubscription.callerPathEdge,
-                addedSubscription.calleeInitialFactBase,
+                methodEntryPoint,
                 sideEffectRequirements
             )
         }
@@ -145,6 +146,7 @@ class SummaryEdgeSubscriptionManager(
         if (sideEffectSummaries.isNotEmpty()) {
             callerAnalyzer.handleFactToFactMethodSideEffectSummary(
                 listOf(sub),
+                methodEntryPoint,
                 sideEffectSummaries
             )
         }
@@ -165,7 +167,7 @@ class SummaryEdgeSubscriptionManager(
         val calleeInitialFactAp = addedSubscription.callerPathEdge.factAp.rebase(addedSubscription.calleeInitialFactBase)
         val summaries = manager.findFactSummaryEdges(methodEntryPoint, calleeInitialFactAp)
 
-        val sub = NDFactToFactSub(addedSubscription.callerPathEdge, addedSubscription.calleeInitialFactBase)
+        val sub = NDFactToFactSub(addedSubscription.callerPathEdge)
 
         if (summaries.isNotEmpty()) {
             callerAnalyzer.handleNDFactToFactMethodSummaryEdge(listOf(sub), summaries)
@@ -568,7 +570,7 @@ class SummaryEdgeSubscriptionManager(
         ) {
             subscriptionStorage.findFactEdgeSub(summaryInitialFact).forEach { (ep, subscriptions) ->
                 val summarySubs = subscriptions.mapTo(mutableListOf()) {
-                    FactToFactSub(it.callerPathEdge, it.calleeInitialFactBase)
+                    FactToFactSub(it.callerPathEdge)
                 }
 
                 if (summarySubs.isEmpty()) return@forEach
@@ -579,7 +581,7 @@ class SummaryEdgeSubscriptionManager(
 
             subscriptionStorage.findZeroEdgeSub(summaryInitialFact).forEach { (ep, subscriptions) ->
                 val summarySubs = subscriptions.mapTo(mutableListOf()) {
-                    ZeroToFactSub(it.callerPathEdge, it.calleeInitialFactBase)
+                    ZeroToFactSub(it.callerPathEdge)
                 }
 
                 if (summarySubs.isEmpty()) return@forEach
@@ -590,7 +592,7 @@ class SummaryEdgeSubscriptionManager(
 
             subscriptionStorage.findFactNDEdgeSub(summaryInitialFact).forEach { (ep, subscriptions) ->
                 val summarySubs = subscriptions.mapTo(mutableListOf()) {
-                    NDFactToFactSub(it.callerPathEdge, it.calleeInitialFactBase)
+                    NDFactToFactSub(it.callerPathEdge)
                 }
 
                 if (summarySubs.isEmpty()) return@forEach
@@ -634,7 +636,8 @@ class SummaryEdgeSubscriptionManager(
                     val analyzer = processingCtx.getMethodAnalyzer(ep)
                     for (subscription in subscriptions) {
                         analyzer.handleMethodSideEffectRequirement(
-                            subscription.callerPathEdge, subscription.calleeInitialFactBase,
+                            subscription.callerPathEdge,
+                            methodEntryPoint,
                             listOf(sideEffectRequirement)
                         )
                     }
@@ -695,24 +698,24 @@ class SummaryEdgeSubscriptionManager(
         ) {
             subscriptionStorage.findFactEdgeSub(seInitialFact).forEach { (ep, subscriptions) ->
                 val summarySubs = subscriptions.mapTo(mutableListOf()) {
-                    FactToFactSub(it.callerPathEdge, it.calleeInitialFactBase)
+                    FactToFactSub(it.callerPathEdge)
                 }
 
                 if (summarySubs.isEmpty()) return@forEach
 
                 val analyzer = processingCtx.getMethodAnalyzer(ep)
-                analyzer.handleFactToFactMethodSideEffectSummary(summarySubs, sideEffects)
+                analyzer.handleFactToFactMethodSideEffectSummary(summarySubs, methodEntryPoint, sideEffects)
             }
 
             subscriptionStorage.findZeroEdgeSub(seInitialFact).forEach { (ep, subscriptions) ->
                 val summarySubs = subscriptions.mapTo(mutableListOf()) {
-                    ZeroToFactSub(it.callerPathEdge, it.calleeInitialFactBase)
+                    ZeroToFactSub(it.callerPathEdge)
                 }
 
                 if (summarySubs.isEmpty()) return@forEach
 
                 val analyzer = processingCtx.getMethodAnalyzer(ep)
-                analyzer.handleZeroToFactMethodSideEffectSummary(summarySubs, sideEffects)
+                analyzer.handleZeroToFactMethodSideEffectSummary(summarySubs, methodEntryPoint, sideEffects)
             }
         }
     }

core/opentaint-dataflow-core/opentaint-dataflow/src/main/kotlin/org/opentaint/dataflow/ap/ifds/TaintAnalysisUnitRunner.kt

@@ -506,11 +506,12 @@ class TaintAnalysisUnitRunner(
     fun resolveCalleeFact(
         methodEntryPoint: MethodEntryPoint,
         statement: CommonInst,
-        factAp: FinalFactAp
+        factAp: FinalFactAp,
+        callee: MethodEntryPoint,
     ): Set<FinalFactAp> {
         val methodRunners = methodAnalyzers(methodEntryPoint)
         val runner = methodRunners.getAnalyzer(methodEntryPoint)
-        return runner.resolveCalleeFact(statement, factAp)
+        return runner.resolveCalleeFact(statement, factAp, callee)
     }
 
     companion object {

core/opentaint-dataflow-core/opentaint-dataflow/src/main/kotlin/org/opentaint/dataflow/ap/ifds/analysis/AnalysisManager.kt

@@ -10,6 +10,7 @@ import org.opentaint.dataflow.ap.ifds.TaintAnalysisUnitRunner
 import org.opentaint.dataflow.ap.ifds.access.ApManager
 import org.opentaint.dataflow.ap.ifds.access.FinalFactAp
 import org.opentaint.dataflow.ap.ifds.trace.MethodCallPrecondition
+import org.opentaint.dataflow.ap.ifds.trace.MethodCallSummaryPrecondition
 import org.opentaint.dataflow.ap.ifds.trace.MethodSequentPrecondition
 import org.opentaint.dataflow.ap.ifds.trace.MethodStartPrecondition
 import org.opentaint.dataflow.graph.MethodInstGraph
@@ -90,6 +91,12 @@ interface AnalysisManager: LanguageManager {
         statement: CommonInst,
     ): MethodCallSummaryHandler
 
+    fun getMethodCallSummaryPrecondition(
+        apManager: ApManager,
+        analysisContext: MethodAnalysisContext,
+        statement: CommonInst,
+    ): MethodCallSummaryPrecondition
+
     fun getMethodSideEffectSummaryHandler(
         apManager: ApManager,
         analysisContext: MethodAnalysisContext,

core/opentaint-dataflow-core/opentaint-dataflow/src/main/kotlin/org/opentaint/dataflow/ap/ifds/analysis/MethodAnalysisContext.kt

@@ -4,7 +4,4 @@ import org.opentaint.dataflow.ap.ifds.MethodEntryPoint
 
 interface MethodAnalysisContext {
     val methodEntryPoint: MethodEntryPoint
-
-    // todo: remove, required for trace generation
-    val methodCallFactMapper: MethodCallFactMapper
 }

core/opentaint-dataflow-core/opentaint-dataflow/src/main/kotlin/org/opentaint/dataflow/ap/ifds/analysis/MethodCallFlowFunction.kt

@@ -2,6 +2,7 @@ package org.opentaint.dataflow.ap.ifds.analysis
 
 import org.opentaint.dataflow.ap.ifds.AccessPathBase
 import org.opentaint.dataflow.ap.ifds.ExclusionSet
+import org.opentaint.dataflow.ap.ifds.MethodWithContext
 import org.opentaint.dataflow.ap.ifds.SideEffectKind
 import org.opentaint.dataflow.ap.ifds.access.FinalFactAp
 import org.opentaint.dataflow.ap.ifds.access.InitialFactAp
@@ -26,53 +27,59 @@ interface MethodCallFlowFunction {
 
     sealed interface NDFactCallFailureFact: NDFactCallFact
 
+    sealed interface ZeroCallSuccessFact
+
+    sealed interface FactCallSuccessFact
+
+    sealed interface NDFactCallSuccessFact
+
     data object Unchanged : ZeroCallFact, FactCallFact, NDFactCallFact
 
-    data object CallToReturnZeroFact: ZeroCallFact, Call2ReturnFact, ZeroCallFailureFact
+    data object CallToReturnZeroFact: ZeroCallFact, Call2ReturnFact, ZeroCallFailureFact, ZeroCallSuccessFact
 
-    data object CallToStartZeroFact : ZeroCallFact
+    data object CallToStartZeroFact : ZeroCallFact, ZeroCallSuccessFact
 
     data class CallToReturnFFact(
         val initialFactAp: InitialFactAp,
         val factAp: FinalFactAp,
         val traceInfo: TraceInfo?,
-    ) : FactCallFact, ZeroCallFact, Call2ReturnFact, FactCallFailureFact, ZeroCallFailureFact
+    ) : FactCallFact, ZeroCallFact, Call2ReturnFact, FactCallFailureFact, ZeroCallFailureFact, ZeroCallSuccessFact, FactCallSuccessFact
 
     data class CallToStartFFact(
         val initialFactAp: InitialFactAp,
         val callerFactAp: FinalFactAp,
         val startFactBase: AccessPathBase,
         val traceInfo: TraceInfo?,
-    ) : FactCallFact
+    ) : FactCallFact, FactCallSuccessFact
 
     data class CallToReturnZFact(
         val factAp: FinalFactAp,
         val traceInfo: TraceInfo?,
-    ) : ZeroCallFact, FactCallFact, NDFactCallFact, Call2ReturnFact, ZeroCallFailureFact, FactCallFailureFact, NDFactCallFailureFact
+    ) : ZeroCallFact, FactCallFact, NDFactCallFact, Call2ReturnFact, ZeroCallFailureFact, FactCallFailureFact, NDFactCallFailureFact, ZeroCallSuccessFact, FactCallSuccessFact, NDFactCallSuccessFact
 
     data class CallToStartZFact(
         val callerFactAp: FinalFactAp,
         val startFactBase: AccessPathBase,
         val traceInfo: TraceInfo?,
-    ) : ZeroCallFact
+    ) : ZeroCallFact, ZeroCallSuccessFact
 
     data class CallToReturnNonDistributiveFact(
         val initialFacts: Set<InitialFactAp>,
         val factAp: FinalFactAp,
         val traceInfo: TraceInfo?,
-    ) : FactCallFact, ZeroCallFact, NDFactCallFact, Call2ReturnFact, FactCallFailureFact, ZeroCallFailureFact, NDFactCallFailureFact
+    ) : FactCallFact, ZeroCallFact, NDFactCallFact, Call2ReturnFact, FactCallFailureFact, ZeroCallFailureFact, NDFactCallFailureFact, ZeroCallSuccessFact, FactCallSuccessFact, NDFactCallSuccessFact
 
     data class CallToStartNDFFact(
         val initialFacts: Set<InitialFactAp>,
         val callerFactAp: FinalFactAp,
         val startFactBase: AccessPathBase,
         val traceInfo: TraceInfo?,
-    ) : NDFactCallFact
+    ) : NDFactCallFact, NDFactCallSuccessFact
 
-    data class SideEffectRequirement(val initialFactAp: InitialFactAp) : FactCallFact, FactCallFailureFact
+    data class SideEffectRequirement(val initialFactAp: InitialFactAp) : FactCallFact, FactCallFailureFact, FactCallSuccessFact
 
     data class ZeroSideEffect(val kind: SideEffectKind) : ZeroCallFact, ZeroCallFailureFact
-    data class FactSideEffect(val initialFactAp: InitialFactAp, val kind: SideEffectKind) : FactCallFact, FactCallFailureFact
+    data class FactSideEffect(val initialFactAp: InitialFactAp, val kind: SideEffectKind) : FactCallFact, FactCallFailureFact, FactCallSuccessFact
 
     data class Drop(
         val traceInfo: TraceInfo?,
@@ -93,6 +100,11 @@ interface MethodCallFlowFunction {
     fun propagateFactToFactResolutionFailure(initialFactAp: InitialFactAp, currentFactAp: FinalFactAp, startFactBase: AccessPathBase): Set<FactCallFailureFact>
     fun propagateNDFactToFactResolutionFailure(initialFacts: Set<InitialFactAp>, currentFactAp: FinalFactAp, startFactBase: AccessPathBase): Set<NDFactCallFailureFact>
 
+    fun propagateZeroToZeroResolutionSuccess(method: MethodWithContext): Set<ZeroCallSuccessFact>
+    fun propagateZeroToFactResolutionSuccess(currentFactAp: FinalFactAp, startFactBase: AccessPathBase, method: MethodWithContext): Set<ZeroCallSuccessFact>
+    fun propagateFactToFactResolutionSuccess(initialFactAp: InitialFactAp, currentFactAp: FinalFactAp, startFactBase: AccessPathBase, method: MethodWithContext): Set<FactCallSuccessFact>
+    fun propagateNDFactToFactResolutionSuccess(initialFacts: Set<InitialFactAp>, currentFactAp: FinalFactAp, startFactBase: AccessPathBase, method: MethodWithContext): Set<NDFactCallSuccessFact>
+
     interface Default : MethodCallFlowFunction {
         override fun propagateZeroToFact(currentFactAp: FinalFactAp) = buildSet {
             propagateFact(
@@ -187,6 +199,7 @@ interface MethodCallFlowFunction {
         override fun propagateZeroToFactResolutionFailure(currentFactAp: FinalFactAp, startFactBase: AccessPathBase) = buildSet {
             propagateUnresolvedCallFact(
                 factAp = currentFactAp,
+                startFactBase = startFactBase,
                 addSideEffectRequirement = { factReader ->
                     check(!factReader.hasRefinement) { "Can't refine Zero fact" }
                 },
@@ -204,6 +217,7 @@ interface MethodCallFlowFunction {
         ): Set<FactCallFailureFact> = buildSet {
             propagateUnresolvedCallFact(
                 factAp = currentFactAp,
+                startFactBase = startFactBase,
                 addSideEffectRequirement = { factReader ->
                     this += SideEffectRequirement(factReader.refineFact(initialFactAp.replaceExclusions(ExclusionSet.Empty)))
                 },
@@ -224,6 +238,7 @@ interface MethodCallFlowFunction {
         ) = buildSet {
             propagateUnresolvedCallFact(
                 factAp = currentFactAp,
+                startFactBase = startFactBase,
                 addSideEffectRequirement = { factReader ->
                     check(!factReader.hasRefinement) { "Can't refine NDF2F edge" }
                 },
@@ -234,6 +249,92 @@ interface MethodCallFlowFunction {
             )
         }
 
+        override fun propagateZeroToZeroResolutionSuccess(method: MethodWithContext): Set<ZeroCallSuccessFact> =
+            setOf(CallToStartZeroFact)
+
+        override fun propagateZeroToFactResolutionSuccess(
+            currentFactAp: FinalFactAp,
+            startFactBase: AccessPathBase,
+            method: MethodWithContext,
+        ): Set<ZeroCallSuccessFact> = buildSet {
+            propagateSuccessCallFact(
+                factAp = currentFactAp,
+                startFactBase = startFactBase,
+                method = method,
+                addSideEffectRequirement = { factReader ->
+                    check(!factReader.hasRefinement) { "Can't refine Zero fact" }
+                },
+                addCallToReturn = { factReader, factAp, trace ->
+                    check(!factReader.hasRefinement) { "Can't refine Zero fact" }
+                    this += CallToReturnZFact(factAp, trace)
+                },
+                addCallToStart = { callerFactAp, startFactBase, trace ->
+                    this += CallToStartZFact(callerFactAp, startFactBase, trace)
+                },
+                addUnchecked = {
+                    check(it is ZeroCallSuccessFact) { "unexpected" }
+                    this += it
+                },
+            )
+        }
+
+        override fun propagateFactToFactResolutionSuccess(
+            initialFactAp: InitialFactAp,
+            currentFactAp: FinalFactAp,
+            startFactBase: AccessPathBase,
+            method: MethodWithContext,
+        ): Set<FactCallSuccessFact> = buildSet {
+            propagateSuccessCallFact(
+                factAp = currentFactAp,
+                startFactBase = startFactBase,
+                method = method,
+                addSideEffectRequirement = { factReader ->
+                    this += SideEffectRequirement(factReader.refineFact(initialFactAp.replaceExclusions(ExclusionSet.Empty)))
+                },
+                addCallToReturn = { factReader, factAp, trace ->
+                    this += CallToReturnFFact(
+                        factReader.refineFact(initialFactAp),
+                        factReader.refineFact(factAp),
+                        trace
+                    )
+                },
+                addCallToStart = { callerFactAp, startFactBase, trace ->
+                    this += CallToStartFFact(initialFactAp, callerFactAp, startFactBase, trace)
+                },
+                addUnchecked = {
+                    check(it is FactCallSuccessFact) { "unexpected" }
+                    this += it
+                },
+            )
+        }
+
+        override fun propagateNDFactToFactResolutionSuccess(
+            initialFacts: Set<InitialFactAp>,
+            currentFactAp: FinalFactAp,
+            startFactBase: AccessPathBase,
+            method: MethodWithContext,
+        ): Set<NDFactCallSuccessFact> = buildSet {
+            propagateSuccessCallFact(
+                factAp = currentFactAp,
+                startFactBase = startFactBase,
+                method = method,
+                addSideEffectRequirement = { factReader ->
+                    check(!factReader.hasRefinement) { "Can't refine NDF2F edge" }
+                },
+                addCallToReturn = { factReader, factAp, trace ->
+                    check(!factReader.hasRefinement) { "Can't refine NDF2F edge" }
+                    this += CallToReturnNonDistributiveFact(initialFacts, factAp, trace)
+                },
+                addCallToStart = { callerFactAp, startFactBase, trace ->
+                    this += CallToStartNDFFact(initialFacts, callerFactAp, startFactBase, trace)
+                },
+                addUnchecked = {
+                    check(it is NDFactCallSuccessFact) { "unexpected" }
+                    this += it
+                },
+            )
+        }
+
         fun propagateFact(
             initialFacts: Set<InitialFactAp>,
             exclusion: ExclusionSet,
@@ -247,8 +348,19 @@ interface MethodCallFlowFunction {
 
         fun propagateUnresolvedCallFact(
             factAp: FinalFactAp,
+            startFactBase: AccessPathBase,
             addCallToReturn: (FinalFactReader, FinalFactAp, TraceInfo?) -> Unit,
             addSideEffectRequirement: (FinalFactReader) -> Unit,
         )
+
+        fun propagateSuccessCallFact(
+            factAp: FinalFactAp,
+            startFactBase: AccessPathBase,
+            method: MethodWithContext,
+            addSideEffectRequirement: (FinalFactReader) -> Unit,
+            addCallToReturn: (FinalFactReader, FinalFactAp, TraceInfo?) -> Unit,
+            addCallToStart: (callerFact: FinalFactAp, startFactBase: AccessPathBase, TraceInfo?) -> Unit,
+            addUnchecked: (CallFact) -> Unit,
+        )
     }
 }