Add sarif logical locations

mmvpm · mmvpm · commit a582daaaa999 · 2022-12-05T20:00:59.000+03:00
diff --git a/utbot-framework/src/main/kotlin/org/utbot/sarif/DataClasses.kt b/utbot-framework/src/main/kotlin/org/utbot/sarif/DataClasses.kt
@@ -1,8 +1,11 @@
 package org.utbot.sarif
 
-import com.fasterxml.jackson.annotation.JsonInclude
-import com.fasterxml.jackson.annotation.JsonProperty
-import com.fasterxml.jackson.annotation.JsonValue
+import com.fasterxml.jackson.annotation.*
+import com.fasterxml.jackson.core.JsonParser
+import com.fasterxml.jackson.databind.DeserializationContext
+import com.fasterxml.jackson.databind.JsonDeserializer
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.module.SimpleModule
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import com.fasterxml.jackson.module.kotlin.readValue
 
@@ -17,6 +20,12 @@ data class Sarif(
     val runs: List<SarifRun>
 ) {
     companion object {
+
+        private val jsonMapper = jacksonObjectMapper()
+            .registerModule(SimpleModule()
+                .addDeserializer(SarifLocationWrapper::class.java, SarifLocationWrapperDeserializer())
+            )
+
         private const val defaultSchema =
             "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json"
         private const val defaultVersion =
@@ -29,11 +38,11 @@ data class Sarif(
             Sarif(defaultSchema, defaultVersion, listOf(run))
 
         fun fromJson(reportInJson: String): Sarif =
-            jacksonObjectMapper().readValue(reportInJson)
+            jsonMapper.readValue(reportInJson)
     }
 
     fun toJson(): String =
-        jacksonObjectMapper()
+        jsonMapper
             .setSerializationInclusion(JsonInclude.Include.NON_NULL)
             .writerWithDefaultPrettyPrinter()
             .writeValueAsString(this)
@@ -111,7 +120,7 @@ data class SarifResult(
     val ruleId: String,
     val level: Level,
     val message: Message,
-    val locations: List<SarifPhysicalLocationWrapper> = listOf(),
+    val locations: List<SarifLocationWrapper> = listOf(),
     val relatedLocations: List<SarifRelatedPhysicalLocationWrapper> = listOf(),
     val codeFlows: List<SarifCodeFlow> = listOf()
 ) {
@@ -145,14 +154,41 @@ data class Message(
     val markdown: String? = null
 )
 
-// physical location
+// location
 
 /**
  * [Documentation](https://docs.github.com/en/code-security/code-scanning/integrating-with-code-scanning/sarif-support-for-code-scanning#location-object)
  */
+sealed class SarifLocationWrapper
+
 data class SarifPhysicalLocationWrapper(
-    val physicalLocation: SarifPhysicalLocation,
-)
+    val physicalLocation: SarifPhysicalLocation // this name used in the SarifLocationWrapperDeserializer
+) : SarifLocationWrapper()
+
+data class SarifLogicalLocationsWrapper(
+    val logicalLocations: List<SarifLogicalLocation> // this name used in the SarifLocationWrapperDeserializer
+) : SarifLocationWrapper()
+
+/**
+ * Custom JSON deserializer for sealed class [SarifLocationWrapper].
+ * Returns [SarifPhysicalLocationWrapper] or [SarifLogicalLocationsWrapper].
+ */
+class SarifLocationWrapperDeserializer : JsonDeserializer<SarifLocationWrapper>() {
+    override fun deserialize(jp: JsonParser, context: DeserializationContext?): SarifLocationWrapper {
+        val node: JsonNode = jp.codec.readTree(jp)
+        val isPhysicalLocation = node.get("physicalLocation") != null // field name
+        val isLogicalLocations = node.get("logicalLocations") != null // field name
+        return when {
+            isPhysicalLocation -> {
+                jacksonObjectMapper().readValue<SarifPhysicalLocationWrapper>(node.toString())
+            }
+            isLogicalLocations -> {
+                return jacksonObjectMapper().readValue<SarifLogicalLocationsWrapper>(node.toString())
+            }
+            else -> error("SarifLocationWrapperDeserializer: Cannot parse ${node.toPrettyString()}")
+        }
+    }
+}
 
 /**
  * [Documentation](https://docs.github.com/en/code-security/code-scanning/integrating-with-code-scanning/sarif-support-for-code-scanning#physicallocation-object)
@@ -189,6 +225,15 @@ data class SarifRegion(
     }
 }
 
+// logical locations
+
+/**
+ * [Documentation](https://github.com/microsoft/sarif-tutorials/blob/main/docs/2-Basics.md#physical-and-logical-locations)
+ */
+data class SarifLogicalLocation(
+    val fullyQualifiedName: String
+)
+
 // related locations
 
 /**
diff --git a/utbot-framework/src/main/kotlin/org/utbot/sarif/SarifReport.kt b/utbot-framework/src/main/kotlin/org/utbot/sarif/SarifReport.kt
@@ -4,6 +4,7 @@ import org.utbot.common.PathUtil.fileExtension
 import org.utbot.common.PathUtil.toPath
 import org.utbot.framework.UtSettings
 import org.utbot.framework.plugin.api.*
+import java.nio.file.Path
 import kotlin.io.path.nameWithoutExtension
 
 /**
@@ -27,6 +28,41 @@ class SarifReport(
             reports.fold(Sarif.empty()) { sarif: Sarif, report: String ->
                 sarif.copy(runs = sarif.runs + Sarif.fromJson(report).runs)
             }.toJson()
+
+        /**
+         * Minimizes SARIF results between several reports.
+         *
+         * More complex version of the [SarifReport.minimizeResults].
+         */
+        fun minimizeSarifResults(srcPathToSarif: MutableMap<Path, Sarif>): MutableMap<Path, Sarif> {
+            val pathToSarifResult = srcPathToSarif.entries.flatMap { (path, sarif) ->
+                sarif.getAllResults().map { sarifResult ->
+                    path to sarifResult
+                }
+            }
+            val groupedResults = pathToSarifResult.groupBy { (_, sarifResult) ->
+                sarifResult.ruleId to sarifResult.locations
+            }
+            val minimizedResults = groupedResults.map { (_, sarifResultsGroup) ->
+                sarifResultsGroup.minByOrNull { (_, sarifResult) ->
+                    sarifResult.totalCodeFlowLocations()
+                }!!
+            }
+            val groupedByPath = minimizedResults
+                .groupBy { (path, _) -> path }
+                .mapValues { (_, resultsWithPath) ->
+                    resultsWithPath.map { (_, sarifResult) -> sarifResult } // remove redundant path
+                }
+            val pathToSarifTool = srcPathToSarif.mapValues { (_, sarif) ->
+                sarif.runs.first().tool
+            }
+            val paths = pathToSarifTool.keys intersect groupedByPath.keys
+            return paths.associateWith { path ->
+                val sarifTool = pathToSarifTool[path]!!
+                val sarifResults = groupedByPath[path]!!
+                Sarif.fromRun(SarifRun(sarifTool, sarifResults))
+            }.toMutableMap()
+        }
     }
 
     /**
@@ -67,6 +103,8 @@ class SarifReport(
      */
     private val relatedLocationId = 1 // for attaching link to generated test in related locations
 
+    private val stackTraceLengthForStackOverflow = 50 // stack overflow error may have too many elements
+
     /**
      * Minimizes detected errors and removes duplicates.
      *
@@ -125,7 +163,7 @@ class SarifReport(
                     [Generated test for this case]($relatedLocationId)
                 """.trimIndent()
             ),
-            getLocations(utExecution, classFqn),
+            getLocations(method, utExecution, classFqn),
             getRelatedLocations(utExecution),
             getCodeFlows(method, utExecution, executionFailure)
         )
@@ -146,16 +184,23 @@ class SarifReport(
         return Pair(sarifResult, sarifRule)
     }
 
-    private fun getLocations(utExecution: UtExecution, classFqn: String?): List<SarifPhysicalLocationWrapper> {
+    private fun getLocations(
+        method: ExecutableId,
+        utExecution: UtExecution,
+        classFqn: String?
+    ): List<SarifLocationWrapper> {
         if (classFqn == null)
             return listOf()
-        val sourceRelativePath = sourceFinding.getSourceRelativePath(classFqn)
-        val startLine = getLastLineNumber(utExecution, classFqn) ?: defaultLineNumber
-        val sourceCode = sourceFinding.getSourceFile(classFqn)?.readText() ?: ""
+        val (startLine, classWithErrorFqn) = getLastLineNumberWithClassFqn(method, utExecution, classFqn)
+        val sourceCode = sourceFinding.getSourceFile(classWithErrorFqn)?.readText() ?: ""
         val sourceRegion = SarifRegion.withStartLine(sourceCode, startLine)
+        val sourceRelativePath = sourceFinding.getSourceRelativePath(classWithErrorFqn)
         return listOf(
             SarifPhysicalLocationWrapper(
                 SarifPhysicalLocation(SarifArtifact(sourceRelativePath), sourceRegion)
+            ),
+            SarifLogicalLocationsWrapper(
+                listOf(SarifLogicalLocation(classWithErrorFqn)) // class name without method name
             )
         )
     }
@@ -181,31 +226,9 @@ class SarifReport(
         utExecution: UtExecution,
         executionFailure: UtExecutionFailure
     ): List<SarifCodeFlow> {
-        /* Example of a typical stack trace:
-            - java.lang.Math.multiplyExact(Math.java:867)
-            - com.abc.Util.multiply(Util.java:10)
-            - com.abc.Util.multiply(Util.java:6)
-            - com.abc.Main.example(Main.java:11) // <- `lastMethodCallIndex`
-            - sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
-            - ...
-         */
-        val stackTrace = executionFailure.exception.stackTrace
-
-        val lastMethodCallIndex = stackTrace.indexOfLast {
-            it.className == method.classId.name && it.methodName == method.name
-        }
-        if (lastMethodCallIndex == -1)
-            return listOf()
-
-        val stackTraceFiltered = stackTrace
-            .take(lastMethodCallIndex + 1) // taking all elements before the last `method` call
-            .filter {
-                !it.className.startsWith("org.utbot.") // filter all internal calls
-            }
-
-        val stackTraceResolved = stackTraceFiltered.mapNotNull {
-            findStackTraceElementLocation(it)
-        }.toMutableList()
+        val stackTraceResolved = filterStackTrace(method, utExecution, executionFailure)
+            .mapNotNull { findStackTraceElementLocation(it) }
+            .toMutableList()
         if (stackTraceResolved.isEmpty())
             return listOf() // empty stack trace is not shown
 
@@ -235,6 +258,40 @@ class SarifReport(
         )
     }
 
