Move Intellij plugin related functionality into IdeaPlugin.kt (#465)

---------

Signed-off-by: Evgeniy Moiseenko <[email protected]>

Author: eupp

src/jvm/main/org/jetbrains/kotlinx/lincheck/IdeaPlugin.kt

@@ -13,7 +13,10 @@ package org.jetbrains.kotlinx.lincheck
 
 import sun.nio.ch.lincheck.*
 import org.jetbrains.kotlinx.lincheck.runner.*
+import org.jetbrains.kotlinx.lincheck.strategy.*
+import org.jetbrains.kotlinx.lincheck.strategy.managed.*
 import org.jetbrains.kotlinx.lincheck.strategy.managed.modelchecking.*
+import org.jetbrains.kotlinx.lincheck.execution.ExecutionResult
 import org.jetbrains.kotlinx.lincheck.util.ThreadMap
 
 const val MINIMAL_PLUGIN_VERSION = "0.2"
@@ -22,18 +25,17 @@ const val MINIMAL_PLUGIN_VERSION = "0.2"
 
 /**
  * Invoked from the strategy [ModelCheckingStrategy] when Lincheck finds a bug.
- * The debugger creates a breakpoint on this method, so when it's called, the debugger receives all the information about the
- * failed test.
+ * The debugger creates a breakpoint on this method, so when it's called,
+ * the debugger receives all the information about the failed test.
  * When a failure is found this method is called to provide all required information (trace points, failure type),
  * then [beforeEvent] method is called on each trace point.
  *
- * @param failureType string representation of the failure type.
- * (`INCORRECT_RESULTS`, `OBSTRUCTION_FREEDOM_VIOLATION`, `UNEXPECTED_EXCEPTION`, `VALIDATION_FAILURE`, `DEADLOCK` or `INTERNAL_BUG`).
+ * @param failureType string representation of the failure type (see [LincheckFailure.type]).
  * @param trace failed test trace, where each trace point is represented as a string
- * (because it's the easiest way to provide some information to the debugger).
- * @param version current Lincheck version
- * @param minimalPluginVersion minimal compatible plugin version
- * @param exceptions representation of the exceptions with their stacktrace occurred during the execution
+ *   (because it's the easiest way to provide some information to the debugger).
+ * @param version current Lincheck version.
+ * @param minimalPluginVersion minimal compatible plugin version.
+ * @param exceptions representation of the exceptions with their stacktrace occurred during the execution.
  */
 @Suppress("UNUSED_PARAMETER")
 fun testFailed(
@@ -42,8 +44,7 @@ fun testFailed(
     version: String?,
     minimalPluginVersion: String,
     exceptions: Array<String>
-) {
-}
+) {}
 
 /**
  * Debugger replaces the result of this method to `true` if idea plugin is enabled.
@@ -61,8 +62,8 @@ fun ideaPluginEnabled(): Boolean {
 fun lincheckVerificationStarted() {}
 
 /**
- * If the debugger needs to replay the execution (due to earlier trace point selection), it replaces the result of this
- * method to `true`.
+ * If the debugger needs to replay the execution (due to earlier trace point selection),
+ * it replaces the result of this method to `true`.
  */
 fun shouldReplayInterleaving(): Boolean {
     return false // should be replaced with `true` to replay the failure
@@ -71,7 +72,8 @@ fun shouldReplayInterleaving(): Boolean {
 /**
  * This method is called on every trace point shown to the user,
  * but before the actual event, such as the read/write/MONITORENTER/MONITOREXIT/, etc.
- * The Debugger creates a breakpoint inside this method and if [eventId] is the selected one, the breakpoint is triggered.
+ * The Debugger creates a breakpoint inside this method and if [eventId] is the selected one,
+ * the breakpoint is triggered.
  * Then the debugger performs step-out action, so we appear in the user's code.
  * That's why this method **must** be called from a user-code, not from a nested function.
  *
@@ -80,18 +82,18 @@ fun shouldReplayInterleaving(): Boolean {
  */
 @Suppress("UNUSED_PARAMETER")
 fun beforeEvent(eventId: Int, type: String) {
-    val strategy = ThreadDescriptor.getCurrentThreadDescriptor()?.eventTracker
-        ?: return
+    val threadDescriptor = ThreadDescriptor.getCurrentThreadDescriptor() ?: return
+    val strategy = threadDescriptor.eventTracker as? ManagedStrategy ?: return
     visualize(strategy)
 }
 
 
 /**
  * This method receives all information about the test object instance to visualize.
- * The Debugger creates a breakpoint inside this method and uses this method parameters to create the diagram.
+ * The Debugger creates a breakpoint inside this method and uses its parameters to create the diagram.
  *
- * We pass Maps as Arrays due to difficulties with passing objects (java.util.Map) to the debugger
- * (class version, etc.).
+ * We pass Maps as Arrays due to difficulties with passing objects (java.util.Map)
+ * to the debugger (class version, etc.).
  *
  * @param testInstance tested data structure.
  * @param numbersArrayMap an array structured like [Object, objectNumber, Object, objectNumber, ...].
@@ -107,8 +109,7 @@ fun visualizeInstance(
     numbersArrayMap: Array<Any>,
     continuationToLincheckThreadIdMap: Array<Any>,
     threadToLincheckThreadIdMap: Array<Any>
-) {
-}
+) {}
 
 /**
  * The Debugger creates a breakpoint on this method call to know when the thread is switched.
@@ -125,8 +126,198 @@ fun onThreadSwitchesOrActorFinishes() {}
  */
 internal val eventIdStrictOrderingCheck = System.getProperty("lincheck.debug.withEventIdSequentialCheck") != null
 
-private fun visualize(strategyObject: Any) = runCatching {
-    val strategy = strategyObject as ModelCheckingStrategy
+/**
+ * If the plugin enabled and the failure has a trace, passes information about
+ * the trace and the failure to the Plugin and run re-run execution to debug it.
+ */
+internal fun ManagedStrategy.runReplayIfPluginEnabled(failure: LincheckFailure) {
+    if (inIdeaPluginReplayMode && failure.trace != null) {
+        // Extract trace representation in the appropriate view.
+        val trace = constructTraceForPlugin(failure, failure.trace)
+        // Collect and analyze the exceptions thrown.
+        val (exceptionsRepresentation, internalBugOccurred) = collectExceptionsForPlugin(failure)
+        // If an internal bug occurred - print it on the console, no need to debug it.
+        if (internalBugOccurred) return
+        // Provide all information about the failed test to the debugger.
+        testFailed(
+            failureType = failure.type,
+            trace = trace,
+            version = lincheckVersion,
+            minimalPluginVersion = MINIMAL_PLUGIN_VERSION,
+            exceptions = exceptionsRepresentation
+        )
+        // Replay execution while it's needed.
+        do {
+            doReplay()
+        } while (shouldReplayInterleaving())
+    }
+}
+
+/**
+ * Transforms failure trace to the array of string to pass it to the debugger.
+ * (due to difficulties with passing objects like List and TracePoint, as class versions may vary)
+ *
+ * Each trace point is transformed into the line of the following form:
+ * `type,iThread,callDepth,shouldBeExpanded,eventId,representation`.
+ *
+ * Later, when [testFailed] breakpoint is triggered debugger parses these lines back to trace points.
+ *
+ * To help the plugin to create an execution view, we provide a type for each trace point.
+ * Below are the codes of trace point types.
+ *
+ * | Value                          | Code |
+ * |--------------------------------|------|
+ * | REGULAR                        | 0    |
+ * | ACTOR                          | 1    |
+ * | RESULT                         | 2    |
+ * | SWITCH                         | 3    |
+ * | SPIN_CYCLE_START               | 4    |
+ * | SPIN_CYCLE_SWITCH              | 5    |
+ * | OBSTRUCTION_FREEDOM_VIOLATION  | 6    |
+ */
+private fun constructTraceForPlugin(failure: LincheckFailure, trace: Trace): Array<String> {
+    val nThreads = trace.trace.maxOf { it.iThread } + 1
+    val results = failure.results
+    val nodesList = constructTraceGraph(nThreads, failure, results, trace, collectExceptionsOrEmpty(failure))
+    var sectionIndex = 0
+    var node: TraceNode? = nodesList.firstOrNull()
+    val representations = mutableListOf<String>()
+    while (node != null) {
+        when (node) {
+            is TraceLeafEvent -> {
+                val event = node.event
+                val eventId = event.eventId
+                val representation = event.toStringImpl(withLocation = false)
+                val type = when (event) {
+                    is SwitchEventTracePoint -> {
+                        when (event.reason) {
+                            SwitchReason.ActiveLock -> {
+                                5
+                            }
+                            else -> 3
+                        }
+                    }
+                    is SpinCycleStartTracePoint -> 4
+                    is ObstructionFreedomViolationExecutionAbortTracePoint -> 6
+                    else -> 0
+                }
+
+                if (representation.isNotEmpty()) {
+                    representations.add("$type;${node.iThread};${node.callDepth};${node.shouldBeExpanded(false)};${eventId};${representation}")
+                }
+            }
+
+            is CallNode -> {
+                val beforeEventId = node.call.eventId
+                val representation = node.call.toStringImpl(withLocation = false)
+                if (representation.isNotEmpty()) {
+                    representations.add("0;${node.iThread};${node.callDepth};${node.shouldBeExpanded(false)};${beforeEventId};${representation}")
+                }
+            }
+
+            is ActorNode -> {
+                val beforeEventId = -1
+                val representation = node.actorRepresentation
+                if (representation.isNotEmpty()) {
+                    representations.add("1;${node.iThread};${node.callDepth};${node.shouldBeExpanded(false)};${beforeEventId};${representation}")
+                }
+            }
+
+            is ActorResultNode -> {
+                val beforeEventId = -1
+                val representation = node.resultRepresentation.toString()
+                representations.add("2;${node.iThread};${node.callDepth};${node.shouldBeExpanded(false)};${beforeEventId};${representation};${node.exceptionNumberIfExceptionResult ?: -1}")
+            }
+
+            else -> {}
+        }
+
+        node = node.next
+        if (node == null && sectionIndex != nodesList.lastIndex) {
+            node = nodesList[++sectionIndex]
+        }
+    }
+    return representations.toTypedArray()
+}
+
+/**
+ * We provide information about the failure type to the Plugin, but
+ * due to difficulties with passing objects like LincheckFailure (as class versions may vary),
+ * we use its string representation.
+ * The Plugin uses this information to show the failure type to a user.
+ */
+private val LincheckFailure.type: String
+    get() = when (this) {
+        is IncorrectResultsFailure -> "INCORRECT_RESULTS"
+        is ObstructionFreedomViolationFailure -> "OBSTRUCTION_FREEDOM_VIOLATION"
+        is UnexpectedExceptionFailure -> "UNEXPECTED_EXCEPTION"
+        is ValidationFailure -> "VALIDATION_FAILURE"
+        is ManagedDeadlockFailure, is TimeoutFailure -> "DEADLOCK"
+    }
+
+/**
+ * Processes the exceptions thrown during the execution.
+ * @return exceptions string representation to pass to the plugin with a flag,
+ *   indicating if an internal bug was the cause of the failure, or not.
+ */
+private fun collectExceptionsForPlugin(failure: LincheckFailure): ExceptionProcessingResult {
+    val results: ExecutionResult = when (failure) {
+        is IncorrectResultsFailure -> failure.results
+        is ValidationFailure -> {
+            return ExceptionProcessingResult(arrayOf(failure.exception.text), isInternalBugOccurred = false)
+        }
+        else -> {
+            return ExceptionProcessingResult(emptyArray(), isInternalBugOccurred = false)
+        }
+    }
+    return when (val exceptionsProcessingResult = collectExceptionStackTraces(results)) {
+        // If some exception was thrown from the Lincheck itself, we'll ask for bug reporting
+        is InternalLincheckBugResult ->
+            ExceptionProcessingResult(arrayOf(exceptionsProcessingResult.exception.text), isInternalBugOccurred = true)
+        // Otherwise collect all the exceptions
+        is ExceptionStackTracesResult -> {
+            exceptionsProcessingResult.exceptionStackTraces.entries
+                .sortedBy { (_, numberAndStackTrace) -> numberAndStackTrace.number }
+                .map { (exception, numberAndStackTrace) ->
+                    val header = exception::class.java.canonicalName + ": " + exception.message
+                    header + numberAndStackTrace.stackTrace.joinToString("") { "\n\tat $it" }
+                }
+                .let { ExceptionProcessingResult(it.toTypedArray(), isInternalBugOccurred = false) }
+        }
+    }
+}
+
+private fun collectExceptionsOrEmpty(failure: LincheckFailure): Map<Throwable, ExceptionNumberAndStacktrace> {
+    if (failure is ValidationFailure) {
+        return mapOf(failure.exception to ExceptionNumberAndStacktrace(1, failure.exception.stackTrace.toList()))
+    }
+    val results = (failure as? IncorrectResultsFailure)?.results ?: return emptyMap()
+    return when (val result = collectExceptionStackTraces(results)) {
+        is ExceptionStackTracesResult -> result.exceptionStackTraces
+        is InternalLincheckBugResult -> emptyMap()
+    }
+}
+
+/**
+ * Result of creating string representations of exceptions
+ * thrown during the execution before passing them to the plugin.
+ *
+ * @param exceptionsRepresentation string representation of all the exceptions
+ * @param isInternalBugOccurred a flag indicating that the exception is caused by a bug in the Lincheck.
+ */
+@Suppress("ArrayInDataClass")
+private data class ExceptionProcessingResult(
+    val exceptionsRepresentation: Array<String>,
+    val isInternalBugOccurred: Boolean
+)
+
+/**
+ * Collects all the necessary data to pass to the debugger plugin and calls [visualizeInstance].
+ *
+ * @param strategy The managed strategy used to obtain data to be passed into the debugger plugin.
+ *   Used to collect the data about the test instance, object numbers, threads, and continuations.
+ */
+private fun visualize(strategy: ManagedStrategy) = runCatching {
     val runner = strategy.runner as ParallelThreadsRunner
     val testObject = runner.testInstance
     val lincheckThreads = runner.executor.threads
@@ -139,7 +330,6 @@ private fun visualize(strategyObject: Any) = runCatching {
     visualizeInstance(testObject, objectToNumberMap, continuationToLincheckThreadIdMap, threadToLincheckThreadIdMap)
 }
 
-
 /**
  * Creates an array [Object, objectNumber, Object, objectNumber, ...].
  * It represents a `Map<Any, Int>`, but due to difficulties with passing objects (Map)
@@ -149,7 +339,6 @@ private fun visualize(strategyObject: Any) = runCatching {
  */
 private fun createObjectToNumberMapAsArray(testObject: Any): Array<Any> {
     val resultArray = arrayListOf<Any>()
-
     val numbersMap = enumerateObjects(testObject)
     numbersMap.forEach { (any, objectNumber) ->
         resultArray.add(any)

src/jvm/main/org/jetbrains/kotlinx/lincheck/LinChecker.kt

@@ -124,17 +124,13 @@ class LinChecker(private val testClass: Class<*>, options: Options<*, *>?) {
      */
     private fun CTestConfiguration.runReplayForPlugin(failure: LincheckFailure, verifier: Verifier) {
         if (ideaPluginEnabled() && this is ModelCheckingCTestConfiguration) {
-            reporter.logFailedIteration(failure, loggingLevel = LoggingLevel.WARN)
-            enableReplayModeForIdeaPlugin()
-            val strategy = createStrategy(failure.scenario)
-            check(strategy is ModelCheckingStrategy)
-            strategy.use {
-                val replayedFailure = it.runIteration(invocationsPerIteration, verifier)
+            createStrategy(failure.scenario).use { strategy ->
+                check(strategy is ModelCheckingStrategy)
+                strategy.enableReplayModeForIdeaPlugin()
+                val replayedFailure = strategy.runIteration(invocationsPerIteration, verifier)
                 check(replayedFailure != null)
                 strategy.runReplayIfPluginEnabled(replayedFailure)
             }
-        } else {
-            reporter.logFailedIteration(failure)
         }
     }
 

src/jvm/main/org/jetbrains/kotlinx/lincheck/strategy/managed/ManagedStrategy.kt

@@ -46,8 +46,13 @@ abstract class ManagedStrategy(
     scenario: ExecutionScenario,
     private val validationFunction: Actor?,
     private val stateRepresentationFunction: Method?,
-    private val testCfg: ManagedCTestConfiguration
+    private val testCfg: ManagedCTestConfiguration,
 ) : Strategy(scenario), EventTracker {
+
+    // The flag to enable IntelliJ IDEA plugin mode
+    var inIdeaPluginReplayMode: Boolean = false
+        private set
+
     // The number of parallel threads.
     protected val nThreads: Int = scenario.nThreads
 
@@ -250,6 +255,16 @@ abstract class ManagedStrategy(
 
     protected open fun enableSpinCycleReplay() {}
 
+    protected open fun initializeReplay() {
+        cleanObjectNumeration()
+        resetEventIdProvider()
+    }
+
+    internal fun doReplay(): InvocationResult {
+        initializeReplay()
+        return runInvocation()
+    }
+
     // == BASIC STRATEGY METHODS ==
 
     override fun beforePart(part: ExecutionPart) = runInIgnoredSection {
@@ -1701,6 +1716,10 @@ abstract class ManagedStrategy(
         return constructor(iThread, actorId, callStackTrace[iThread]?.toList() ?: emptyList())
     }
 
+    fun enableReplayModeForIdeaPlugin() {
+        inIdeaPluginReplayMode = true
+    }
+
     override fun beforeEvent(eventId: Int, type: String) {
         ideaPluginBeforeEvent(eventId, type)
     }
@@ -2034,4 +2053,4 @@ private const val OBSTRUCTION_FREEDOM_SUSPEND_VIOLATION_MESSAGE =
 private const val INFINITE_TIMEOUT = 1000L * 60 * 60 * 24 * 365
 
 private fun getTimeOutMs(strategy: ManagedStrategy, defaultTimeOutMs: Long): Long =
-    if (strategy is ModelCheckingStrategy && strategy.replay) INFINITE_TIMEOUT else defaultTimeOutMs
+    if (strategy.inIdeaPluginReplayMode) INFINITE_TIMEOUT else defaultTimeOutMs