implement getByteSlow non-recursively

Author: Nicolas Laurent

src/main/java/org/truffleruby/core/rope/ConcatRope.java

@@ -12,8 +12,6 @@
 import org.jcodings.Encoding;
 import org.jcodings.specific.ASCIIEncoding;
 
-import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
-
 public class ConcatRope extends ManagedRope {
 
     private final ManagedRope left;
@@ -80,13 +78,8 @@ Rope withBinaryEncoding() {
     }
 
     @Override
-    @TruffleBoundary
     public byte getByteSlow(int index) {
-        if (index < left.byteLength()) {
-            return left.getByteSlow(index);
-        }
-
-        return right.getByteSlow(index - left.byteLength());
+        return RopeOperations.getByteSlow(this, index);
     }
 
     public ManagedRope getLeft() {

src/main/java/org/truffleruby/core/rope/RepeatingRope.java

@@ -70,7 +70,7 @@ protected byte[] getBytesSlow() {
 
     @Override
     protected byte getByteSlow(int index) {
-        return child.getByteSlow(index % child.byteLength());
+        return RopeOperations.getByteSlow(this, index);
     }
 
     public ManagedRope getChild() {

src/main/java/org/truffleruby/core/rope/RopeOperations.java

@@ -497,6 +497,36 @@ public static byte[] flattenBytes(Rope rope) {
         return buffer;
     }
 
+    /** Used to implement {@link Rope#getByteSlow(int)} in a non-recursive fashion for some Rope subclasses. Do not call
+     * directly, call {@link Rope#getByteSlow(int) instead.} */
+    @TruffleBoundary
+    static byte getByteSlow(Rope rope, int index) {
+        while (true) {
+            final byte[] rawBytes = rope.getRawBytes();
+            if (rawBytes != null) {
+                return rawBytes[index];
+            } else if (rope instanceof ConcatRope) {
+                final ConcatRope concatRope = (ConcatRope) rope;
+                final Rope left = concatRope.getLeft();
+                if (index < left.byteLength()) {
+                    rope = left;
+                } else {
+                    rope = concatRope.getRight();
+                    index -= left.byteLength();
+                }
+            } else if (rope instanceof SubstringRope) {
+                final SubstringRope substringRope = (SubstringRope) rope;
+                rope = substringRope.getChild();
+                index += substringRope.getByteOffset();
+            } else if (rope instanceof RepeatingRope) {
+                rope = ((RepeatingRope) rope).getChild();
+                index %= rope.byteLength();
+            } else {
+                return rope.getByteSlow(index);
+            }
+        }
+    }
+
     private static int computeLoopCount(int offset, int times, int length, int patternLength) {
         // The loopCount has to be precisely determined so every repetition has at least some parts used.
         // It has to account for the beginning we don't need (offset), has to reach the end but, and must not

src/main/java/org/truffleruby/core/rope/SubstringRope.java

@@ -82,7 +82,7 @@ protected byte[] getBytesSlow() {
 
     @Override
     public byte getByteSlow(int index) {
-        return child.getByteSlow(index + byteOffset);
+        return RopeOperations.getByteSlow(this, index);
     }
 
     public ManagedRope getChild() {