Convert ToRubyIntegerNode to DSL inlinable

Author: horakivo

src/main/java/org/truffleruby/core/VMPrimitiveNodes.java

@@ -475,7 +475,7 @@ protected Object startHashNotNumber(Object salt,
                 @Cached InlinedConditionProfile isIntegerProfile,
                 @Cached InlinedConditionProfile isLongProfile,
                 @Cached InlinedConditionProfile isBignumProfile) {
-            Object result = toRubyInteger.execute(salt);
+            Object result = toRubyInteger.execute(this, salt);
             if (isIntegerProfile.profile(this, result instanceof Integer)) {
                 return getContext().getHashing(this).start((int) result);
             } else if (isLongProfile.profile(this, result instanceof Long)) {
@@ -508,7 +508,7 @@ protected Object updateHash(long hash, Object value,
                 @Cached InlinedConditionProfile isIntegerProfile,
                 @Cached InlinedConditionProfile isLongProfile,
                 @Cached InlinedConditionProfile isBignumProfile) {
-            Object result = toRubyInteger.execute(value);
+            Object result = toRubyInteger.execute(this, value);
             if (isIntegerProfile.profile(this, result instanceof Integer)) {
                 return Hashing.update(hash, (int) result);
             } else if (isLongProfile.profile(this, result instanceof Long)) {

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

@@ -9,8 +9,10 @@
  */
 package org.truffleruby.core.cast;
 
+import com.oracle.truffle.api.dsl.GenerateCached;
+import com.oracle.truffle.api.dsl.GenerateInline;
 import com.oracle.truffle.api.dsl.GenerateUncached;
-import com.oracle.truffle.api.dsl.NeverDefault;
+import com.oracle.truffle.api.nodes.Node;
 import org.truffleruby.core.numeric.RubyBignum;
 import org.truffleruby.language.RubyBaseNode;
 import org.truffleruby.language.dispatch.DispatchNode;
@@ -20,33 +22,30 @@
 
 /** See {@link ToIntNode} for a comparison of different integer conversion nodes. */
 @GenerateUncached
+@GenerateInline
+@GenerateCached(false)
 public abstract class ToRubyIntegerNode extends RubyBaseNode {
 
-    @NeverDefault
-    public static ToRubyIntegerNode create() {
-        return ToRubyIntegerNodeGen.create();
-    }
-
-    public abstract Object execute(Object object);
+    public abstract Object execute(Node node, Object object);
 
     @Specialization
-    protected int coerceInt(int value) {
+    protected static int coerceInt(int value) {
         return value;
     }
 
     @Specialization
-    protected long coerceLong(long value) {
+    protected static long coerceLong(long value) {
         return value;
     }
 
     @Specialization
-    protected RubyBignum coerceRubyBignum(RubyBignum value) {
+    protected static RubyBignum coerceRubyBignum(RubyBignum value) {
         return value;
     }
 
     @Specialization(guards = "!isRubyInteger(object)")
-    protected Object coerceObject(Object object,
+    protected static Object coerceObject(Node node, Object object,
             @Cached DispatchNode toIntNode) {
-        return toIntNode.call(coreLibrary().truffleTypeModule, "rb_to_int_fallback", object);
+        return toIntNode.call(coreLibrary(node).truffleTypeModule, "rb_to_int_fallback", object);
     }
 }

src/main/java/org/truffleruby/core/hash/HashingNodes.java

@@ -167,11 +167,11 @@ protected static int castBignum(RubyBignum hashed) {
         }
 
         @Specialization(guards = "!isRubyInteger(hashed)")
-        protected static int castOther(Object hashed,
+        protected static int castOther(Node node, Object hashed,
                 @Cached ToRubyIntegerNode toRubyInteger,
                 //recursive inlining is not supported
                 @Cached(inline = false) HashCastResultNode hashCastResult) {
-            return hashCastResult.executeCached(toRubyInteger.execute(hashed));
+            return hashCastResult.executeCached(toRubyInteger.execute(node, hashed));
         }
     }
 }

src/main/java/org/truffleruby/core/numeric/IntegerNodes.java

@@ -13,11 +13,13 @@
 import java.math.BigInteger;
 import java.math.RoundingMode;
 
+import com.oracle.truffle.api.dsl.Bind;
 import com.oracle.truffle.api.dsl.Cached.Shared;
 import com.oracle.truffle.api.dsl.Cached.Exclusive;
 import com.oracle.truffle.api.dsl.Fallback;
 import com.oracle.truffle.api.dsl.Idempotent;
 import com.oracle.truffle.api.dsl.NeverDefault;
+import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.profiles.InlinedBranchProfile;
 import com.oracle.truffle.api.profiles.InlinedConditionProfile;
 import com.oracle.truffle.api.profiles.InlinedLoopConditionProfile;
@@ -1261,10 +1263,11 @@ protected Object leftShiftNeg(Object a, RubyBignum b) {
         // Coercion
 
         @Specialization(guards = "!isRubyInteger(b)")
-        protected Object leftShiftCoerced(Object a, Object b,
+        protected static Object leftShiftCoerced(Object a, Object b,
                 @Cached ToRubyIntegerNode toRubyIntNode,
-                @Cached LeftShiftNode leftShiftNode) {
-            return leftShiftNode.executeLeftShift(a, toRubyIntNode.execute(b));
+                @Cached LeftShiftNode leftShiftNode,
+                @Bind("this") Node node) {
+            return leftShiftNode.executeLeftShift(a, toRubyIntNode.execute(node, b));
         }
 
         private Object negateAndRightShift(Object a, Object b) {
@@ -1380,10 +1383,11 @@ protected Object rightShiftNeg(Object a, RubyBignum b) {
         // Coercion
 
         @Specialization(guards = "!isRubyInteger(b)")
-        protected Object rightShiftCoerced(Object a, Object b,
+        protected static Object rightShiftCoerced(Object a, Object b,
                 @Cached ToRubyIntegerNode toRubyIntNode,
-                @Cached RightShiftNode rightShiftNode) {
-            return rightShiftNode.executeRightShift(a, toRubyIntNode.execute(b));
+                @Cached RightShiftNode rightShiftNode,
+                @Bind("this") Node node) {
+            return rightShiftNode.executeRightShift(a, toRubyIntNode.execute(node, b));
         }
 
         private Object negateAndLeftShift(Object a, Object b) {

src/main/java/org/truffleruby/core/support/TypeNodes.java

@@ -426,11 +426,11 @@ protected int numToInt(Object value) {
 
     @Primitive(name = "rb_to_int")
     public abstract static class RbToIntNode extends PrimitiveArrayArgumentsNode {
-        @Child private ToRubyIntegerNode toRubyInteger = ToRubyIntegerNode.create();
 
         @Specialization
-        protected Object toRubyInteger(Object value) {
-            return toRubyInteger.execute(value);
+        protected Object toRubyInteger(Object value,
+                @Cached ToRubyIntegerNode toRubyInteger) {
+            return toRubyInteger.execute(this, value);
         }
     }