Refactor byte-code transformation

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

@@ -0,0 +1,50 @@
+/*
+ * Lincheck
+ *
+ * Copyright (C) 2019 - 2024 JetBrains s.r.o.
+ *
+ * This Source Code Form is subject to the terms of the
+ * Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed
+ * with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+package org.jetbrains.kotlinx.lincheck
+
+import java.util.*
+
+/**
+ * Methods of this interface are called from the instrumented tested code during model-checking.
+ * See [Injections] for the documentation.
+ */
+internal interface EventTracker {
+    fun lock(monitor: Any, codeLocation: Int)
+    fun unlock(monitor: Any, codeLocation: Int)
+
+    fun park(codeLocation: Int)
+    fun unpark(thread: Thread, codeLocation: Int)
+
+    fun wait(monitor: Any, codeLocation: Int, withTimeout: Boolean)
+    fun notify(monitor: Any, codeLocation: Int, notifyAll: Boolean)
+
+    fun beforeReadField(obj: Any, className: String, fieldName: String, codeLocation: Int)
+    fun beforeReadFieldStatic(className: String, fieldName: String, codeLocation: Int)
+    fun beforeReadArrayElement(array: Any, index: Int, codeLocation: Int)
+    fun afterRead(value: Any?)
+
+    fun beforeWriteField(obj: Any, className: String, fieldName: String, value: Any?, codeLocation: Int)
+    fun beforeWriteFieldStatic(className: String, fieldName: String, value: Any?, codeLocation: Int)
+    fun beforeWriteArrayElement(array: Any, index: Int, value: Any?, codeLocation: Int)
+    fun afterWrite()
+
+    fun beforeMethodCall(owner: Any?, className: String, methodName: String, codeLocation: Int, params: Array<Any?>)
+    fun beforeAtomicMethodCall(ownerName: String, methodName: String, codeLocation: Int, params: Array<Any?>)
+    fun beforeAtomicUpdaterMethodCall(owner: Any, methodName: String, codeLocation: Int, params: Array<Any?>)
+    fun onMethodCallFinishedSuccessfully(result: Any?)
+    fun onMethodCallThrewException(t: Throwable)
+
+    fun getThreadLocalRandom(): Random
+    fun randomNextInt(): Int
+
+    fun onNewObjectCreation(obj: Any)
+    fun addDependency(receiver: Any, value: Any?)
+}

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

