@cached(parameters = "PRIVATE") DispatchNode: drop the parameters

Nicolas Laurent · Nicolas Laurent · commit fcf60ade3087 · 2020-09-07T14:29:15.000+02:00
diff --git a/src/main/java/org/truffleruby/core/array/ArrayNodes.java b/src/main/java/org/truffleruby/core/array/ArrayNodes.java
@@ -968,13 +968,13 @@ protected Object value(Object[] args) {
 
         @Specialization
         protected Object fillFallback(VirtualFrame frame, RubyArray array, Object[] args, NotProvided block,
-                @Cached(parameters = "PRIVATE") DispatchNode callFillInternal) {
+                @Cached DispatchNode callFillInternal) {
             return callFillInternal.call(array, "fill_internal", args);
         }
 
         @Specialization
         protected Object fillFallback(VirtualFrame frame, RubyArray array, Object[] args, RubyProc block,
-                @Cached(parameters = "PRIVATE") DispatchNode callFillInternal) {
+                @Cached DispatchNode callFillInternal) {
             return callFillInternal.callWithBlock(array, "fill_internal", block, args);
         }
 
@@ -989,7 +989,7 @@ public abstract static class HashNode extends ArrayCoreMethodNode {
         @Specialization(limit = "storageStrategyLimit()")
         protected long hash(VirtualFrame frame, RubyArray array,
                 @CachedLibrary("array.store") ArrayStoreLibrary stores,
-                @Cached(parameters = "PRIVATE") DispatchNode toHashNode,
+                @Cached DispatchNode toHashNode,
                 @Cached ToLongNode toLongNode,
                 @Cached("createCountingProfile()") LoopConditionProfile loopProfile) {
             final int size = array.size;
@@ -2093,7 +2093,7 @@ protected RubyArray sortEmpty(RubyArray array, Object unusedBlock) {
         protected RubyArray sortVeryShort(VirtualFrame frame, RubyArray array, NotProvided block,
                 @CachedLibrary("array.store") ArrayStoreLibrary originalStores,
                 @CachedLibrary(limit = "1") ArrayStoreLibrary stores,
-                @Cached(parameters = "PRIVATE") DispatchNode compareDispatchNode,
+                @Cached DispatchNode compareDispatchNode,
                 @Cached CmpIntNode cmpIntNode) {
             final Object originalStore = array.store;
             final Object store = originalStores
@@ -2155,13 +2155,13 @@ protected Object sortPrimitiveArrayNoBlock(RubyArray array, NotProvided block,
                 limit = "storageStrategyLimit()")
         protected Object sortArrayWithoutBlock(RubyArray array, NotProvided block,
                 @CachedLibrary("array.store") ArrayStoreLibrary stores,
-                @Cached(parameters = "PRIVATE") DispatchNode fallbackNode) {
+                @Cached DispatchNode fallbackNode) {
             return fallbackNode.call(array, "sort_fallback");
         }
 
         @Specialization(guards = "!isEmptyArray(array)")
         protected Object sortGenericWithBlock(RubyArray array, RubyProc block,
-                @Cached(parameters = "PRIVATE") DispatchNode fallbackNode) {
+                @Cached DispatchNode fallbackNode) {
             return fallbackNode.callWithBlock(array, "sort_fallback", block);
         }
 
diff --git a/src/main/java/org/truffleruby/core/cast/CmpIntNode.java b/src/main/java/org/truffleruby/core/cast/CmpIntNode.java
@@ -79,8 +79,8 @@ private String formatMessage(Object receiver, Object other) {
 
     @Specialization(guards = { "!isRubyInteger(value)", "!isNil(value)" })
     protected int cmpObject(Object value, Object receiver, Object other,
-            @Cached(parameters = "PRIVATE") DispatchNode gtNode,
-            @Cached(parameters = "PRIVATE") DispatchNode ltNode,
+            @Cached DispatchNode gtNode,
+            @Cached DispatchNode ltNode,
             @Cached BooleanCastNode gtCastNode,
             @Cached BooleanCastNode ltCastNode) {
 
diff --git a/src/main/java/org/truffleruby/core/cast/SplatCastNode.java b/src/main/java/org/truffleruby/core/cast/SplatCastNode.java
@@ -92,7 +92,7 @@ protected RubyArray splat(VirtualFrame frame, RubyArray array) {
 
     @Specialization(guards = { "!isNil(object)", "!isRubyArray(object)" })
     protected RubyArray splat(VirtualFrame frame, Object object,
-            @Cached(parameters = "PRIVATE") DispatchNode toArrayNode) {
+            @Cached DispatchNode toArrayNode) {
         final Object array = toArrayNode.call(
                 coreLibrary().truffleTypeModule,
                 "rb_check_convert_type",
diff --git a/src/main/java/org/truffleruby/core/cast/ToPathNode.java b/src/main/java/org/truffleruby/core/cast/ToPathNode.java
@@ -28,7 +28,7 @@ protected RubyString coerceRubyString(RubyString path) {
 
     @Specialization(guards = "!isRubyString(object)")
     protected RubyString coerceObject(Object object,
-            @Cached(parameters = "PRIVATE") DispatchNode toPathNode) {
+            @Cached DispatchNode toPathNode) {
         return (RubyString) toPathNode.call(coreLibrary().truffleTypeModule, "coerce_to_path", object);
     }
 
diff --git a/src/main/java/org/truffleruby/core/cast/ToProcNode.java b/src/main/java/org/truffleruby/core/cast/ToProcNode.java
@@ -38,7 +38,7 @@ protected RubyProc doRubyProc(RubyProc proc) {
 
     @Specialization(guards = { "!isNil(object)", "!isRubyProc(object)" })
     protected RubyProc doObject(VirtualFrame frame, Object object,
-            @Cached(parameters = "PRIVATE") DispatchNode toProc,
+            @Cached DispatchNode toProc,
             @Cached BranchProfile errorProfile) {
         final Object coerced;
         try {
diff --git a/src/main/java/org/truffleruby/core/cast/ToSNode.java b/src/main/java/org/truffleruby/core/cast/ToSNode.java
@@ -33,7 +33,7 @@ protected RubyString toS(RubyString string) {
 
     @Specialization(guards = "!isRubyString(object)")
     protected RubyString toSFallback(VirtualFrame frame, Object object,
-            @Cached(parameters = "PRIVATE") DispatchNode callToSNode) {
+            @Cached DispatchNode callToSNode) {
         final Object value = callToSNode.call(object, "to_s");
 
         if (value instanceof RubyString) {
diff --git a/src/main/java/org/truffleruby/core/cast/ToStrNode.java b/src/main/java/org/truffleruby/core/cast/ToStrNode.java
@@ -39,7 +39,7 @@ protected RubyString coerceRubyString(RubyString string) {
     @Specialization(guards = "!isRubyString(object)")
     protected RubyString coerceObject(Object object,
             @Cached BranchProfile errorProfile,
-            @Cached(parameters = "PRIVATE") DispatchNode toStrNode) {
+            @Cached DispatchNode toStrNode) {
         final Object coerced;
         try {
             coerced = toStrNode.call(object, "to_str");
diff --git a/src/main/java/org/truffleruby/core/hash/HashNodes.java b/src/main/java/org/truffleruby/core/hash/HashNodes.java
@@ -638,7 +638,7 @@ protected RubyHash replaceBuckets(RubyHash self, RubyHash from) {
 
         @Specialization(guards = "!isRubyHash(from)")
         protected RubyHash replaceCoerce(RubyHash self, Object from,
-                @Cached(parameters = "PRIVATE") DispatchNode coerceNode,
+                @Cached DispatchNode coerceNode,
                 @Cached InitializeCopyNode initializeCopyNode) {
             final Object otherHash = coerceNode.call(
                     coreLibrary().truffleTypeModule,
diff --git a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java
@@ -643,7 +643,7 @@ protected Object dup(Object self,
                 @Cached IsImmutableObjectNode isImmutableObjectNode,
                 @Cached ConditionProfile immutableProfile,
                 @Cached CopyNode copyNode,
-                @Cached(parameters = "PRIVATE") DispatchNode initializeDupNode) {
+                @Cached DispatchNode initializeDupNode) {
             if (immutableProfile.profile(isImmutableObjectNode.execute(self))) {
                 return self;
             }
diff --git a/src/main/java/org/truffleruby/core/numeric/FloatNodes.java b/src/main/java/org/truffleruby/core/numeric/FloatNodes.java
@@ -76,7 +76,7 @@ protected double add(double a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object addCoerced(double a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {
+                @Cached DispatchNode redoCoerced) {
             return redoCoerced.call(a, "redo_coerced", CoreSymbols.PLUS, b);
         }
     }
@@ -101,7 +101,7 @@ protected double sub(double a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object subCoerced(double a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {
+                @Cached DispatchNode redoCoerced) {
             return redoCoerced.call(a, "redo_coerced", CoreSymbols.MINUS, b);
         }
 
@@ -127,7 +127,7 @@ protected double mul(double a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object mulCoerced(double a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {
+                @Cached DispatchNode redoCoerced) {
             return redoCoerced.call(a, "redo_coerced", CoreSymbols.MULTIPLY, b);
         }
 
@@ -183,7 +183,7 @@ protected double pow(double base, RubyBignum exponent) {
 
         @Specialization(guards = "!isRubyNumber(exponent)")
         protected Object powCoerced(double base, Object exponent,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {
+                @Cached DispatchNode redoCoerced) {
             return redoCoerced.call(base, "redo_coerced", CoreSymbols.POW, exponent);
         }
 
@@ -209,7 +209,7 @@ protected double div(double a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object divCoerced(double a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {
+                @Cached DispatchNode redoCoerced) {
             return redoCoerced.call(a, "redo_coerced", CoreSymbols.DIVIDE, b);
         }
 
@@ -255,7 +255,7 @@ protected double mod(double a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object modCoerced(double a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {
+                @Cached DispatchNode redoCoerced) {
             return redoCoerced.call(a, "redo_coerced", CoreSymbols.MODULO, b);
         }
 
@@ -283,7 +283,7 @@ protected RubyArray divMod(double a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyBignum(b)")
         protected Object divModCoerced(double a, RubyDynamicObject b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {
+                @Cached DispatchNode redoCoerced) {
             return redoCoerced.call(a, "redo_coerced", CoreSymbols.DIVMOD, b);
         }
 
@@ -309,7 +309,7 @@ protected boolean lessBignum(double a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object lessCoerced(double a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCompare) {
+                @Cached DispatchNode redoCompare) {
             return redoCompare.call(a, "redo_compare", CoreSymbols.LESS_THAN, b);
         }
     }
@@ -334,7 +334,7 @@ protected boolean lessEqual(double a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object lessEqualCoerced(double a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCompare) {
+                @Cached DispatchNode redoCompare) {
             return redoCompare.call(a, "redo_compare", CoreSymbols.LEQ, b);
         }
     }
@@ -419,13 +419,13 @@ protected int compare(double a, double b) {
 
         @Specialization(guards = { "!isNaN(a)", "!isRubyBignum(b)" })
         protected Object compare(double a, RubyDynamicObject b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCompare) {
+                @Cached DispatchNode redoCompare) {
             return redoCompare.call(a, "redo_compare_bad_coerce_return_error", b);
         }
 
         @Specialization(guards = { "!isNaN(a)" })
         protected Object compare(double a, Nil b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCompare) {
+                @Cached DispatchNode redoCompare) {
             return redoCompare.call(a, "redo_compare_bad_coerce_return_error", b);
         }
 
@@ -451,7 +451,7 @@ protected boolean greaterEqual(double a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object greaterEqualCoerced(double a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCompare) {
+                @Cached DispatchNode redoCompare) {
             return redoCompare.call(a, "redo_compare", CoreSymbols.GEQ, b);
         }
 
@@ -477,7 +477,7 @@ protected boolean greater(double a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object greaterCoerced(double a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCompare) {
+                @Cached DispatchNode redoCompare) {
             return redoCompare.call(a, "redo_compare", CoreSymbols.GREATER_THAN, b);
         }
     }
diff --git a/src/main/java/org/truffleruby/core/numeric/IntegerNodes.java b/src/main/java/org/truffleruby/core/numeric/IntegerNodes.java
@@ -164,7 +164,7 @@ protected Object add(RubyBignum a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object addCoerced(Object a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {
+                @Cached DispatchNode redoCoerced) {
             return redoCoerced.call(a, "redo_coerced", CoreSymbols.PLUS, b);
         }
     }
@@ -221,7 +221,7 @@ protected Object sub(RubyBignum a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object subCoerced(Object a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {
+                @Cached DispatchNode redoCoerced) {
             return redoCoerced.call(a, "redo_coerced", CoreSymbols.MINUS, b);
         }
 
@@ -283,7 +283,7 @@ protected Object mul(RubyBignum a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object mul(Object a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {
+                @Cached DispatchNode redoCoerced) {
             return redoCoerced.call(a, "redo_coerced", CoreSymbols.MULTIPLY, b);
         }
 
@@ -438,7 +438,7 @@ protected Object div(RubyBignum a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object divCoerced(Object a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {
+                @Cached DispatchNode redoCoerced) {
             return redoCoerced.call(a, "redo_coerced", CoreSymbols.DIVIDE, b);
         }
 
@@ -588,7 +588,7 @@ protected Object mod(RubyBignum a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object modCoerced(Object a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {
+                @Cached DispatchNode redoCoerced) {
             return redoCoerced.call(a, "redo_coerced", CoreSymbols.MODULO, b);
         }
 
@@ -676,7 +676,7 @@ protected boolean less(RubyBignum a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object lessCoerced(Object a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCompare) {
+                @Cached DispatchNode redoCompare) {
             return redoCompare.call(a, "redo_compare", CoreSymbols.LESS_THAN, b);
         }
     }
@@ -721,7 +721,7 @@ protected boolean lessEqual(RubyBignum a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object lessEqualCoerced(Object a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCompare) {
+                @Cached DispatchNode redoCompare) {
             return redoCompare.call(a, "redo_compare", CoreSymbols.LEQ, b);
         }
 
@@ -772,7 +772,7 @@ protected boolean equal(RubyBignum a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object equal(VirtualFrame frame, Object a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode reverseCallNode,
+                @Cached DispatchNode reverseCallNode,
                 @Cached BooleanCastNode booleanCastNode) {
             final Object reversedResult = reverseCallNode.call(b, "==", a);
             return booleanCastNode.executeToBoolean(reversedResult);
@@ -845,7 +845,7 @@ protected int compare(RubyBignum a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object compare(Object a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCompare) {
+                @Cached DispatchNode redoCompare) {
             return redoCompare.call(a, "redo_compare_no_error", b);
         }
 
@@ -891,7 +891,7 @@ protected boolean greaterEqual(RubyBignum a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object greaterEqualCoerced(Object a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCompare) {
+                @Cached DispatchNode redoCompare) {
             return redoCompare.call(a, "redo_compare", CoreSymbols.GEQ, b);
         }
 
@@ -937,7 +937,7 @@ protected boolean greater(RubyBignum a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyNumber(b)")
         protected Object greaterCoerced(Object a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCompare) {
+                @Cached DispatchNode redoCompare) {
             return redoCompare.call(a, "redo_compare", CoreSymbols.GREATER_THAN, b);
         }
 
@@ -1026,7 +1026,7 @@ protected Object bitAnd(RubyBignum a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyInteger(b)")
         protected Object bitAndCoerced(Object a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {
+                @Cached DispatchNode redoCoerced) {
             return redoCoerced.call(a, "redo_bit_coerced", CoreSymbols.AMPERSAND, b);
         }
 
@@ -1064,7 +1064,7 @@ protected Object bitOr(RubyBignum a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyInteger(b)")
         protected Object bitOrCoerced(Object a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {
+                @Cached DispatchNode redoCoerced) {
             return redoCoerced.call(a, "redo_bit_coerced", CoreSymbols.PIPE, b);
         }
 
@@ -1100,7 +1100,7 @@ protected Object bitXOr(RubyBignum a, RubyBignum b) {
 
         @Specialization(guards = "!isRubyInteger(b)")
         protected Object bitXOrCoerced(Object a, Object b,
-                @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {
+                @Cached DispatchNode redoCoerced) {
             return redoCoerced.call(a, "redo_bit_coerced", CoreSymbols.CIRCUMFLEX, b);
         }
 
diff --git a/src/main/java/org/truffleruby/core/range/RangeNodes.java b/src/main/java/org/truffleruby/core/range/RangeNodes.java
@@ -451,7 +451,7 @@ protected RubyLongRange longRange(RubyClass rubyClass, long begin, long end, boo
 
         @Specialization(guards = { "rubyClass != getRangeClass() || (!isIntOrLong(begin) || !isIntOrLong(end))" })
         protected RubyObjectRange objectRange(RubyClass rubyClass, Object begin, Object end, boolean excludeEnd,
-                @Cached(parameters = "PRIVATE") DispatchNode compare) {
+                @Cached DispatchNode compare) {
 
             if (compare.call(begin, "<=>", end) == nil && end != nil) {
                 throw new RaiseException(getContext(), coreExceptions().argumentError("bad value for range", this));
diff --git a/src/main/java/org/truffleruby/core/regexp/MatchDataNodes.java b/src/main/java/org/truffleruby/core/regexp/MatchDataNodes.java
@@ -620,7 +620,7 @@ public static RegexpNode create() {
         @Specialization
         protected RubyRegexp regexp(RubyMatchData matchData,
                 @Cached ConditionProfile profile,
-                @Cached(parameters = "PRIVATE") DispatchNode stringToRegexp) {
+                @Cached DispatchNode stringToRegexp) {
             final RubyDynamicObject value = matchData.regexp;
 
             if (profile.profile(value instanceof RubyRegexp)) {
diff --git a/src/main/java/org/truffleruby/core/string/StringNodes.java b/src/main/java/org/truffleruby/core/string/StringNodes.java
diff --git a/src/main/java/org/truffleruby/language/constants/GetConstantNode.java b/src/main/java/org/truffleruby/language/constants/GetConstantNode.java
diff --git a/src/main/java/org/truffleruby/stdlib/bigdecimal/BigDecimalCastNode.java b/src/main/java/org/truffleruby/stdlib/bigdecimal/BigDecimalCastNode.java
diff --git a/src/main/java/org/truffleruby/stdlib/bigdecimal/BigDecimalNodes.java b/src/main/java/org/truffleruby/stdlib/bigdecimal/BigDecimalNodes.java
diff --git a/src/main/java/org/truffleruby/stdlib/bigdecimal/CreateBigDecimalNode.java b/src/main/java/org/truffleruby/stdlib/bigdecimal/CreateBigDecimalNode.java

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ protected RubyString coerceRubyString(RubyString path) {`
`28`	`28`
`29`	`29`	`@Specialization(guards = "!isRubyString(object)")`
`30`	`30`	`protected RubyString coerceObject(Object object,`
`31`		`- @Cached(parameters = "PRIVATE") DispatchNode toPathNode) {`
	`31`	`+ @Cached DispatchNode toPathNode) {`
`32`	`32`	`return (RubyString) toPathNode.call(coreLibrary().truffleTypeModule, "coerce_to_path", object);`
`33`	`33`	`}`
`34`	`34`
Original file line number	Diff line number	Diff line change
`@@ -643,7 +643,7 @@ protected Object dup(Object self,`
`643`	`643`	`@Cached IsImmutableObjectNode isImmutableObjectNode,`
`644`	`644`	`@Cached ConditionProfile immutableProfile,`
`645`	`645`	`@Cached CopyNode copyNode,`
`646`		`- @Cached(parameters = "PRIVATE") DispatchNode initializeDupNode) {`
	`646`	`+ @Cached DispatchNode initializeDupNode) {`
`647`	`647`	`if (immutableProfile.profile(isImmutableObjectNode.execute(self))) {`
`648`	`648`	`return self;`
`649`	`649`	`}`
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ protected double add(double a, RubyBignum b) {`
`76`	`76`
`77`	`77`	`@Specialization(guards = "!isRubyNumber(b)")`
`78`	`78`	`protected Object addCoerced(double a, Object b,`
`79`		`- @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {`
	`79`	`+ @Cached DispatchNode redoCoerced) {`
`80`	`80`	`return redoCoerced.call(a, "redo_coerced", CoreSymbols.PLUS, b);`
`81`	`81`	`}`
`82`	`82`	`}`
`@@ -101,7 +101,7 @@ protected double sub(double a, RubyBignum b) {`
`101`	`101`
`102`	`102`	`@Specialization(guards = "!isRubyNumber(b)")`
`103`	`103`	`protected Object subCoerced(double a, Object b,`
`104`		`- @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {`
	`104`	`+ @Cached DispatchNode redoCoerced) {`
`105`	`105`	`return redoCoerced.call(a, "redo_coerced", CoreSymbols.MINUS, b);`
`106`	`106`	`}`
`107`	`107`
`@@ -127,7 +127,7 @@ protected double mul(double a, RubyBignum b) {`
`127`	`127`
`128`	`128`	`@Specialization(guards = "!isRubyNumber(b)")`
`129`	`129`	`protected Object mulCoerced(double a, Object b,`
`130`		`- @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {`
	`130`	`+ @Cached DispatchNode redoCoerced) {`
`131`	`131`	`return redoCoerced.call(a, "redo_coerced", CoreSymbols.MULTIPLY, b);`
`132`	`132`	`}`
`133`	`133`
`@@ -183,7 +183,7 @@ protected double pow(double base, RubyBignum exponent) {`
`183`	`183`
`184`	`184`	`@Specialization(guards = "!isRubyNumber(exponent)")`
`185`	`185`	`protected Object powCoerced(double base, Object exponent,`
`186`		`- @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {`
	`186`	`+ @Cached DispatchNode redoCoerced) {`
`187`	`187`	`return redoCoerced.call(base, "redo_coerced", CoreSymbols.POW, exponent);`
`188`	`188`	`}`
`189`	`189`
`@@ -209,7 +209,7 @@ protected double div(double a, RubyBignum b) {`
`209`	`209`
`210`	`210`	`@Specialization(guards = "!isRubyNumber(b)")`
`211`	`211`	`protected Object divCoerced(double a, Object b,`
`212`		`- @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {`
	`212`	`+ @Cached DispatchNode redoCoerced) {`
`213`	`213`	`return redoCoerced.call(a, "redo_coerced", CoreSymbols.DIVIDE, b);`
`214`	`214`	`}`
`215`	`215`
`@@ -255,7 +255,7 @@ protected double mod(double a, RubyBignum b) {`
`255`	`255`
`256`	`256`	`@Specialization(guards = "!isRubyNumber(b)")`
`257`	`257`	`protected Object modCoerced(double a, Object b,`
`258`		`- @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {`
	`258`	`+ @Cached DispatchNode redoCoerced) {`
`259`	`259`	`return redoCoerced.call(a, "redo_coerced", CoreSymbols.MODULO, b);`
`260`	`260`	`}`
`261`	`261`
`@@ -283,7 +283,7 @@ protected RubyArray divMod(double a, RubyBignum b) {`
`283`	`283`
`284`	`284`	`@Specialization(guards = "!isRubyBignum(b)")`
`285`	`285`	`protected Object divModCoerced(double a, RubyDynamicObject b,`
`286`		`- @Cached(parameters = "PRIVATE") DispatchNode redoCoerced) {`
	`286`	`+ @Cached DispatchNode redoCoerced) {`
`287`	`287`	`return redoCoerced.call(a, "redo_coerced", CoreSymbols.DIVMOD, b);`
`288`	`288`	`}`
`289`	`289`
`@@ -309,7 +309,7 @@ protected boolean lessBignum(double a, RubyBignum b) {`
`309`	`309`
`310`	`310`	`@Specialization(guards = "!isRubyNumber(b)")`
`311`	`311`	`protected Object lessCoerced(double a, Object b,`
`312`		`- @Cached(parameters = "PRIVATE") DispatchNode redoCompare) {`
	`312`	`+ @Cached DispatchNode redoCompare) {`
`313`	`313`	`return redoCompare.call(a, "redo_compare", CoreSymbols.LESS_THAN, b);`
`314`	`314`	`}`
`315`	`315`	`}`
`@@ -334,7 +334,7 @@ protected boolean lessEqual(double a, RubyBignum b) {`
`334`	`334`
`335`	`335`	`@Specialization(guards = "!isRubyNumber(b)")`
`336`	`336`	`protected Object lessEqualCoerced(double a, Object b,`
`337`		`- @Cached(parameters = "PRIVATE") DispatchNode redoCompare) {`
	`337`	`+ @Cached DispatchNode redoCompare) {`
`338`	`338`	`return redoCompare.call(a, "redo_compare", CoreSymbols.LEQ, b);`
`339`	`339`	`}`
`340`	`340`	`}`
`@@ -419,13 +419,13 @@ protected int compare(double a, double b) {`
`419`	`419`
`420`	`420`	`@Specialization(guards = { "!isNaN(a)", "!isRubyBignum(b)" })`
`421`	`421`	`protected Object compare(double a, RubyDynamicObject b,`
`422`		`- @Cached(parameters = "PRIVATE") DispatchNode redoCompare) {`
	`422`	`+ @Cached DispatchNode redoCompare) {`
`423`	`423`	`return redoCompare.call(a, "redo_compare_bad_coerce_return_error", b);`
`424`	`424`	`}`
`425`	`425`
`426`	`426`	`@Specialization(guards = { "!isNaN(a)" })`
`427`	`427`	`protected Object compare(double a, Nil b,`
`428`		`- @Cached(parameters = "PRIVATE") DispatchNode redoCompare) {`
	`428`	`+ @Cached DispatchNode redoCompare) {`
`429`	`429`	`return redoCompare.call(a, "redo_compare_bad_coerce_return_error", b);`
`430`	`430`	`}`
`431`	`431`
`@@ -451,7 +451,7 @@ protected boolean greaterEqual(double a, RubyBignum b) {`
`451`	`451`
`452`	`452`	`@Specialization(guards = "!isRubyNumber(b)")`
`453`	`453`	`protected Object greaterEqualCoerced(double a, Object b,`
`454`		`- @Cached(parameters = "PRIVATE") DispatchNode redoCompare) {`
	`454`	`+ @Cached DispatchNode redoCompare) {`
`455`	`455`	`return redoCompare.call(a, "redo_compare", CoreSymbols.GEQ, b);`
`456`	`456`	`}`
`457`	`457`
`@@ -477,7 +477,7 @@ protected boolean greater(double a, RubyBignum b) {`
`477`	`477`
`478`	`478`	`@Specialization(guards = "!isRubyNumber(b)")`
`479`	`479`	`protected Object greaterCoerced(double a, Object b,`
`480`		`- @Cached(parameters = "PRIVATE") DispatchNode redoCompare) {`
	`480`	`+ @Cached DispatchNode redoCompare) {`
`481`	`481`	`return redoCompare.call(a, "redo_compare", CoreSymbols.GREATER_THAN, b);`
`482`	`482`	`}`
`483`	`483`	`}`