Inline ArrayOperations.normalizeIndex()

* The logic is simpler in the caller where variables can be re-assigned.

Author: eregon

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

@@ -264,9 +264,10 @@ public abstract static class IndexNode extends ArrayCoreMethodNode {
         protected Object index(RubyArray array, int index, NotProvided length,
                 @Cached ConditionProfile negativeIndexProfile,
                 @Cached ReadNormalizedNode readNode) {
-            final int normalizedIndex = ArrayOperations
-                    .normalizeIndex(array.size, index, negativeIndexProfile);
-            return readNode.executeRead(array, normalizedIndex);
+            if (negativeIndexProfile.profile(index < 0)) {
+                index += array.size;
+            }
+            return readNode.executeRead(array, index);
         }
 
         @Specialization
@@ -291,9 +292,10 @@ protected Object slice(RubyArray array, int start, int length,
             if (length < 0) {
                 return nil;
             }
-            final int normalizedStart = ArrayOperations
-                    .normalizeIndex(array.size, start, negativeIndexProfile);
-            return readSliceNode.executeReadSlice(array, normalizedStart, length);
+            if (negativeIndexProfile.profile(start < 0)) {
+                start += array.size;
+            }
+            return readSliceNode.executeReadSlice(array, start, length);
         }
 
         @Specialization(guards = { "wasProvided(length)", "!isInteger(start) || !isInteger(length)" })
@@ -728,7 +730,10 @@ protected Object deleteAt(RubyArray array, int index,
                 @Cached ConditionProfile negativeIndexProfile,
                 @Cached ConditionProfile notInBoundsProfile) {
             final int size = array.size;
-            final int i = ArrayOperations.normalizeIndex(size, index, negativeIndexProfile);
+            int i = index;
+            if (negativeIndexProfile.profile(index < 0)) {
+                i += size;
+            }
 
             if (notInBoundsProfile.profile(i < 0 || i >= size)) {
                 return nil;
@@ -751,7 +756,10 @@ protected Object deleteAtCopying(RubyArray array, int index,
                 @Cached ConditionProfile negativeIndexProfile,
                 @Cached ConditionProfile notInBoundsProfile) {
             final int size = array.size;
-            final int i = ArrayOperations.normalizeIndex(size, index, negativeIndexProfile);
+            int i = index;
+            if (negativeIndexProfile.profile(index < 0)) {
+                i += size;
+            }
 
             if (notInBoundsProfile.profile(i < 0 || i >= size)) {
                 return nil;

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

@@ -19,7 +19,6 @@
 
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
-import com.oracle.truffle.api.profiles.ConditionProfile;
 
 public abstract class ArrayOperations {
 
@@ -69,22 +68,6 @@ public static boolean verifyStore(RubyArray array) {
         return true;
     }
 
-    public static int normalizeIndex(int length, int index, ConditionProfile negativeIndexProfile) {
-        if (negativeIndexProfile.profile(index < 0)) {
-            return length + index;
-        } else {
-            return index;
-        }
-    }
-
-    public static int normalizeIndex(int length, int index) {
-        if (CompilerDirectives.injectBranchProbability(CompilerDirectives.SLOWPATH_PROBABILITY, index < 0)) {
-            return length + index;
-        } else {
-            return index;
-        }
-    }
-
     public static int clampExclusiveIndex(int length, int index) {
         if (CompilerDirectives.injectBranchProbability(CompilerDirectives.UNLIKELY_PROBABILITY, index < 0)) {
             return 0;

src/main/java/org/truffleruby/core/regexp/MatchDataNodes.java

@@ -241,14 +241,15 @@ protected Object getIndex(RubyMatchData matchData, int index, NotProvided length
             final RubyString source = matchData.source;
             final Rope sourceRope = source.rope;
             final Region region = matchData.region;
-            final int normalizedIndex = ArrayOperations
-                    .normalizeIndex(region.beg.length, index, normalizedIndexProfile);
+            if (normalizedIndexProfile.profile(index < 0)) {
+                index += region.beg.length;
+            }
 
-            if (indexOutOfBoundsProfile.profile((normalizedIndex < 0) || (normalizedIndex >= region.beg.length))) {
+            if (indexOutOfBoundsProfile.profile((index < 0) || (index >= region.beg.length))) {
                 return nil;
             } else {
-                final int start = region.beg[normalizedIndex];
-                final int end = region.end[normalizedIndex];
+                final int start = region.beg[index];
+                final int end = region.end[index];
                 if (hasValueProfile.profile(start > -1 && end > -1)) {
                     Rope rope = substringNode.executeSubstring(sourceRope, start, end - start);
                     final Shape shape = allocateHelperNode.getCachedShape(source.getLogicalClass());
@@ -262,11 +263,14 @@ protected Object getIndex(RubyMatchData matchData, int index, NotProvided length
         }
 
         @Specialization
-        protected RubyArray getIndex(RubyMatchData matchData, int index, int length) {
+        protected RubyArray getIndex(RubyMatchData matchData, int index, int length,
+                @Cached ConditionProfile normalizedIndexProfile) {
             // TODO BJF 15-May-2015 Need to handle negative indexes and lengths and out of bounds
             final Object[] values = getValuesNode.execute(matchData);
-            final int normalizedIndex = ArrayOperations.normalizeIndex(values.length, index);
-            final Object[] store = Arrays.copyOfRange(values, normalizedIndex, normalizedIndex + length);
+            if (normalizedIndexProfile.profile(index < 0)) {
+                index += values.length;
+            }
+            final Object[] store = Arrays.copyOfRange(values, index, index + length);
             return createArray(store);
         }
 
@@ -310,13 +314,19 @@ protected Object getIndex(RubyMatchData matchData, Object index, NotProvided len
         @Specialization
         protected RubyArray getIndex(RubyMatchData matchData, RubyIntRange range, NotProvided len) {
             final Object[] values = getValuesNode.execute(matchData);
-            final int normalizedIndex = ArrayOperations.normalizeIndex(values.length, range.begin);
-            final int end = ArrayOperations.normalizeIndex(values.length, range.end);
+            int index = range.begin;
+            if (range.begin < 0) {
+                index += values.length;
+            }
+            int end = range.end;
+            if (end < 0) {
+                end += values.length;
+            }
             final int exclusiveEnd = ArrayOperations
                     .clampExclusiveIndex(values.length, range.excludedEnd ? end : end + 1);
-            final int length = exclusiveEnd - normalizedIndex;
+            final int length = exclusiveEnd - index;
 
-            return createArray(Arrays.copyOfRange(values, normalizedIndex, normalizedIndex + length));
+            return createArray(Arrays.copyOfRange(values, index, index + length));
         }
 
         @TruffleBoundary