Use CallInternalMethodNode instead of DirectCallNode for the CallTarget of Method#to_proc

Author: eregon

spec/truffle/always_inlined_spec.rb

@@ -113,4 +113,12 @@
     obj = Class.new { attr_reader(*names) }.new
     names.each { |name| obj.send(name).should == nil }
   end
+
+  it "work with each(&method(:always_inlined_method))" do
+    obj = Class.new do
+      [:foo].each(&method(:attr_accessor))
+    end.new
+    obj.foo = 42
+    obj.foo.should == 42
+  end
 end

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

@@ -19,6 +19,8 @@
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.frame.VirtualFrame;
 
+import java.util.Arrays;
+
 public class ReRaiseInlinedExceptionNode extends RubyContextSourceNode {
 
     public final NodeFactory<? extends RubyBaseNode> nodeFactory;
@@ -31,8 +33,10 @@ public ReRaiseInlinedExceptionNode(NodeFactory<? extends RubyBaseNode> nodeFacto
     public Object execute(VirtualFrame frame) {
         final Object[] arguments = frame.getArguments();
         if (arguments.length != 1 || !(arguments[0] instanceof RaiseException)) {
+            CompilerDirectives.transferToInterpreterAndInvalidate();
             throw CompilerDirectives.shouldNotReachHere(
-                    "CallTarget of always-inlined builtin should be called with a single RaiseException argument");
+                    "CallTarget of always-inlined builtin should be called with a single RaiseException argument" +
+                            ", but was called with: " + Arrays.toString(arguments));
         }
 
         final RaiseException raiseException = (RaiseException) arguments[0];

src/main/java/org/truffleruby/core/method/MethodNodes.java

@@ -38,6 +38,7 @@
 import org.truffleruby.language.arguments.RubyArguments;
 import org.truffleruby.language.control.RaiseException;
 import org.truffleruby.language.methods.CallBoundMethodNode;
+import org.truffleruby.language.methods.CallInternalMethodNode;
 import org.truffleruby.language.methods.InternalMethod;
 import org.truffleruby.language.objects.AllocationTracing;
 import org.truffleruby.language.objects.MetaClassNode;
@@ -51,7 +52,6 @@
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.MaterializedFrame;
 import com.oracle.truffle.api.frame.VirtualFrame;
-import com.oracle.truffle.api.nodes.DirectCallNode;
 import com.oracle.truffle.api.nodes.RootNode;
 import com.oracle.truffle.api.source.SourceSection;
 
@@ -132,8 +132,7 @@ public abstract static class CallNode extends CoreMethodArrayArgumentsNode {
 
         @Specialization
         protected Object call(VirtualFrame frame, RubyMethod method, Object[] arguments, Object maybeBlock) {
-            return callBoundMethodNode
-                    .execute(frame, method, arguments, maybeBlock);
+            return callBoundMethodNode.execute(frame, method, arguments, maybeBlock);
         }
 
     }
@@ -320,20 +319,21 @@ private RubyProc createProc(RootCallTarget callTarget, InternalMethod method, Ob
         protected RootCallTarget methodCallTarget(InternalMethod method) {
             // translate to something like:
             // lambda { |same args list| method.call(args) }
-            // We need to preserve the method receiver and we want to have the same argument list
+            // We need to preserve the method receiver and we want to have the same argument list.
+            // We create a new CallTarget for the Proc that calls the method CallTarget and passes the correct receiver.
 
             final SourceSection sourceSection = method.getSharedMethodInfo().getSourceSection();
-            final RubyRootNode oldRootNode = RubyRootNode.of(method.getCallTarget());
+            final RubyRootNode methodRootNode = RubyRootNode.of(method.getCallTarget());
 
-            final SetReceiverNode setReceiverNode = new SetReceiverNode(method.getCallTarget());
-            final RootNode newRootNode = new RubyRootNode(
+            final SetReceiverNode setReceiverNode = new SetReceiverNode(method);
+            final RootNode wrapRootNode = new RubyRootNode(
                     getLanguage(),
                     sourceSection,
-                    oldRootNode.getFrameDescriptor(),
+                    methodRootNode.getFrameDescriptor(),
                     method.getSharedMethodInfo(),
                     setReceiverNode,
-                    oldRootNode.getSplit());
-            return Truffle.getRuntime().createCallTarget(newRootNode);
+                    methodRootNode.getSplit());
+            return Truffle.getRuntime().createCallTarget(wrapRootNode);
         }
 
         protected int getCacheLimit() {
@@ -378,23 +378,24 @@ protected boolean unbound(RubyUnboundMethod rubyMethod) {
     }
 
     private static class SetReceiverNode extends RubyContextSourceNode {
+        private final InternalMethod method;
+        @Child private CallInternalMethodNode callInternalMethodNode = CallInternalMethodNode.create();
 
-        @Child private DirectCallNode methodCallNode;
-
-        public SetReceiverNode(RootCallTarget methodCallTarget) {
-            this.methodCallNode = DirectCallNode.create(methodCallTarget);
+        public SetReceiverNode(InternalMethod method) {
+            this.method = method;
         }
 
         @Override
         public Object execute(VirtualFrame frame) {
-            Object receiver = RubyArguments.getSelf(RubyArguments.getDeclarationFrame(frame));
-            RubyArguments.setSelf(frame, receiver);
-            /* Remove the declaration frame from the arguments so that the method will not see the special variables
-             * associated with the proc. This matches the behaviour in MRI. */
-            RubyArguments.setDeclarationFrame(frame, null);
-            return methodCallNode.call(frame.getArguments());
+            final Object originalBoundMethodReceiver = RubyArguments.getSelf(RubyArguments.getDeclarationFrame(frame));
+            return callInternalMethodNode.execute(
+                    frame,
+                    null,
+                    method,
+                    originalBoundMethodReceiver,
+                    RubyArguments.getBlock(frame),
+                    RubyArguments.getArguments(frame));
         }
-
     }
 
     @CoreMethod(names = { "__allocate__", "__layout_allocate__" }, constructor = true, visibility = Visibility.PRIVATE)

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

@@ -142,15 +142,6 @@ public static SpecialVariableStorage getCallerStorage(Frame frame) {
         }
     }
 
-    public static FrameAndVariables getCallerFrameAndVariables(Frame frame) {
-        Object frameOrVariables = frame.getArguments()[ArgumentIndicies.CALLER_FRAME_OR_VARIABLES.ordinal()];
-        if (frameOrVariables instanceof FrameAndVariables) {
-            return (FrameAndVariables) frameOrVariables;
-        } else {
-            return null;
-        }
-    }
-
     public static InternalMethod getMethod(Frame frame) {
         return (InternalMethod) frame.getArguments()[ArgumentIndicies.METHOD.ordinal()];
     }