jruby · Jul 28, 2015 · Jul 28, 2015 · Jul 28, 2015
diff --git a/spec/truffle/tags/core/kernel/respond_to_missing_tags.txt b/spec/truffle/tags/core/kernel/respond_to_missing_tags.txt
@@ -1,10 +1 @@
-fails:Kernel#respond_to_missing? is called with a 2nd argument of false when #respond_to? is
-fails:Kernel#respond_to_missing? is called a 2nd argument of false when #respond_to? is called with only 1 argument
-fails:Kernel#respond_to_missing? is called with true as the second argument when #respond_to? is
-fails:Kernel#respond_to_missing? is called when #respond_to? would return false
-fails:Kernel#respond_to_missing? causes #respond_to? to return true if called and not returning false
-fails:Kernel#respond_to_missing? causes #respond_to? to return false if called and returning false
-fails:Kernel#respond_to_missing? causes #respond_to? to return false if called and returning nil
 fails:Kernel#respond_to_missing? is called when obj responds to the given protected method, include_private = false
-fails:Kernel#respond_to_missing? is called when obj responds to the given private method, include_private = false
-fails:Kernel#respond_to_missing? is called for missing class methods
diff --git a/spec/truffle/tags/core/kernel/respond_to_tags.txt b/spec/truffle/tags/core/kernel/respond_to_tags.txt
@@ -1,3 +1,2 @@
-fails:Kernel#respond_to? returns false if the given method was undefined
 fails:Kernel#respond_to? returns false if obj responds to the given protected method
 fails:Kernel#respond_to? returns false if obj responds to the given protected method (include_private = false)
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/KernelNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/KernelNodes.java
@@ -1604,6 +1604,7 @@ public abstract static class RespondToNode extends CoreMethodNode {
 
         @Child private DoesRespondDispatchHeadNode dispatch;
         @Child private DoesRespondDispatchHeadNode dispatchIgnoreVisibility;
+        @Child private CallDispatchHeadNode respondToMissingNode;
         private final ConditionProfile ignoreVisibilityProfile = ConditionProfile.createBinaryProfile();
 
         public RespondToNode(RubyContext context, SourceSection sourceSection) {
@@ -1627,22 +1628,46 @@ public RubyNode coerceToBoolean(RubyNode includeProtectedAndPrivate) {
 
         @Specialization(guards = "isRubyString(name)")
         public boolean doesRespondToString(VirtualFrame frame, Object object, RubyBasicObject name, boolean includeProtectedAndPrivate) {
+            final boolean ret;
+
             if (ignoreVisibilityProfile.profile(includeProtectedAndPrivate)) {
-                return dispatchIgnoreVisibility.doesRespondTo(frame, name, object);
+                ret = dispatchIgnoreVisibility.doesRespondTo(frame, name, object);
             } else {
-                return dispatch.doesRespondTo(frame, name, object);
+                ret = dispatch.doesRespondTo(frame, name, object);
+            }
+
+            if (ret) {
+                return true;
+            } else {
+                return respondToMissing(frame, object, name, includeProtectedAndPrivate);
             }
         }
 
         @Specialization(guards = "isRubySymbol(name)")
         public boolean doesRespondToSymbol(VirtualFrame frame, Object object, RubyBasicObject name, boolean includeProtectedAndPrivate) {
+            final boolean ret;
+
             if (ignoreVisibilityProfile.profile(includeProtectedAndPrivate)) {
-                return dispatchIgnoreVisibility.doesRespondTo(frame, name, object);
+                ret = dispatchIgnoreVisibility.doesRespondTo(frame, name, object);
+            } else {
+                ret = dispatch.doesRespondTo(frame, name, object);
+            }
+
+            if (ret) {
+                return true;
             } else {
-                return dispatch.doesRespondTo(frame, name, object);
+                return respondToMissing(frame, object, name, includeProtectedAndPrivate);
             }
         }
 
+        private boolean respondToMissing(VirtualFrame frame, Object object, RubyBasicObject name, boolean includeProtectedAndPrivate) {
+            if (respondToMissingNode == null) {
+                CompilerDirectives.transferToInterpreter();
+                respondToMissingNode = insert(DispatchHeadNodeFactory.createMethodCall(getContext(), true));
+            }
+
+            return respondToMissingNode.callBoolean(frame, object, "respond_to_missing?", null, name, includeProtectedAndPrivate);
+        }
     }
 
     @CoreMethod(names = "respond_to_missing?", required = 2)

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/dispatch/UnresolvedDispatchNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/dispatch/UnresolvedDispatchNode.java
@@ -12,6 +12,9 @@
 import com.oracle.truffle.api.Assumption;
 import com.oracle.truffle.api.CompilerAsserts;
 import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.Truffle;
+import com.oracle.truffle.api.frame.Frame;
+import com.oracle.truffle.api.frame.FrameInstance;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.interop.TruffleObject;
 import com.oracle.truffle.interop.messages.Argument;
@@ -170,7 +173,16 @@ private DispatchNode doRubyBasicObject(
             Object receiverObject,
             Object methodName,
             Object argumentsObjects) {
-        final RubyBasicObject callerClass = ignoreVisibility ? null : getContext().getCoreLibrary().getMetaClass(RubyArguments.getSelf(frame.getArguments()));
+        final RubyBasicObject callerClass;
+
+        if (ignoreVisibility) {
+            callerClass = null;
+        } else if (getDispatchAction() == DispatchAction.RESPOND_TO_METHOD) {
+            final Frame callerFrame = Truffle.getRuntime().getCallerFrame().getFrame(FrameInstance.FrameAccess.READ_ONLY, false);
+            callerClass = getContext().getCoreLibrary().getMetaClass(RubyArguments.getSelf(callerFrame.getArguments()));
+        } else {
+            callerClass = getContext().getCoreLibrary().getMetaClass(RubyArguments.getSelf(frame.getArguments()));
+        }
 
         final InternalMethod method = lookup(callerClass, receiverObject, toString(methodName), ignoreVisibility);