[GR-32001] Always-inline Kernel#respond_to? and Kernel#respond_to_missing?

PullRequest: truffleruby/3301

Author: eregon

spec/truffle/always_inlined_spec.rb

@@ -20,6 +20,15 @@
       }.should raise_error(TypeError) { |e| e.backtrace_locations[0].label.should == 'public_send' }
     end
 
+    it "for #respond_to?" do
+      -> {
+        respond_to?()
+      }.should raise_error(ArgumentError) { |e| e.backtrace_locations[0].label.should == 'respond_to?' }
+      -> {
+        respond_to?(Object.new)
+      }.should raise_error(TypeError) { |e| e.backtrace_locations[0].label.should == 'respond_to?' }
+    end
+
     it "for #block_given?" do
       -> {
         block_given?(:wrong)
@@ -191,6 +200,19 @@
     end
 
     guard -> { RUBY_ENGINE != "ruby" } do
+      it "for #respond_to?" do
+        obj = Object.new
+        def obj.respond_to_missing?(name, priv)
+          name == :foo ? raise("foo") : super
+        end
+        -> {
+          obj.respond_to?(:foo)
+        }.should raise_error(RuntimeError, "foo") { |e|
+          e.backtrace_locations[0].label.should == 'respond_to_missing?'
+          e.backtrace_locations[1].label.should.start_with?('block (5 levels)')
+        }
+      end
+
       it "for Method#call" do
         def method_to_call
           raise "foo"

src/main/java/org/truffleruby/core/array/ArrayNodes.java

@@ -21,7 +21,6 @@
 import org.graalvm.collections.EconomicSet;
 import org.graalvm.collections.Equivalence;
 import org.truffleruby.Layouts;
-import org.truffleruby.RubyLanguage;
 import org.truffleruby.builtins.CoreMethod;
 import org.truffleruby.builtins.CoreMethodArrayArgumentsNode;
 import org.truffleruby.builtins.CoreMethodNode;
@@ -1263,7 +1262,7 @@ protected RubyArray initializeFromArray(
                 guards = { "!isImplicitLong(object)", "wasProvided(object)", "!isRubyArray(object)" })
         protected RubyArray initialize(RubyArray array, Object object, NotProvided unusedValue, Nil block) {
             RubyArray copy = null;
-            if (respondToToAry(getLanguage(), object)) {
+            if (respondToToAry(object)) {
                 Object toAryResult = callToAry(object);
                 if (toAryResult instanceof RubyArray) {
                     copy = (RubyArray) toAryResult;
@@ -1278,13 +1277,12 @@ protected RubyArray initialize(RubyArray array, Object object, NotProvided unuse
             }
         }
 
-        public boolean respondToToAry(RubyLanguage language, Object object) {
+        public boolean respondToToAry(Object object) {
             if (respondToToAryNode == null) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
-                respondToToAryNode = insert(KernelNodesFactory.RespondToNodeFactory.create(null, null, null));
+                respondToToAryNode = insert(KernelNodesFactory.RespondToNodeFactory.create());
             }
-            return respondToToAryNode
-                    .executeDoesRespondTo(null, object, language.coreStrings.TO_ARY.createInstance(getContext()), true);
+            return respondToToAryNode.executeDoesRespondTo(object, coreSymbols().TO_ARY, true);
         }
 
         protected Object callToAry(Object object) {
@@ -1792,7 +1790,7 @@ protected Object reject(RubyArray array, RubyProc block,
                 for (; loopProfile.inject(n < arraySizeProfile.profile(array.size)); n++) {
                     final Object value = stores.read(store, n);
 
-                    if (!booleanCastNode.executeToBoolean(callBlock(block, value))) {
+                    if (!booleanCastNode.execute(callBlock(block, value))) {
                         arrayBuilder.appendValue(state, selectedSize, value);
                         selectedSize++;
                     }
@@ -1858,7 +1856,7 @@ private Object rejectInPlaceInternal(RubyArray array, RubyProc block, ArrayStore
             try {
                 for (; loop1Profile.inject(n < arraySizeProfile.profile(array.size)); n++) {
                     final Object value = stores.read(store, n);
-                    if (booleanCastNode.executeToBoolean(callBlock(block, value))) {
+                    if (booleanCastNode.execute(callBlock(block, value))) {
                         continue;
                     }
 
@@ -2082,7 +2080,7 @@ protected Object select(RubyArray array, RubyProc block,
                 for (; loopProfile.inject(n < arraySizeProfile.profile(array.size)); n++) {
                     final Object value = stores.read(store, n);
 
-                    if (booleanCastNode.executeToBoolean(callBlock(block, value))) {
+                    if (booleanCastNode.execute(callBlock(block, value))) {
                         arrayBuilder.appendValue(state, selectedSize, value);
                         selectedSize++;
                     }

src/main/java/org/truffleruby/core/basicobject/BasicObjectNodes.java

@@ -90,7 +90,7 @@ public abstract static class NotNode extends UnaryCoreMethodNode {
         @Specialization
         protected boolean not(Object value,
                 @Cached BooleanCastNode cast) {
-            return !cast.executeToBoolean(value);
+            return !cast.execute(value);
         }
 
     }
@@ -103,7 +103,7 @@ public abstract static class NotEqualNode extends CoreMethodArrayArgumentsNode {
 
         @Specialization
         protected boolean equal(VirtualFrame frame, Object a, Object b) {
-            return !booleanCastNode.executeToBoolean(equalNode.call(a, "==", b));
+            return !booleanCastNode.execute(equalNode.call(a, "==", b));
         }
 
     }

src/main/java/org/truffleruby/core/bool/FalseClassNodes.java

@@ -35,7 +35,7 @@ public abstract static class OrXorNode extends UnaryCoreMethodNode {
         @Specialization
         protected boolean orXor(Object other,
                 @Cached BooleanCastNode cast) {
-            return cast.executeToBoolean(other);
+            return cast.execute(other);
         }
 
     }

src/main/java/org/truffleruby/core/bool/TrueClassNodes.java

@@ -27,7 +27,7 @@ public abstract static class AndNode extends UnaryCoreMethodNode {
         @Specialization
         protected boolean and(Object other,
                 @Cached BooleanCastNode cast) {
-            return cast.executeToBoolean(other);
+            return cast.execute(other);
         }
     }
 
@@ -46,7 +46,7 @@ public abstract static class XorNode extends UnaryCoreMethodNode {
         @Specialization
         protected boolean xor(Object other,
                 @Cached BooleanCastNode cast) {
-            return !cast.executeToBoolean(other);
+            return !cast.execute(other);
         }
     }
 

src/main/java/org/truffleruby/core/cast/BooleanCastNode.java

@@ -36,10 +36,10 @@ public static BooleanCastNode create() {
     }
 
     /** Execute with child node */
-    public abstract boolean executeBoolean(VirtualFrame frame);
+    public abstract boolean execute(VirtualFrame frame);
 
     /** Execute with given value */
-    public abstract boolean executeToBoolean(Object value);
+    public abstract boolean execute(Object value);
 
     @Specialization
     protected boolean doNil(Nil nil) {

src/main/java/org/truffleruby/core/cast/BooleanCastWithDefaultNode.java

@@ -39,7 +39,7 @@ protected boolean doDefault(NotProvided value) {
     @Fallback
     protected boolean fallback(Object value,
             @Cached BooleanCastNode booleanCastNode) {
-        return booleanCastNode.executeToBoolean(value);
+        return booleanCastNode.execute(value);
     }
 
 }

src/main/java/org/truffleruby/core/cast/CmpIntNode.java

@@ -84,11 +84,11 @@ protected int cmpObject(Object value, Object receiver, Object other,
             @Cached BooleanCastNode gtCastNode,
             @Cached BooleanCastNode ltCastNode) {
 
-        if (gtCastNode.executeToBoolean(gtNode.call(value, ">", 0))) {
+        if (gtCastNode.execute(gtNode.call(value, ">", 0))) {
             return 1;
         }
 
-        if (ltCastNode.executeToBoolean(ltNode.call(value, "<", 0))) {
+        if (ltCastNode.execute(ltNode.call(value, "<", 0))) {
             return -1;
         }
 

src/main/java/org/truffleruby/core/hash/library/PackedHashStoreLibrary.java

@@ -546,7 +546,7 @@ private boolean callEqual(Object receiver, Object key) {
                 booleanCastNode = insert(BooleanCastNode.create());
             }
 
-            return booleanCastNode.executeToBoolean(equalNode.call(receiver, "eql?", key));
+            return booleanCastNode.execute(equalNode.call(receiver, "eql?", key));
         }
     }
 

src/main/java/org/truffleruby/core/inlined/AlwaysInlinedMethodNode.java

@@ -19,14 +19,14 @@
 import org.truffleruby.language.control.RaiseException;
 
 /** A core method that should always be executed inline, without going through a CallTarget. That enables accessing the
- * caller frame efficiently and reliably.
+ * caller frame efficiently and reliably. It also means there is a copy/"split" of that core method for every call site.
  * <p>
  * If called from a foreign language, then the caller frame will be null. The node should check using
- * {@link #needCallerFrame(Frame, RootCallTarget)} that the caller frame is not null before using it (if it uses it), in
- * order to provide a useful exception in that case.
+ * {@link #needCallerFrame(Frame, RootCallTarget)} that the caller frame is not null before using it (if it needs it),
+ * in order to provide a useful exception in that case.
  * <p>
  * Such a method will not appear in backtraces. However, Ruby exceptions emitted from this node will be resent through a
- * CallTarget to get the proper backtrace.
+ * CallTarget to get the proper backtrace. This should be tested in spec/truffle/always_inlined_spec.rb.
  * <p>
  * Such a core method should not emit significantly more Graal nodes than a non-inlined call, as Truffle cannot decide
  * to not inline it, and that could lead to too big methods to compile. */