jruby · Jun 9, 2015 · Jun 9, 2015 · Jun 9, 2015
diff --git a/spec/truffle/tags/core/string/rindex_tags.txt b/spec/truffle/tags/core/string/rindex_tags.txt
@@ -5,5 +5,4 @@ fails(regexp):String#rindex with Regexp starts the search at the given offset
 fails(regexp):String#rindex with Regexp supports \G which matches at the given start offset
 fails(regexp):String#rindex with Regexp tries to convert start_offset to an integer via to_int
 fails(regexp):String#rindex with Regexp returns the reverse character index of a multibyte character
-fails(regexp):String#rindex with Regexp returns the character index before the finish
 fails:String#rindex with Regexp returns nil if the substring isn't found
diff --git a/spec/truffle/tags/core/string/split_tags.txt b/spec/truffle/tags/core/string/split_tags.txt
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/StringGuards.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/StringGuards.java
@@ -25,8 +25,9 @@ public static boolean isAsciiCompatible(RubyString string) {
         return StringNodes.getByteList(string).getEncoding().isAsciiCompatible();
     }
 
-    public static boolean isSingleByteOptimizableOrAsciiCompatible(RubyString string) {
-        return isSingleByteOptimizable(string) || isAsciiCompatible(string);
+    public static boolean isSingleByteOptimizableOrAsciiOnly(RubyString string) {
+        // TODO (nirvdrnum 08-Jun-15) Rubinius tracks whether a String is ASCII-only via a field in the String.
+        return isSingleByteOptimizable(string);
     }
 
     public static boolean isSingleByte(RubyString string) {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/StringPrimitiveNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/StringPrimitiveNodes.java
@@ -602,16 +602,26 @@ public Object stringToF(RubyString string) {
     @RubiniusPrimitive(name = "string_index", lowerFixnumParameters = 1)
     public static abstract class StringIndexPrimitiveNode extends RubiniusPrimitiveNode {
 
+        @Child StringByteCharacterIndexNode byteIndexToCharIndexNode;
+
         public StringIndexPrimitiveNode(RubyContext context, SourceSection sourceSection) {
 
             super(context, sourceSection);
         }
 
         @Specialization
-        public Object stringIndex(RubyString string, RubyString pattern, int start) {
+        public Object stringIndex(VirtualFrame frame, RubyString string, RubyString pattern, int start) {
+            if (byteIndexToCharIndexNode == null) {
+                CompilerDirectives.transferToInterpreter();
+                byteIndexToCharIndexNode = insert(StringPrimitiveNodesFactory.StringByteCharacterIndexNodeFactory.create(getContext(), getSourceSection(), new RubyNode[]{}));
+            }
+
+            // Rubinius will pass in a byte index for the `start` value, but StringSupport.index requires a character index.
+            final int charIndex = byteIndexToCharIndexNode.executeStringBytCharacterIndex(frame, string, start, 0);
+
             final int index = StringSupport.index(StringNodes.getCodeRangeable(string),
                     StringNodes.getCodeRangeable(pattern),
-                    start, StringNodes.getByteList(string).getEncoding());
+                    charIndex, StringNodes.getByteList(string).getEncoding());
 
             if (index == -1) {
                 return nil();
@@ -652,19 +662,21 @@ public StringByteCharacterIndexNode(RubyContext context, SourceSection sourceSec
             super(context, sourceSection);
         }
 
-        @Specialization(guards = "isSingleByteOptimizableOrAsciiCompatible(string)")
+        public abstract int executeStringBytCharacterIndex(VirtualFrame frame, RubyString string, int index, int start);
+
+        @Specialization(guards = "isSingleByteOptimizableOrAsciiOnly(string)")
         public int stringByteCharacterIndexSingleByte(RubyString string, int index, int start) {
             // Taken from Rubinius's String::find_byte_character_index.
             return index;
         }
 
-        @Specialization(guards = { "!isSingleByteOptimizableOrAsciiCompatible(string)", "isFixedWidthEncoding(string)", "!isValidUtf8(string)" })
+        @Specialization(guards = { "!isSingleByteOptimizableOrAsciiOnly(string)", "isFixedWidthEncoding(string)", "!isValidUtf8(string)" })
         public int stringByteCharacterIndexFixedWidth(RubyString string, int index, int start) {
             // Taken from Rubinius's String::find_byte_character_index.
             return index / StringNodes.getByteList(string).getEncoding().minLength();
         }
 
-        @Specialization(guards = { "!isSingleByteOptimizableOrAsciiCompatible(string)", "!isFixedWidthEncoding(string)", "isValidUtf8(string)" })
+        @Specialization(guards = { "!isSingleByteOptimizableOrAsciiOnly(string)", "!isFixedWidthEncoding(string)", "isValidUtf8(string)" })
         public int stringByteCharacterIndexValidUtf8(RubyString string, int index, int start) {
             // Taken from Rubinius's String::find_byte_character_index.
 
@@ -673,7 +685,7 @@ public int stringByteCharacterIndexValidUtf8(RubyString string, int index, int s
         }
 
         @TruffleBoundary
-        @Specialization(guards = { "!isSingleByteOptimizableOrAsciiCompatible(string)", "!isFixedWidthEncoding(string)", "!isValidUtf8(string)" })
+        @Specialization(guards = { "!isSingleByteOptimizableOrAsciiOnly(string)", "!isFixedWidthEncoding(string)", "!isValidUtf8(string)" })
         public int stringByteCharacterIndex(RubyString string, int index, int start) {
             // Taken from Rubinius's String::find_byte_character_index and Encoding::find_byte_character_index.