Use the correct guards to account for implicit casts in RubyTypes

eregon · eregon · commit bcb684697f8c · 2021-03-04T18:20:24.000+01:00
diff --git a/src/main/java/org/truffleruby/cext/IsNativeObjectNode.java b/src/main/java/org/truffleruby/cext/IsNativeObjectNode.java
@@ -11,6 +11,7 @@
 
 import static org.truffleruby.cext.ValueWrapperManager.isMallocAligned;
 
+import com.oracle.truffle.api.dsl.Fallback;
 import org.truffleruby.language.RubyBaseNode;
 
 import com.oracle.truffle.api.dsl.GenerateUncached;
@@ -29,7 +30,7 @@ protected boolean isNativeObjectTaggedObject(long handle) {
         return isMallocAligned(handle) && handle < ValueWrapperManager.ALLOCATION_BASE;
     }
 
-    @Specialization(guards = "!isLong(handle)")
+    @Fallback
     protected boolean isNativeObjectFallback(Object handle) {
         return false;
     }
diff --git a/src/main/java/org/truffleruby/core/array/ArrayNodes.java b/src/main/java/org/truffleruby/core/array/ArrayNodes.java
@@ -212,7 +212,7 @@ protected RubyArray mulEmpty(RubyArray array, long count) {
                     0);
         }
 
-        @Specialization(guards = { "!isInteger(count)", "!isLong(count)" })
+        @Specialization(guards = { "!isImplicitLong(count)" })
         protected Object fallback(RubyArray array, Object count) {
             return FAILURE;
         }
@@ -284,7 +284,7 @@ protected Object indexRange(RubyArray array, RubyRange range, NotProvided length
             return readSlice.executeReadSlice(array, startLength[0], len);
         }
 