@@ -0,0 +1,313 @@
+/*
+ * Lincheck
+ *
+ * Copyright (C) 2019 - 2024 JetBrains s.r.o.
+ *
+ * This Source Code Form is subject to the terms of the
+ * Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed
+ * with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+package org.jetbrains.kotlinx.lincheck
+
+import java.util.*
+
+/**
+ * Methods of this object are called from the instrumented code.
+ */
+internal object Injections {
+    @JvmStatic
+    var lastSuspendedCancellableContinuationDuringVerification: Any? = null
+
+    @JvmStatic
+    fun storeCancellableContinuation(cont: Any) {
+        val t = Thread.currentThread()
+        if (t is TestThread) {
+            t.suspendedContinuation = cont
+        } else {
+            lastSuspendedCancellableContinuationDuringVerification = cont
+        }
+    }
+
+    @JvmStatic
+    fun enterIgnoredSection(): Boolean {
+        val t = Thread.currentThread()
+        if (t !is TestThread || t.inIgnoredSection) return false
+        t.inIgnoredSection = true
+        return true
+    }
+
+    @JvmStatic
+    fun leaveIgnoredSection() {
+        val t = Thread.currentThread() as TestThread
+        check(t.inIgnoredSection)
+        t.inIgnoredSection = false
+    }
+
+    @JvmStatic
+    fun inTestingCode(): Boolean {
+        val t = Thread.currentThread()
+        if (t !is TestThread) return false
+        return t.inTestingCode && !t.inIgnoredSection
+    }
+
+    /**
+     * Called from instrumented code before the lock operation
+     */
+    @JvmStatic
+    fun lock(monitor: Any, codeLocation: Int) {
+        eventTracker.lock(monitor, codeLocation)
+    }
+
+    /**
+     * Called from instrumented code before the unlock operation
+     */
+    @JvmStatic
+    fun unlock(monitor: Any, codeLocation: Int) {
+        eventTracker.unlock(monitor, codeLocation)
+    }
+
+    /**
+     * Called from the instrumented code before the park operation
+     */
+    @JvmStatic
+    fun park(codeLocation: Int) {
+        eventTracker.park(codeLocation)
+    }
+
+    /**
+     * Called from the instrumented code before the unpark operation
+     */
+    @JvmStatic
+    fun unpark(thread: Thread, codeLocation: Int) {
+        eventTracker.unpark(thread, codeLocation)
+    }
+
+    /**
+     * Called from the instrumented code before the wait operation
+     */
+    @JvmStatic
+    fun wait(monitor: Any, codeLocation: Int) {
+        eventTracker.wait(monitor, codeLocation, withTimeout = false)
+    }
+
+
+    /**
+     * Called from the instrumented code before the wait operation
+     */
+    @JvmStatic
+    fun waitWithTimeout(monitor: Any, codeLocation: Int) {
+        eventTracker.wait(monitor, codeLocation, withTimeout = true)
+    }
+
+    /**
+     * Called from the instrumented code before the notify operation
+     */
+    @JvmStatic
+    fun notify(monitor: Any, codeLocation: Int) {
+        eventTracker.notify(monitor, codeLocation, notifyAll = false)
+    }
+
+    /**
+     * Called from the instrumented code before the notifyAll operation
+     */
+    @JvmStatic
+    fun notifyAll(monitor: Any, codeLocation: Int) {
+        eventTracker.notify(monitor, codeLocation, notifyAll = true)
+    }
+
+    /**
+     * Called from the instrumented code to replace random.nextInt() call with a deterministic value
+     */
+    @JvmStatic
+    fun nextInt(): Int {
+        return eventTracker.randomNextInt()
+    }
+
+    /**
+     * Called from the instrumented code to get a deterministic random instance
+     */
+    @JvmStatic
+    fun deterministicRandom(): Random {
+        return eventTracker.getThreadLocalRandom()
+    }
+
+    /**
+     * Called from the instrumented code to examine if this value is Random
+     */
+    @JvmStatic
+    fun isRandom(any: Any?): Boolean {
+        return any is Random
+    }
+
+    /**
+     * Called from the instrumented code before any field read
+     */
+    @JvmStatic
+    fun beforeReadField(obj: Any?, className: String, fieldName: String, codeLocation: Int) {
+        if (obj == null) return // Ignore, NullPointerException will be thrown
+        eventTracker.beforeReadField(obj, className, fieldName, codeLocation)
+    }
+
+    /**
+     * Called from the instrumented code before any static field read
+     */
+    @JvmStatic
+    fun beforeReadFieldStatic(className: String, fieldName: String, codeLocation: Int) {
+        eventTracker.beforeReadFieldStatic(className, fieldName, codeLocation)
+    }
+
+    /**
+     * Called from the instrumented code before any array cell read
+     */
+    @JvmStatic
+    fun beforeReadArray(array: Any?, index: Int, codeLocation: Int) {
+        if (array == null) return // Ignore, NullPointerException will be thrown
+        eventTracker.beforeReadArrayElement(array, index, codeLocation)
+    }
+
+    /**
+     * Called from the instrumented code after any field read
+     */
+    @JvmStatic
+    fun afterRead(value: Any?) {
+        eventTracker.afterRead(value)
+    }
+
+    /**
+     * Called from the instrumented code before any field write
+     */
+    @JvmStatic
+    fun beforeWriteField(obj: Any?, className: String, fieldName: String, value: Any?, codeLocation: Int) {
+        if (obj == null) return // Ignore, NullPointerException will be thrown
+        eventTracker.beforeWriteField(obj, className, fieldName, value, codeLocation)
+    }
+
+    /**
+     * Called from the instrumented code before any static field write
+     */
+    @JvmStatic
+    fun beforeWriteFieldStatic(className: String, fieldName: String, value: Any?, codeLocation: Int) {
+        eventTracker.beforeWriteFieldStatic(className, fieldName, value, codeLocation)
+    }
+
+    /**
+     * Called from the instrumented code before any array cell write
+     */
+    @JvmStatic
+    fun beforeWriteArray(array: Any?, index: Int, value: Any?, codeLocation: Int) {
+        if (array == null) return // Ignore, NullPointerException will be thrown
+        eventTracker.beforeWriteArrayElement(array, index, value, codeLocation)
+    }
+
+    /**
+     * Called from the instrumented code before any write operation
+     */
+    @JvmStatic
+    fun afterWrite() {
+        eventTracker.afterWrite()
+    }
+
+    /**
+     * Called from the instrumented code before any method call
+     *
+     * @param owner is `null` for static methods
+     */
+    @JvmStatic
+    fun beforeMethodCall(owner: Any?, className: String, methodName: String, codeLocation: Int, params: Array<Any?>) {
+        eventTracker.beforeMethodCall(owner, className, methodName, codeLocation, params)
+    }
+
+
+    /**
+     * Called from the instrumented code before any atomic method call
+     */
+    @JvmStatic
+    fun beforeAtomicMethodCall(ownerName: String, methodName: String, codeLocation: Int, params: Array<Any?>) {
+        eventTracker.beforeAtomicMethodCall(ownerName, methodName, codeLocation, params)
+    }
+
+    /**
+     * Called from the instrumented code before any AtomicFieldUpdater method call
+     */
+    @JvmStatic
+    fun beforeAtomicUpdaterMethodCall(owner: Any?, methodName: String, codeLocation: Int, params: Array<Any?>) {
+        eventTracker.beforeAtomicUpdaterMethodCall(owner!!, methodName, codeLocation, params)
+    }
+
+    /**
+     * Called from the instrumented code after any method successful call, i.e., without any exception
+     */
+    @JvmStatic
+    fun onMethodCallFinishedSuccessfully(result: Any?) {
+        eventTracker.onMethodCallFinishedSuccessfully(result)
+    }
+
+    /**
+     * Called from the instrumented code after any method that returns void successful call, i.e., without any exception
+     */
+    @JvmStatic
+    fun onMethodCallVoidFinishedSuccessfully() {
+        eventTracker.onMethodCallFinishedSuccessfully(VOID_RESULT)
+    }
+
+    /**
+     * Called from the instrumented code after any method call threw an exception
+     */
+    @JvmStatic
+    fun onMethodCallThrewException(t: Throwable) {
+        eventTracker.onMethodCallThrewException(t)
+    }
+
+    /**
+     * Called from the instrumented code after any object is created
+     */
+    @JvmStatic
+    fun onNewObjectCreation(obj: Any) {
+        eventTracker.onNewObjectCreation(obj)
+    }
+
+    @JvmStatic
+    private val eventTracker: EventTracker
+        get() = (Thread.currentThread() as TestThread).eventTracker!! // should be non-null
+
+    @JvmStatic
+    val VOID_RESULT = Any()
+
+    /**
+     * Called from the instrumented code after value assigned to any receiver field.
+     * Required to track local objects.
+     * @see org.jetbrains.kotlinx.lincheck.strategy.managed.LocalObjectManager
+     */
+    @JvmStatic
+    fun addDependency(receiver: Any, value: Any?) {
+        eventTracker.addDependency(receiver, value)
+    }
+
+    // == LISTENING METHODS ==
+
+    /**
+     * Called from the instrumented code to replace [java.lang.Object.hashCode] method call with some
+     * deterministic value.
+     */
+    @JvmStatic
+    internal fun hashCodeDeterministic(obj: Any): Int {
+        val hashCode = obj.hashCode()
+        return if (hashCode == System.identityHashCode(obj)) {
+            identityHashCodeDeterministic(obj)
+        } else {
+            hashCode
+        }
+    }
+
+    /**
+     * Called from the instrumented code to replace [java.lang.System.identityHashCode] method call with some
+     * deterministic value.
+     */
+    @JvmStatic
+    internal fun identityHashCodeDeterministic(obj: Any?): Int {
+        if (obj == null) return 0
+        // TODO: easier to support when `javaagent` is merged
+        return 0
+    }
+}

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

@@ -12,7 +12,6 @@ package org.jetbrains.kotlinx.lincheck
 
 import org.jetbrains.kotlinx.lincheck.LoggingLevel.*
 import org.jetbrains.kotlinx.lincheck.execution.*
-import org.jetbrains.kotlinx.lincheck.runner.*
 import org.jetbrains.kotlinx.lincheck.strategy.*
 import org.jetbrains.kotlinx.lincheck.strategy.managed.*
 import java.io.*
@@ -573,7 +572,7 @@ private fun StringBuilder.appendDeadlockWithDumpFailure(failure: DeadlockWithDum
     failure.threadDump?.let { threadDump ->
         // Sort threads to produce same output for the same results
         for ((t, stackTrace) in threadDump.entries.sortedBy { it.key.id }) {
-            val threadNumber = if (t is FixedActiveThreadsExecutor.TestThread) t.iThread.toString() else "?"
+            val threadNumber = (t as? TestThread)?.name ?: "?"
             appendLine("Thread-$threadNumber:")
             stackTrace.map {
                 StackTraceElement(