Fix after review (2)

Author: mmvpm

utbot-framework-api/src/main/kotlin/org/utbot/framework/UtSettings.kt

@@ -271,22 +271,23 @@ object UtSettings : AbstractSettings(logger, defaultKeyForSettingsPath, defaultS
     var useTaintAnalysis by getBooleanProperty(false)
 
     /**
-     * If true, [Traverser] will call [TraversalContext.implicitlyThrowException] for [TaintMarksAll],
-     * even if [TaintMarksSet] is specified, i.e. each taint mark will not be processed separately.
+     * If it is true, [Traverser] processes all available taint marks in one request,
+     * otherwise, it forks the state and creates checks for each one of them separately.
      *
      * @see [org.utbot.engine.Traverser.processTaintSink]
      */
-    var ThrowTaintErrorOnlyForAllMarks = false
+    var throwTaintErrorOnlyForAllMarks = false
 
     /**
      * How deep we should analyze the throwables.
      */
     val exploreThrowableDepth: ExploreThrowableDepth
         get() =
-            if (useTaintAnalysis)
+            if (useTaintAnalysis) {
                 ExploreThrowableDepth.EXPLORE_ALL_STATEMENTS
-            else
+            } else {
                 ExploreThrowableDepth.SKIP_ALL_STATEMENTS
+            }
 
 // region engine process debug
 

utbot-framework/src/main/kotlin/org/utbot/engine/Traverser.kt

@@ -2705,7 +2705,7 @@ class Traverser(
         val parameters = resolveParameters(invokeExpr.args, invokeExpr.method.parameterTypes)
 
         if (UtSettings.useTaintAnalysis) {
-            processTaintSink(SymbolicMethodData(invokeExpr.method.executableId, null, parameters, null))
+            processTaintSink(SymbolicMethodData(invokeExpr.method.executableId, base = null, args = parameters, result = null))
         }
 
         val result = mockMakeSymbolic(invokeExpr) ?: mockStaticMethod(invokeExpr.method, parameters)
@@ -2738,7 +2738,7 @@ class Traverser(
         val resolvedParameters = resolveParameters(parameters, method.parameterTypes)
 
         if (UtSettings.useTaintAnalysis) {
-            processTaintSink(SymbolicMethodData(method.executableId, instance, resolvedParameters, null))
+            processTaintSink(SymbolicMethodData(method.executableId, instance, resolvedParameters, result = null))
         }
 
         val invocation = Invocation(instance, method, resolvedParameters) {
@@ -2911,7 +2911,7 @@ class Traverser(
         val parameters = resolveParameters(invokeExpr.args, method.parameterTypes)
 
         if (UtSettings.useTaintAnalysis) {
-            processTaintSink(SymbolicMethodData(method.executableId, instance, parameters, null))
+            processTaintSink(SymbolicMethodData(method.executableId, instance, parameters, result = null))
         }
 
         val invocation = Invocation(instance, method, parameters, InvocationTarget(instance, method))
@@ -4270,33 +4270,49 @@ class Traverser(
     }
 
     private fun TraversalContext.processTaintSink(methodData: SymbolicMethodData) {
-        val methodName = methodData.methodId.simpleNameWithClass
         val sinkConfigurations = taintContext.configuration.getSinksBy(methodData.methodId)
-
-        for (sink in sinkConfigurations) {
+        sinkConfigurations.forEach { sink ->
             val condition = sink.condition.toBoolExpr(this@Traverser, methodData)
+            sink.check.entities.forEach { entity ->
+                implicitlyThrowTaintError(methodData, entity, sink.marks, condition)
+            }
+        }
+    }
+
+    private fun TraversalContext.implicitlyThrowTaintError(
+        methodData: SymbolicMethodData,
+        entity: TaintEntity,
+        marks: TaintMarks,
+        condition: UtBoolExpression,
+    ) {
+        val symbolicEntity = methodData.choose(entity) ?: return
+        val entityAddr = symbolicEntity.addrOrNull ?: return
+        val containsAnyMark = taintContext.markManager.containsAnyMark(memory, entityAddr)
+
+        val methodName = methodData.methodId.simpleNameWithClass
+        val taintedVarType = symbolicEntity.type.toQuotedString()
 
-            for (entity in sink.check.entities) {
-                val symbolicEntity = methodData.choose(entity) ?: continue
-                val entityAddr = symbolicEntity.addrOrNull ?: continue
-                val taintedVarType = symbolicEntity.type.toQuotedString()
+        if (UtSettings.throwTaintErrorOnlyForAllMarks) {
+            implicitlyThrowException(
+                TaintAnalysisError(methodName, taintedVarType, "tainted"),
+                setOf(mkAnd(containsAnyMark, condition))
+            )
+            return
+        }
 
-                if (sink.marks is TaintMarksAll || UtSettings.ThrowTaintErrorOnlyForAllMarks) {
-                    val containsAnyMark = taintContext.markManager.containsAnyMark(memory, entityAddr)
+        when (marks) {
+            is TaintMarksAll ->
+                implicitlyThrowException(
+                    TaintAnalysisError(methodName, taintedVarType, "tainted"),
+                    setOf(mkAnd(containsAnyMark, condition))
+                )
+            is TaintMarksSet -> {
+                marks.marks.forEach { mark ->
+                    val containsMark = taintContext.markManager.containsMark(memory, entityAddr, mark)
                     implicitlyThrowException(
-                        TaintAnalysisError(methodName, taintedVarType, "tainted"),
-                        setOf(mkAnd(containsAnyMark, condition))
+                        TaintAnalysisError(methodName, taintedVarType, mark.name),
+                        setOf(mkAnd(containsMark, condition))
                     )
-                } else if (sink.marks is TaintMarksSet) {
-                    for (mark in sink.marks.marks) {
-                        val containsMark = taintContext.markManager.containsMark(memory, entityAddr, mark)
-                        implicitlyThrowException(
-                            TaintAnalysisError(methodName, taintedVarType, mark.name),
-                            setOf(mkAnd(containsMark, condition))
-                        )
-                    }
-                } else {
-                    error("${sink.marks::class.java.canonicalName} not is TaintMarksAll and not is TaintMarksSet")
                 }
             }
         }

utbot-framework/src/main/kotlin/org/utbot/taint/TaintMarkManager.kt

@@ -22,15 +22,15 @@ class TaintMarkManager(private val markRegistry: TaintMarkRegistry) {
         val taintVector = memory.taintVector(addr).toLongValue()
         val taintMarkId = markRegistry.idByMark(mark)
         val taintMarkVector = mkLong(taintMarkId).toLongValue()
-        return mkNot(mkEq(And(taintVector, taintMarkVector), bvExpr0))
+        return mkNot(mkEq(And(taintVector, taintMarkVector), emptyTaintVector))
     }
 
     /**
      * Returns true if taint vector at address [addr] in [memory] contains any taint mark.
      */
     fun containsAnyMark(memory: Memory, addr: UtAddrExpression): UtBoolExpression {
         val taintVector = memory.taintVector(addr).toLongValue()
-        return mkNot(mkEq(taintVector, bvExpr0.toLongValue()))
+        return mkNot(mkEq(taintVector, emptyTaintVector.toLongValue()))
     }
 
     /**
@@ -104,7 +104,7 @@ class TaintMarkManager(private val markRegistry: TaintMarkRegistry) {
         val taintMarks = constructTaintVector(marks).toLongValue()
         val oldTaintVectorFrom = memory.taintVector(fromAddr).toLongValue()
         val intersection = And(taintMarks, oldTaintVectorFrom)
-        val hasAtLeastOneMark = mkNot(mkEq(intersection, bvExpr0))
+        val hasAtLeastOneMark = mkNot(mkEq(intersection, emptyTaintVector))
 
         val oldTaintVectorExprTo = memory.taintVector(toAddr)
         val newTaintVectorExprTo = Or(oldTaintVectorExprTo.toLongValue(), intersection.toLongValue())
@@ -120,7 +120,7 @@ class TaintMarkManager(private val markRegistry: TaintMarkRegistry) {
 
     // internal
 
-    private val bvExpr0 = mkLong(0L)
+    private val emptyTaintVector = mkLong(0L)
 
     /**
      * Returns taint vector that represents [marks].

utbot-framework/src/main/kotlin/org/utbot/taint/model/SymbolicMethodData.kt

@@ -21,6 +21,6 @@ data class SymbolicMethodData(
 
     companion object {
         fun constructInvalid(methodId: ExecutableId): SymbolicMethodData =
-            SymbolicMethodData(methodId, null, listOf(), null)
+            SymbolicMethodData(methodId, base = null, args = listOf(), result = null)
     }
 }

utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/settings/SettingsWindow.kt

@@ -89,7 +89,7 @@ class SettingsWindow(val project: Project) {
         }
         row {
             useTaintAnalysisCheckBox =
-                checkBox("Use taint analysis")
+                checkBox("Enable taint analysis")
                     .onApply {
                         settings.state.useTaintAnalysis = useTaintAnalysisCheckBox.isSelected
                     }