Move how fulfilled lazy call targets are handled

Author: chrisseaton

src/main/java/org/truffleruby/language/methods/CachedLazyCallTargetSupplier.java

@@ -9,36 +9,32 @@
  */
 package org.truffleruby.language.methods;
 
-import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.RootCallTarget;
 
 import java.util.function.Supplier;
 
 public class CachedLazyCallTargetSupplier {
 
-    private volatile RootCallTarget value = null;
+    // Volatile, so that writes from another thread will finish publishing the RootCallTarget first
+    private volatile RootCallTarget callTarget = null;
     private Supplier<RootCallTarget> supplier;
 
     public CachedLazyCallTargetSupplier(Supplier<RootCallTarget> supplier) {
         this.supplier = supplier;
     }
 
     public RootCallTarget get() {
-        if (isAvailable()) {
-            return value;
-        }
-        CompilerDirectives.transferToInterpreterAndInvalidate();
         synchronized (this) {
-            if (value == null) {
-                value = supplier.get();
+            if (callTarget == null) {
+                callTarget = supplier.get();
                 supplier = null;
             }
-            return value;
+            return callTarget;
         }
     }
 
-    public boolean isAvailable() {
-        return value != null;
+    public RootCallTarget getWhenAvailable() {
+        return callTarget;
     }
 
 }

src/main/java/org/truffleruby/language/methods/InternalMethod.java

@@ -11,6 +11,7 @@
 
 import java.util.Set;
 
+import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.dsl.NodeFactory;
 import org.truffleruby.RubyContext;
@@ -172,8 +173,8 @@ private InternalMethod(
 
         /* If the call target supplier has already been run, then don't wait until the first time the InternalMethod is
          * asked for the call target, because this would be a deoptimization in getCallTarget(). */
-        if (callTarget == null && callTargetSupplier != null && callTargetSupplier.isAvailable()) {
-            this.callTarget = callTargetSupplier.get();
+        if (callTarget == null && callTargetSupplier != null) {
+            this.callTarget = callTargetSupplier.getWhenAvailable();
         }
     }
 
@@ -231,6 +232,7 @@ public RubyProc getProc() {
 
     public RootCallTarget getCallTarget() {
         if (callTarget == null) {
+            CompilerDirectives.transferToInterpreterAndInvalidate();
             callTarget = callTargetSupplier.get();
             assert RubyRootNode.of(callTarget).getSharedMethodInfo() == sharedMethodInfo;
         }