Simplify sending and reading the caller frame and variables storage

* Now that #__send__/#send no longer need to forward through the caller data.
* Makes the separation between reading nodes and sending nodes clearer.

Author: eregon

src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java

@@ -319,15 +319,14 @@ public static GetSpecialVariableStorage create() {
             return GetSpecialVariableStorageNodeGen.create();
         }
 
-        public void startSending(Reads variables, Reads frame) {
-            if (variables == Reads.CALLER || frame == Reads.CALLER) {
-                throw CompilerDirectives.shouldNotReachHere();
-            }
-            if (frame == Reads.SELF) {
+        @Override
+        public void startSending(boolean variables, boolean frame) {
+            if (frame) {
                 replace(new ReadOwnFrameAndVariablesNode(), "Starting to read own frame and variables");
             }
         }
 
+        @Override
         public boolean sendingFrame() {
             return false;
         }

src/main/java/org/truffleruby/language/CallStackManager.java

@@ -98,10 +98,6 @@ public InternalMethod getCallingMethod() {
         return tryGetMethod(getCallerFrame(FrameAccess.READ_ONLY));
     }
 
-    public boolean callerIsSend() {
-        return false; // TODO (eregon, 2 Feb 2021): simplify callers
-    }
-
     // SourceSection
 
     @TruffleBoundary

src/main/java/org/truffleruby/language/FrameAndVariablesSendingNode.java

@@ -16,25 +16,19 @@
 import org.truffleruby.language.arguments.ReadCallerFrameNode;
 import org.truffleruby.language.arguments.ReadCallerVariablesNode;
 
-import org.truffleruby.language.FrameOrVariablesReadingNode.Reads;
 import org.truffleruby.language.methods.DeclarationContext;
 import org.truffleruby.language.threadlocal.SpecialVariableStorage;
 
 /** Some Ruby methods need access to the caller frame (the frame active when the method call was made) or to the storage
  * of special variables within that frame: see usages of {@link ReadCallerFrameNode} and {@link ReadCallerVariablesNode}
  * . This is notably used to get hold of instances of {@link DeclarationContext} and {@link RubyBinding} and methods
- * which need to access the last regexp match or the last io line.
+ * which need to access the last regexp MatchData or the last IO line.
  *
  * <p>
  * This means that when making a method call, we might need to pass down its {@link Frame} or
  * {@link SpecialVariableStorage} active when the method call was made.
  *
  * <p>
- * When retrieving the frame or special variable storage in a method called through the Ruby {@code #send} method, we
- * must not retrieve the frame of the actual call (made by {@code #send}) but the frame of the {@code #send} call
- * itself.
- *
- * <p>
  * Materializing a frame is expensive, and the point of this parent node is to only materialize the frame when we know
  * for sure it has been requested by the callee. It is also possible to walk the stack to retrieve the frame to
  * materialize - but this is even slower and causes a deoptimization in the callee every time we walk the stack.
@@ -43,10 +37,12 @@
  * This class works in tandem with {@link FrameOrVariablesReadingNode} for this purpose. At first, we don't send down
  * the frame. If the callee needs it, it will de-optimize and walk the stack to retrieve it (slow). It will also call
  * {@link #startSendingOwnFrame()}}, so that the next time the method is called, the frame will be passed down and the
- * method does not need further de-optimizations. (Note in the case of {@code #send} calls, we need to recursively call
- * {@link ReadCallerFrameNode} to get the parent frame!) {@link ReadCallerVariablesNode} is used similarly to access
- * special variable storage, but for child nodes that only require access to this storage ensures they receive an object
- * that will not require node splitting to be accessed efficiently. */
+ * method does not need further de-optimizations.
+ *
+ * <p>
+ * {@link ReadCallerVariablesNode} is used similarly to access special variable storage, but for child nodes that only
+ * require access to this storage ensures they receive an object that will not require node splitting to be accessed
+ * efficiently. */
 @SuppressFBWarnings("IS")
 public abstract class FrameAndVariablesSendingNode extends RubyContextNode {
 
@@ -60,37 +56,23 @@ public boolean sendingFrames() {
         }
     }
 
-    private synchronized void startSending(Reads variables, Reads frame) {
+    private synchronized void startSending(boolean variables, boolean frame) {
         if (readingNode != null) {
             readingNode.startSending(variables, frame);
-        } else if (variables == Reads.SELF && frame == Reads.NOTHING) {
+        } else if (variables && !frame) {
             readingNode = insert(GetSpecialVariableStorage.create());
-        } else if (variables == Reads.NOTHING && frame == Reads.SELF) {
+        } else if (!variables && frame) {
             readingNode = insert(new ReadOwnFrameNode());
-        } else if (variables == Reads.CALLER && frame == Reads.NOTHING) {
-            readingNode = insert(new ReadCallerFrameNode());
-        } else if (variables == Reads.NOTHING && frame == Reads.CALLER) {
-            readingNode = insert(new ReadCallerVariablesNode());
         }
     }
 
     /** Whether we are sending down the frame (because the called method reads it). */
     public void startSendingOwnFrame() {
-        RubyRootNode root = (RubyRootNode) getRootNode();
-        if (getContext().getCoreLibrary().isSend(root.getSharedMethodInfo())) {
-            startSending(Reads.NOTHING, Reads.CALLER);
-        } else {
-            startSending(Reads.NOTHING, Reads.SELF);
-        }
+        startSending(false, true);
     }
 
     public void startSendingOwnVariables() {
-        RubyRootNode root = (RubyRootNode) getRootNode();
-        if (getContext().getCoreLibrary().isSend(root.getSharedMethodInfo())) {
-            startSending(Reads.CALLER, Reads.NOTHING);
-        } else {
-            startSending(Reads.SELF, Reads.NOTHING);
-        }
+        startSending(true, false);
     }
 
     public Object getFrameOrStorageIfRequired(Frame frame) {

src/main/java/org/truffleruby/language/FrameOrVariablesReadingNode.java

@@ -12,17 +12,13 @@
 import com.oracle.truffle.api.frame.Frame;
 import com.oracle.truffle.api.nodes.NodeInterface;
 
+/** See {@link FrameAndVariablesSendingNode}. Nodes implementing this interface are used to read the data from the
+ * current frame, before a call. */
 public interface FrameOrVariablesReadingNode extends NodeInterface {
 
-    public static enum Reads {
-        NOTHING,       // callees don't need to read the frame
-        SELF,      // for most calls
-        CALLER;   // for `send` calls
-    }
-
     public Object execute(Frame frame);
 
-    public void startSending(Reads variables, Reads frame);
+    public void startSending(boolean variables, boolean frame);
 
     public boolean sendingFrame();
 }

src/main/java/org/truffleruby/language/ReadOwnFrameAndVariablesNode.java

@@ -9,7 +9,6 @@
  */
 package org.truffleruby.language;
 
-import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.frame.Frame;
 import org.truffleruby.core.kernel.TruffleKernelNodes.GetSpecialVariableStorage;
 
@@ -21,12 +20,11 @@ public Object execute(Frame frame) {
         return new FrameAndVariables(readVariablesNode.execute(frame), frame.materialize());
     }
 
-    public void startSending(Reads variables, Reads frame) {
-        if (variables == Reads.CALLER || frame == Reads.CALLER) {
-            throw CompilerDirectives.shouldNotReachHere();
-        }
+    @Override
+    public void startSending(boolean variables, boolean frame) {
     }
 
+    @Override
     public boolean sendingFrame() {
         return true;
     }

src/main/java/org/truffleruby/language/ReadOwnFrameNode.java

@@ -9,7 +9,6 @@
  */
 package org.truffleruby.language;
 
-import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.frame.Frame;
 
 public class ReadOwnFrameNode extends RubyBaseNode implements FrameOrVariablesReadingNode {
@@ -18,15 +17,14 @@ public Object execute(Frame frame) {
         return frame.materialize();
     }
 
-    public void startSending(Reads variables, Reads frame) {
-        if (variables == Reads.CALLER || frame == Reads.CALLER) {
-            throw CompilerDirectives.shouldNotReachHere();
-        }
-        if (variables == Reads.SELF) {
+    @Override
+    public void startSending(boolean variables, boolean frame) {
+        if (variables) {
             replace(new ReadOwnFrameAndVariablesNode(), "Starting to read own frame and variables");
         }
     }
 
+    @Override
     public boolean sendingFrame() {
         return true;
     }

src/main/java/org/truffleruby/language/arguments/ReadCallerDataNode.java

@@ -19,12 +19,11 @@
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.profiles.ConditionProfile;
 
-import org.truffleruby.language.FrameOrVariablesReadingNode;
 import org.truffleruby.language.FrameAndVariablesSendingNode;
 import org.truffleruby.language.NotOptimizedWarningNode;
 import org.truffleruby.language.RubyContextNode;
 
-public abstract class ReadCallerDataNode extends RubyContextNode implements FrameOrVariablesReadingNode {
+public abstract class ReadCallerDataNode extends RubyContextNode {
 
     private final ConditionProfile callerDataProfile = ConditionProfile.create();
     @Child private NotOptimizedWarningNode notOptimizedNode = null;

src/main/java/org/truffleruby/language/arguments/ReadCallerFrameAndVariablesNode.java

@@ -12,7 +12,6 @@
 import com.oracle.truffle.api.frame.Frame;
 import org.truffleruby.language.FrameAndVariablesSendingNode;
 
-import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.frame.MaterializedFrame;
 
 public class ReadCallerFrameNode extends ReadCallerDataNode {
@@ -41,17 +40,4 @@ protected Object getDataFromFrame(MaterializedFrame frame) {
         return frame;
     }
 
-    public void startSending(Reads variables, Reads frame) {
-        if (variables == Reads.SELF || frame == Reads.SELF) {
-            throw CompilerDirectives.shouldNotReachHere();
-        }
-        if (variables == Reads.CALLER) {
-            replace(new ReadCallerFrameAndVariablesNode(), "Starting to read caller frame and variables");
-        }
-    }
-
-
-    public boolean sendingFrame() {
-        return true;
-    }
 }

src/main/java/org/truffleruby/language/arguments/ReadCallerFrameNode.java

@@ -14,7 +14,6 @@
 import org.truffleruby.core.kernel.TruffleKernelNodes;
 import org.truffleruby.language.FrameAndVariablesSendingNode;
 
-import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.frame.MaterializedFrame;
 
 public class ReadCallerVariablesNode extends ReadCallerDataNode {
@@ -43,16 +42,4 @@ protected Object getDataFromFrame(MaterializedFrame frame) {
         return TruffleKernelNodes.GetSpecialVariableStorage.getSlow(frame);
     }
 
-    public void startSending(Reads variables, Reads frame) {
-        if (variables == Reads.SELF || frame == Reads.SELF) {
-            throw CompilerDirectives.shouldNotReachHere();
-        }
-        if (frame == Reads.CALLER) {
-            replace(new ReadCallerFrameAndVariablesNode(), "Starting to read caller frame and variables");
-        }
-    }
-
-    public boolean sendingFrame() {
-        return false;
-    }
 }