Non-determinism fix: ClassLoaders are now transformed in the Model Checking mode

src/jvm/main/org/jetbrains/kotlinx/lincheck/transformation/LincheckClassVisitor.kt

@@ -93,7 +93,7 @@ internal class LincheckClassVisitor(
             mv = ObjectCreationTransformer(fileName, className, methodName, mv.newAdapter())
             return mv
         }
-        if (className.contains("ClassLoader")) {
+        if (isClassLoader(className)) {
             if (methodName == "loadClass") {
                 mv = WrapMethodInIgnoredSectionTransformer(fileName, className, methodName, mv.newAdapter())
             }

src/jvm/main/org/jetbrains/kotlinx/lincheck/transformation/LincheckJavaAgent.kt

@@ -140,6 +140,11 @@ internal object LincheckJavaAgent {
             // In the model checking mode, Lincheck processes classes lazily, only when they are used.
             instrumentationMode == MODEL_CHECKING -> {
                 check(instrumentedClasses.isEmpty())
+                // Transform class loaders on the start, because it's the only place where we can do it.
+                val classLoaderClasses = getLoadedClassesToInstrument()
+                    .filter { isClassLoader(it.name) }
+                    .toTypedArray()
+                instrumentation.retransformClasses(*classLoaderClasses)
             }
         }
     }
@@ -351,7 +356,8 @@ internal object LincheckClassFileTransformer : ClassFileTransformer {
         // once they are used in the testing code.
         if (!INSTRUMENT_ALL_CLASSES &&
             instrumentationMode == MODEL_CHECKING &&
-            internalClassName.canonicalClassName !in instrumentedClasses) {
+            internalClassName.canonicalClassName !in instrumentedClasses &&
+            !isClassLoader(internalClassName)) {
             return null
         }
         return transformImpl(loader, internalClassName, classBytes)
@@ -382,6 +388,10 @@ internal object LincheckClassFileTransformer : ClassFileTransformer {
         if (instrumentationMode == STRESS) {
             if (className.startsWith("java.") || className.startsWith("kotlin.")) return false
         }
+        // We should transform all the ClassLoader-s to wrap `loadClass` methods in the ignored section.
+        if (isClassLoader(className)) {
+            return true
+        }
         // We do not need to instrument most standard Java classes.
         // It is fine to inject the Lincheck analysis only into the
         // `java.util.*` ones, ignored the known atomic constructs.

src/jvm/main/org/jetbrains/kotlinx/lincheck/transformation/TransformationUtils.kt

@@ -347,3 +347,5 @@ internal const val ASM_API = Opcodes.ASM9
 internal val STRING_TYPE = getType(String::class.java)
 internal val CLASS_TYPE = getType(Class::class.java)
 internal val CLASS_FOR_NAME_METHOD = Method("forName", CLASS_TYPE, arrayOf(STRING_TYPE))
+
+internal fun isClassLoader(className: String): Boolean = className.contains("ClassLoader")