Remove atomic setter transformers

bootstrap/src/sun/nio/ch/lincheck/EventTracker.java

@@ -42,8 +42,6 @@ boolean beforeWriteField(Object obj, String className, String fieldName, Object
     boolean beforeWriteArrayElement(Object array, int index, Object value, int codeLocation);
     void afterWrite();
 
-    void afterReflectiveSetter(Object receiver, Object value);
-
     void beforeMethodCall(Object owner, String className, String methodName, int codeLocation, int methodId, Object[] params);
     void onMethodCallReturn(Object result);
     void onMethodCallException(Throwable t);

bootstrap/src/sun/nio/ch/lincheck/Injections.java

@@ -237,19 +237,6 @@ public static void afterWrite() {
         getEventTracker().afterWrite();
     }
 
-    /**
-     * Called from the instrumented code after atomic write is performed through either
-     * the AtomicXXXFieldUpdater, VarHandle, or Unsafe APIs.
-     * Incorporates all atomic methods that can set the field (or array element) of an object,
-     * such as `set`, `compareAndSet`, `compareAndExchange`, etc.
-     *
-     * @param receiver The object to which field (or array element) the value is set.
-     * @param value The value written into [receiver] field (or array element).
-     */
-    public static void afterReflectiveSetter(Object receiver, Object value) {
-        getEventTracker().afterReflectiveSetter(receiver, value);
-    }
-
     /**
      * Called from the instrumented code before any method call.
      *

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

@@ -874,10 +874,6 @@ abstract class ManagedStrategy(
         }
     }
 
-    override fun afterReflectiveSetter(receiver: Any?, value: Any?) = runInIgnoredSection {
-        objectTracker.registerObjectLink(fromObject = receiver ?: StaticObject, toObject = value)
-    }
-
     override fun getThreadLocalRandom(): Random = runInIgnoredSection {
         return randoms[currentThread]
     }
@@ -937,6 +933,12 @@ abstract class ManagedStrategy(
             if (owner == null && atomicMethodDescriptor == null && guarantee == null) { // static method
                 LincheckJavaAgent.ensureClassHierarchyIsTransformed(className.canonicalClassName)
             }
+            if (atomicMethodDescriptor != null && atomicMethodDescriptor.kind.isSetter) {
+                objectTracker.registerObjectLink(
+                    fromObject = atomicMethodDescriptor.getAccessedObject(owner!!, params),
+                    toObject = atomicMethodDescriptor.getSetValue(owner, params)
+                )
+            }
             if (collectTrace) {
                 traceCollector!!.checkActiveLockDetected()
                 addBeforeMethodCallTracePoint(owner, codeLocation, methodId, className, methodName, params, atomicMethodDescriptor)

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

@@ -138,9 +138,6 @@ internal class LincheckClassVisitor(
         mv = DeterministicHashCodeTransformer(fileName, className, methodName, mv.newAdapter())
         mv = DeterministicTimeTransformer(mv.newAdapter())
         mv = DeterministicRandomTransformer(fileName, className, methodName, mv.newAdapter())
-        mv = UnsafeMethodTransformer(fileName, className, methodName, mv.newAdapter())
-        mv = AtomicFieldUpdaterMethodTransformer(fileName, className, methodName, mv.newAdapter())
-        mv = VarHandleMethodTransformer(fileName, className, methodName, mv.newAdapter())
         // `SharedMemoryAccessTransformer` goes first because it relies on `AnalyzerAdapter`,
         // which should be put in front of the byte-code transformer chain,
         // so that it can correctly analyze the byte-code and compute required type-information