Give CachedLazyCallTargetSupplier a more specific name, and put the transfer in it

Author: chrisseaton

src/main/java/org/truffleruby/builtins/CoreMethodNodeManager.java

@@ -16,7 +16,7 @@
 import com.oracle.truffle.api.TruffleSafepoint;
 import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
-import org.truffleruby.collections.CachedSupplier;
+import org.truffleruby.language.methods.CachedLazyCallTargetSupplier;
 import org.truffleruby.core.CoreLibrary;
 import org.truffleruby.core.DummyNode;
 import org.truffleruby.core.array.ArrayUtils;
@@ -253,7 +253,7 @@ private static void addMethod(
                     arity);
 
             final RootCallTarget callTarget;
-            final CachedSupplier<RootCallTarget> callTargetSupplier;
+            final CachedLazyCallTargetSupplier callTargetSupplier;
             final NodeFactory<? extends RubyBaseNode> alwaysInlinedNodeFactory;
             if (alwaysInlined) {
                 callTarget = callTargetFactory.apply(sharedMethodInfo);
@@ -262,10 +262,8 @@ private static void addMethod(
             } else {
                 if (context.getLanguageSlow().options.LAZY_CALLTARGETS) {
                     callTarget = null;
-                    callTargetSupplier = new CachedSupplier<>(() -> {
-                        CompilerDirectives.transferToInterpreterAndInvalidate();
-                        return callTargetFactory.apply(sharedMethodInfo);
-                    });
+                    callTargetSupplier = new CachedLazyCallTargetSupplier(
+                            () -> callTargetFactory.apply(sharedMethodInfo));
                 } else {
                     callTarget = callTargetFactory.apply(sharedMethodInfo);
                     callTargetSupplier = null;

src/main/java/org/truffleruby/collections/CachedSupplier.java renamed to src/main/java/org/truffleruby/language/methods/CachedLazyCallTargetSupplier.java

@@ -7,23 +7,27 @@
  * GNU General Public License version 2, or
  * GNU Lesser General Public License version 2.1.
  */
-package org.truffleruby.collections;
+package org.truffleruby.language.methods;
+
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.RootCallTarget;
 
 import java.util.function.Supplier;
 
-public class CachedSupplier<T> {
+public class CachedLazyCallTargetSupplier {
 
-    private volatile T value = null;
-    private Supplier<T> supplier;
+    private volatile RootCallTarget value = null;
+    private Supplier<RootCallTarget> supplier;
 
-    public CachedSupplier(Supplier<T> supplier) {
+    public CachedLazyCallTargetSupplier(Supplier<RootCallTarget> supplier) {
         this.supplier = supplier;
     }
 
-    public T get() {
+    public RootCallTarget get() {
         if (isAvailable()) {
             return value;
         }
+        CompilerDirectives.transferToInterpreterAndInvalidate();
         synchronized (this) {
             if (value == null) {
                 value = supplier.get();

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

@@ -14,7 +14,6 @@
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.dsl.NodeFactory;
 import org.truffleruby.RubyContext;
-import org.truffleruby.collections.CachedSupplier;
 import org.truffleruby.core.klass.RubyClass;
 import org.truffleruby.core.module.RubyModule;
 import org.truffleruby.core.proc.RubyProc;
@@ -52,7 +51,7 @@ public class InternalMethod implements ObjectGraphNode {
     public final NodeFactory<? extends RubyBaseNode> alwaysInlinedNodeFactory;
     private final RubyProc proc; // only if method is created from a Proc
 
-    private final CachedSupplier<RootCallTarget> callTargetSupplier;
+    private final CachedLazyCallTargetSupplier callTargetSupplier;
     @CompilationFinal private RootCallTarget callTarget;
 
     public static InternalMethod fromProc(
@@ -116,7 +115,7 @@ public InternalMethod(
             NodeFactory<? extends RubyBaseNode> alwaysInlined,
             RubyProc proc,
             RootCallTarget callTarget,
-            CachedSupplier<RootCallTarget> callTargetSupplier) {
+            CachedLazyCallTargetSupplier callTargetSupplier) {
         this(
                 sharedMethodInfo,
                 lexicalScope,
@@ -150,7 +149,7 @@ private InternalMethod(
             DeclarationContext activeRefinements,
             RubyProc proc,
             RootCallTarget callTarget,
-            CachedSupplier<RootCallTarget> callTargetSupplier) {
+            CachedLazyCallTargetSupplier callTargetSupplier) {
         assert declaringModule != null;
         assert lexicalScope != null;
         assert !sharedMethodInfo.isBlock() : sharedMethodInfo;

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

@@ -13,14 +13,12 @@
 import com.oracle.truffle.api.instrumentation.InstrumentableNode;
 import com.oracle.truffle.api.instrumentation.StandardTags;
 import com.oracle.truffle.api.instrumentation.Tag;
-import org.truffleruby.collections.CachedSupplier;
 import org.truffleruby.core.module.RubyModule;
 import org.truffleruby.language.RubyContextSourceNode;
 import org.truffleruby.language.RubyNode;
 import org.truffleruby.language.Visibility;
 import org.truffleruby.language.arguments.RubyArguments;
 
-import com.oracle.truffle.api.RootCallTarget;
 import com.oracle.truffle.api.frame.VirtualFrame;
 
 import java.util.Set;
@@ -32,7 +30,7 @@ public class LiteralMethodDefinitionNode extends RubyContextSourceNode {
     private final String name;
     private final SharedMethodInfo sharedMethodInfo;
     private final boolean isDefSingleton;
-    private final CachedSupplier<RootCallTarget> callTargetSupplier;
+    private final CachedLazyCallTargetSupplier callTargetSupplier;
 
     @Child private RubyNode moduleNode;
 
@@ -41,7 +39,7 @@ public LiteralMethodDefinitionNode(
             String name,
             SharedMethodInfo sharedMethodInfo,
             boolean isDefSingleton,
-            CachedSupplier<RootCallTarget> callTargetSupplier) {
+            CachedLazyCallTargetSupplier callTargetSupplier) {
         this.name = name;
         this.sharedMethodInfo = sharedMethodInfo;
         this.isDefSingleton = isDefSingleton;

src/main/java/org/truffleruby/parser/MethodTranslator.java

@@ -12,9 +12,8 @@
 import java.util.Arrays;
 import java.util.function.Supplier;
 
-import com.oracle.truffle.api.CompilerDirectives;
 import org.truffleruby.RubyLanguage;
-import org.truffleruby.collections.CachedSupplier;
+import org.truffleruby.language.methods.CachedLazyCallTargetSupplier;
 import org.truffleruby.core.IsNilNode;
 import org.truffleruby.core.cast.SplatCastNode;
 import org.truffleruby.core.cast.SplatCastNode.NilBehavior;
@@ -419,17 +418,15 @@ private RubyMethodRootNode translateMethodNode(SourceIndexLength sourceSection,
                 argsNode.getArity());
     }
 
-    public CachedSupplier<RootCallTarget> buildMethodNodeCompiler(SourceIndexLength sourceSection,
+    public CachedLazyCallTargetSupplier buildMethodNodeCompiler(SourceIndexLength sourceSection,
             MethodDefParseNode defNode, ParseNode bodyNode) {
 
         if (shouldLazyTranslate) {
-            return new CachedSupplier<>(() -> {
-                CompilerDirectives.transferToInterpreterAndInvalidate();
-                return translateMethodNode(sourceSection, defNode, bodyNode).getCallTarget();
-            });
+            return new CachedLazyCallTargetSupplier(
+                    () -> translateMethodNode(sourceSection, defNode, bodyNode).getCallTarget());
         } else {
             final RubyMethodRootNode root = translateMethodNode(sourceSection, defNode, bodyNode);
-            return new CachedSupplier<>(() -> root.getCallTarget());
+            return new CachedLazyCallTargetSupplier(() -> root.getCallTarget());
         }
     }