+    private fun filterStackTrace(
+        method: ExecutableId,
+        utExecution: UtExecution,
+        executionFailure: UtExecutionFailure
+    ): List<StackTraceElement> {
+        /* Example of a typical stack trace:
+            - java.lang.Math.multiplyExact(Math.java:867)
+            - com.abc.Util.multiply(Util.java:10)
+            - com.abc.Util.multiply(Util.java:6)
+            - com.abc.Main.example(Main.java:11) // <- `lastMethodCallIndex`
+            - sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
+            - ...
+         */
+        var stackTrace = executionFailure.exception.stackTrace.toList()
+
+        val lastMethodCallIndex = stackTrace.indexOfLast {
+            it.className == method.classId.name && it.methodName == method.name
+        }
+        if (lastMethodCallIndex != -1) {
+            // taking all elements before the last `method` call
+            stackTrace = stackTrace.take(lastMethodCallIndex + 1)
+        }
+
+        if (executionFailure.exception is StackOverflowError) {
+            stackTrace = stackTrace.takeLast(stackTraceLengthForStackOverflow)
+        }
+
+        val stackTraceFiltered = stackTrace.filter {
+            !it.className.startsWith("org.utbot.") // filter all internal calls
+        }
+
+        return stackTraceFiltered
+    }
+
     private fun findStackTraceElementLocation(stackTraceElement: StackTraceElement): SarifFlowLocationWrapper? {
         val lineNumber = stackTraceElement.lineNumber
         if (lineNumber < 1)
@@ -327,15 +384,21 @@ class SarifReport(
     }
 
     /**
-     * Returns the number of the last line in the execution path which is located in the [classFqn].
+     * Returns the number of the last line in the execution path
+     * And the name of the class in which it is located.
      */
-    private fun getLastLineNumber(utExecution: UtExecution, classFqn: String): Int? {
-        val classFqnPath = classFqn.replace(".", "/")
+    private fun getLastLineNumberWithClassFqn(
+        method: ExecutableId,
+        utExecution: UtExecution,
+        defaultClassFqn: String
+    ): Pair<Int, String> {
         val coveredInstructions = utExecution.coverage?.coveredInstructions
-        val lastCoveredInstruction = coveredInstructions?.lastOrNull { it.className == classFqnPath }
-            ?: coveredInstructions?.lastOrNull()
+        val lastCoveredInstruction = coveredInstructions?.lastOrNull()
         if (lastCoveredInstruction != null)
-            return lastCoveredInstruction.lineNumber
+            return Pair(
+                lastCoveredInstruction.lineNumber,
+                lastCoveredInstruction.className.replace('/', '.')
+            )
 
         // if for some reason we can't extract the last line from the coverage
         val lastPathElementLineNumber = try {
@@ -345,7 +408,20 @@ class SarifReport(
         } catch (t: Throwable) {
             null
         }
-        return lastPathElementLineNumber
+        if (lastPathElementLineNumber != null) {
+            return Pair(lastPathElementLineNumber, defaultClassFqn)
+        }
+
+        val methodDefinitionLine = getMethodDefinitionLineNumber(method)
+        return Pair(methodDefinitionLine ?: defaultLineNumber, defaultClassFqn)
+    }
+
+    private fun getMethodDefinitionLineNumber(method: ExecutableId): Int? {
+        val sourceFile = sourceFinding.getSourceFile(method.classId.canonicalName)
+        val lineNumber = sourceFile?.readLines()?.indexOfFirst { line ->
+            line.contains(" ${method.name}(") // method definition
+        }
+        return if (lineNumber == null || lineNumber == -1) null else lineNumber + 1 // to one-based
     }
 
     private fun shouldProcessExecutionResult(result: UtExecutionResult): Boolean {
diff --git a/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/CodeGenerationController.kt b/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/CodeGenerationController.kt
@@ -8,7 +8,6 @@ import com.intellij.ide.fileTemplates.FileTemplateUtil
 import com.intellij.ide.fileTemplates.JavaTemplateUtil
 import com.intellij.ide.highlighter.JavaFileType
 import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.application.readAction
 import com.intellij.openapi.application.runReadAction
 import com.intellij.openapi.application.runWriteAction
 import com.intellij.openapi.command.WriteCommandAction.runWriteCommandAction
@@ -53,7 +52,6 @@ import org.jetbrains.kotlin.idea.core.ShortenReferences
 import org.jetbrains.kotlin.idea.core.getPackage
 import org.jetbrains.kotlin.idea.core.util.toPsiDirectory
 import org.jetbrains.kotlin.idea.util.ImportInsertHelperImpl
-import org.jetbrains.kotlin.idea.util.projectStructure.allModules
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.KtNamedFunction
@@ -96,8 +94,7 @@ import org.utbot.intellij.plugin.util.RunConfigurationHelper
 import org.utbot.intellij.plugin.util.assertIsDispatchThread
 import org.utbot.intellij.plugin.util.assertIsWriteThread
 import org.utbot.intellij.plugin.util.extractClassMethodsIncludingNested
-import org.utbot.sarif.Sarif
-import org.utbot.sarif.SarifReport
+import org.utbot.sarif.*
 
 object CodeGenerationController {
     private val logger = KotlinLogging.logger {}
@@ -211,7 +208,7 @@ object CodeGenerationController {
             return
         }
         UnitTestBotInspectionManager
-            .getInstance(model.project, srcClassPathToSarifReport)
+            .getInstance(model.project, SarifReport.minimizeSarifResults(srcClassPathToSarifReport))
             .createNewGlobalContext()
             .doInspections(AnalysisScope(model.project))
     }
diff --git a/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/inspection/UnitTestBotInspectionTool.kt b/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/inspection/UnitTestBotInspectionTool.kt