-        @Specialization(guards = { "!isInteger(index)", "!isRubyRange(index)" })
+        @Specialization(guards = { "!isImplicitInteger(index)", "!isRubyRange(index)" })
         protected Object indexFallback(RubyArray array, Object index, NotProvided length,
                 @Cached AtNode accessWithIndexConversion) {
             return accessWithIndexConversion.executeAt(array, index);
@@ -303,7 +303,7 @@ protected Object slice(RubyArray array, int start, int length,
             return readSliceNode.executeReadSlice(array, start, length);
         }
 
-        @Specialization(guards = { "wasProvided(length)", "!isInteger(start) || !isInteger(length)" })
+        @Specialization(guards = { "wasProvided(length)", "!isImplicitInteger(start) || !isImplicitInteger(length)" })
         protected Object sliceFallback(RubyArray array, Object start, Object length,
                 @Cached ToIntNode indexToInt,
                 @Cached ToIntNode lengthToInt) {
@@ -359,7 +359,7 @@ protected Object setRange(RubyArray array, RubyRange range, Object value, NotPro
             return executeIntIndices(array, start, length, value);
         }
 
-        @Specialization(guards = { "!isInteger(start)", "!isRubyRange(start)" })
+        @Specialization(guards = { "!isImplicitInteger(start)", "!isRubyRange(start)" })
         protected Object fallbackBinary(RubyArray array, Object start, Object value, NotProvided unused,
                 @Cached ToIntNode toInt) {
             return executeIntIndex(array, toInt.execute(start), value, unused);
@@ -423,7 +423,8 @@ protected Object setTernary(RubyArray array, int start, int length, Object repla
             return replacement;
         }
 
-        @Specialization(guards = { "!isInteger(start) || !isInteger(length)", "wasProvided(replacement)" })
+        @Specialization(
+                guards = { "!isImplicitInteger(start) || !isImplicitInteger(length)", "wasProvided(replacement)" })
         protected Object fallbackTernary(RubyArray array, Object start, Object length, Object replacement,
                 @Cached ToIntNode startToInt,
                 @Cached ToIntNode lengthToInt) {
@@ -1133,7 +1134,7 @@ protected RubyArray initializeWithSizeAndValue(RubyArray array, int size, Object
         }
 
         @Specialization(
-                guards = { "wasProvided(size)", "!isInteger(size)", "!isLong(size)", "wasProvided(fillingValue)" })
+                guards = { "wasProvided(size)", "!isImplicitLong(size)", "wasProvided(fillingValue)" })
         protected RubyArray initializeSizeOther(RubyArray array, Object size, Object fillingValue, Nil block) {
             int intSize = toInt(size);
             return executeInitialize(array, intSize, fillingValue, block);
@@ -1173,7 +1174,7 @@ protected RubyArray initializeFromArray(
         }
 
         @Specialization(
-                guards = { "!isInteger(object)", "!isLong(object)", "wasProvided(object)", "!isRubyArray(object)" })
+                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)) {
@@ -1608,7 +1609,7 @@ protected RubyArray popNotEmptyUnsharedStorage(RubyArray array, int n,
             return createArray(popped, numPop);
         }
 
-        @Specialization(guards = { "wasProvided(n)", "!isInteger(n)", "!isLong(n)" })
+        @Specialization(guards = { "wasProvided(n)", "!isImplicitInteger(n)" })
         protected Object popNToInt(RubyArray array, Object n,
                 @Cached ToIntNode toIntNode) {
             return executePop(array, toIntNode.execute(n));
@@ -2038,7 +2039,7 @@ protected Object shiftMany(RubyArray array, int n,
             return createArray(result, numShift);
         }
 
-        @Specialization(guards = { "wasProvided(n)", "!isInteger(n)", "!isLong(n)" })
+        @Specialization(guards = { "wasProvided(n)", "!isImplicitInteger(n)" })
         protected Object shiftNToInt(RubyArray array, Object n,
                 @Cached ToIntNode toIntNode) {
             return executeShift(array, toIntNode.execute(n));
diff --git a/src/main/java/org/truffleruby/core/cast/ToIntNode.java b/src/main/java/org/truffleruby/core/cast/ToIntNode.java
@@ -107,7 +107,7 @@ protected long coerceNil(Nil value) {
                 coreExceptions().typeError("no implicit conversion from nil to integer", this));
     }
 
-    @Specialization(guards = { "!isRubyInteger(object)", "!isDouble(object)", "!isNil(object)" })
+    @Specialization(guards = { "!isRubyInteger(object)", "!isImplicitDouble(object)", "!isNil(object)" })
     protected int coerceObject(Object object,
             @Cached DispatchNode toIntNode,
             @Cached ToIntNode fitNode) {
diff --git a/src/main/java/org/truffleruby/core/cast/ToLongNode.java b/src/main/java/org/truffleruby/core/cast/ToLongNode.java
@@ -77,7 +77,7 @@ protected long coerceNil(Nil nil) {
                 coreExceptions().typeError("no implicit conversion from nil to integer", this));
     }
 
-    @Specialization(guards = { "!isRubyInteger(object)", "!isDouble(object)", "!isNil(object)" })
+    @Specialization(guards = { "!isRubyInteger(object)", "!isImplicitDouble(object)", "!isNil(object)" })
     protected long coerceObject(Object object,
             @Cached DispatchNode toIntNode,
             @Cached ToLongNode fitNode) {
diff --git a/src/main/java/org/truffleruby/core/format/format/FormatFloatHumanReadableNode.java b/src/main/java/org/truffleruby/core/format/format/FormatFloatHumanReadableNode.java
@@ -20,18 +20,18 @@
 public abstract class FormatFloatHumanReadableNode extends FormatNode {
 
     @TruffleBoundary
-    @Specialization(guards = "isInteger(value)")
+    @Specialization(guards = "isIntegerValue(value)")
     protected byte[] formatInteger(double value) {
         return RopeOperations.encodeAsciiBytes(String.valueOf((long) value));
     }
 
     @TruffleBoundary
-    @Specialization(guards = "!isInteger(value)")
+    @Specialization(guards = "!isIntegerValue(value)")
     protected byte[] format(double value) {
         return RopeOperations.encodeAsciiBytes(String.valueOf(value));
     }
 
-    protected boolean isInteger(double value) {
+    protected boolean isIntegerValue(double value) {
         /** General approach taken from StackOverflow:
          * http://stackoverflow.com/questions/703396/how-to-nicely-format-floating-numbers-to-string-without-unnecessary
          * -decimal-0 Answers provided by JasonD (http://stackoverflow.com/users/1288598/jasond) and Darthenius
diff --git a/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java b/src/main/java/org/truffleruby/core/numeric/FixnumLowerNode.java
@@ -51,7 +51,7 @@ protected long lowerFails(long value) {
         return value;
     }
 
-    @Specialization(guards = { "!isInteger(value)", "!isLong(value)" })
+    @Specialization(guards = "!isImplicitLong(value)")
     protected Object passThrough(Object value) {
         return value;
     }
diff --git a/src/main/java/org/truffleruby/core/numeric/FloatNodes.java b/src/main/java/org/truffleruby/core/numeric/FloatNodes.java
@@ -345,7 +345,7 @@ protected boolean eql(double a, double b) {
             return a == b;
         }
 
-        @Specialization(guards = { "!isDouble(b)" })
+        @Specialization(guards = { "!isImplicitDouble(b)" })
         protected boolean eqlGeneral(double a, Object b) {
             return false;
         }
diff --git a/src/main/java/org/truffleruby/core/regexp/MatchDataNodes.java b/src/main/java/org/truffleruby/core/regexp/MatchDataNodes.java
@@ -315,7 +315,7 @@ protected Object getIndexString(RubyMatchData matchData, Object index, NotProvid
 
         @Specialization(
                 guards = {
-                        "!isInteger(index)",
+                        "!isImplicitInteger(index)",
                         "!isRubySymbol(index)",
                         "isNotRubyString(index)",
                         "!isIntRange(index)" })
diff --git a/src/main/java/org/truffleruby/core/string/StringNodes.java b/src/main/java/org/truffleruby/core/string/StringNodes.java
@@ -2611,10 +2611,7 @@ protected Object sum(Object string, NotProvided bits,
             return sum(string, 16, strings);
         }
 
-        @Specialization(guards = {
-                "!isInteger(bits)",
-                "!isLong(bits)",
-                "wasProvided(bits)" })
+        @Specialization(guards = { "!isImplicitLong(bits)", "wasProvided(bits)" })
         protected Object sum(Object string, Object bits,
                 @Cached ToLongNode toLongNode,
                 @Cached SumNode sumNode) {
diff --git a/src/main/java/org/truffleruby/core/time/TimeNodes.java b/src/main/java/org/truffleruby/core/time/TimeNodes.java
@@ -483,7 +483,7 @@ protected RubyTime timeSFromArray(
             return buildTime(language, timeClass, sec, min, hour, mday, month, year, nsec, isdst, isutc, utcoffset);
         }
 
-        @Specialization(guards = "!isInteger(sec) || !isInteger(nsec)")
+        @Specialization(guards = "!isImplicitInteger(sec) || !isImplicitInteger(nsec)")
         protected Object timeSFromArrayFallback(
                 RubyClass timeClass,
                 Object sec,
diff --git a/src/main/java/org/truffleruby/language/RubyGuards.java b/src/main/java/org/truffleruby/language/RubyGuards.java
@@ -34,22 +34,10 @@ public abstract class RubyGuards {
 
     // Basic Java types
 
-    public static boolean isInteger(Object value) {
-        return value instanceof Integer;
-    }
-
     public static boolean fitsInInteger(long value) {
         return CoreLibrary.fitsIntoInteger(value);
     }
 
-    public static boolean isLong(Object value) {
-        return value instanceof Long;
-    }
-
-    public static boolean isDouble(Object value) {
-        return value instanceof Double;
-    }
-
     public static boolean isCharacter(Object value) {
         return value instanceof Character;
     }
@@ -58,14 +46,20 @@ public static boolean isString(Object value) {
         return value instanceof String;
     }
 
-    public static boolean isImplicitDouble(Object object) {
-        return object instanceof Float || object instanceof Double;
+    // no isInteger/isLong/isDouble, use isImplicit* instead in guards to account for implicit casts of RubyTypes
+
+    public static boolean isImplicitInteger(Object object) {
+        return object instanceof Byte || object instanceof Short || object instanceof Integer;
     }
 
     public static boolean isImplicitLong(Object object) {
         return object instanceof Byte || object instanceof Short || object instanceof Integer || object instanceof Long;
     }
 
+    public static boolean isImplicitDouble(Object object) {
+        return object instanceof Float || object instanceof Double;
+    }
+
     public static boolean isImplicitLongOrDouble(Object object) {
         return object instanceof Byte || object instanceof Short || object instanceof Integer ||
                 object instanceof Long || object instanceof Float || object instanceof Double;

Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@`
`11`	`11`
`12`	`12`	`import static org.truffleruby.cext.ValueWrapperManager.isMallocAligned;`
`13`	`13`
	`14`	`+import com.oracle.truffle.api.dsl.Fallback;`
`14`	`15`	`import org.truffleruby.language.RubyBaseNode;`
`15`	`16`
`16`	`17`	`import com.oracle.truffle.api.dsl.GenerateUncached;`
`@@ -29,7 +30,7 @@ protected boolean isNativeObjectTaggedObject(long handle) {`
`29`	`30`	`return isMallocAligned(handle) && handle < ValueWrapperManager.ALLOCATION_BASE;`
`30`	`31`	`}`
`31`	`32`
`32`		`- @Specialization(guards = "!isLong(handle)")`
	`33`	`+ @Fallback`
`33`	`34`	`protected boolean isNativeObjectFallback(Object handle) {`
`34`	`35`	`return false;`
`35`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ protected long coerceNil(Nil value) {`
`107`	`107`	`coreExceptions().typeError("no implicit conversion from nil to integer", this));`
`108`	`108`	`}`
`109`	`109`
`110`		`- @Specialization(guards = { "!isRubyInteger(object)", "!isDouble(object)", "!isNil(object)" })`
	`110`	`+ @Specialization(guards = { "!isRubyInteger(object)", "!isImplicitDouble(object)", "!isNil(object)" })`
`111`	`111`	`protected int coerceObject(Object object,`
`112`	`112`	`@Cached DispatchNode toIntNode,`
`113`	`113`	`@Cached ToIntNode fitNode) {`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ protected long coerceNil(Nil nil) {`
`77`	`77`	`coreExceptions().typeError("no implicit conversion from nil to integer", this));`
`78`	`78`	`}`
`79`	`79`
`80`		`- @Specialization(guards = { "!isRubyInteger(object)", "!isDouble(object)", "!isNil(object)" })`
	`80`	`+ @Specialization(guards = { "!isRubyInteger(object)", "!isImplicitDouble(object)", "!isNil(object)" })`
`81`	`81`	`protected long coerceObject(Object object,`
`82`	`82`	`@Cached DispatchNode toIntNode,`
`83`	`83`	`@Cached ToLongNode fitNode) {`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ protected long lowerFails(long value) {`
`51`	`51`	`return value;`
`52`	`52`	`}`
`53`	`53`
`54`		`- @Specialization(guards = { "!isInteger(value)", "!isLong(value)" })`
	`54`	`+ @Specialization(guards = "!isImplicitLong(value)")`
`55`	`55`	`protected Object passThrough(Object value) {`
`56`	`56`	`return value;`
`57`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -345,7 +345,7 @@ protected boolean eql(double a, double b) {`
`345`	`345`	`return a == b;`
`346`	`346`	`}`
`347`	`347`
`348`		`- @Specialization(guards = { "!isDouble(b)" })`
	`348`	`+ @Specialization(guards = { "!isImplicitDouble(b)" })`
`349`	`349`	`protected boolean eqlGeneral(double a, Object b) {`
`350`	`350`	`return false;`
`351`	`351`	`}`
Original file line number	Diff line number	Diff line change
`@@ -483,7 +483,7 @@ protected RubyTime timeSFromArray(`
`483`	`483`	`return buildTime(language, timeClass, sec, min, hour, mday, month, year, nsec, isdst, isutc, utcoffset);`
`484`	`484`	`}`
`485`	`485`
`486`		`- @Specialization(guards = "!isInteger(sec) \|\| !isInteger(nsec)")`
	`486`	`+ @Specialization(guards = "!isImplicitInteger(sec) \|\| !isImplicitInteger(nsec)")`
`487`	`487`	`protected Object timeSFromArrayFallback(`
`488`	`488`	`RubyClass timeClass,`
`489`	`489`	`Object sec,`