jruby · Feb 16, 2015 · Feb 16, 2015
diff --git a/core/src/main/java/org/jruby/util/ByteListHolder.java b/core/src/main/java/org/jruby/util/ByteListHolder.java
@@ -30,6 +30,7 @@
 
 public interface ByteListHolder {
     public ByteList getByteList();
+    public void modify();
     public void modify(int length);
     public Encoding checkEncoding(ByteListHolder other);
 }
diff --git a/core/src/main/java/org/jruby/util/io/EncodingUtils.java b/core/src/main/java/org/jruby/util/io/EncodingUtils.java
@@ -38,7 +38,9 @@
 import org.jruby.runtime.encoding.EncodingCapable;
 import org.jruby.runtime.encoding.EncodingService;
 import org.jruby.util.ByteList;
+import org.jruby.util.ByteListHolder;
 import org.jruby.util.CodeRangeSupport;
+import org.jruby.util.CodeRangeable;
 import org.jruby.util.StringSupport;
 import org.jruby.util.TypeConverter;
 
@@ -1461,7 +1463,7 @@ public static void  rbStrBufCat(Ruby runtime, RubyString str, ByteList ptr) {
         // negative length check here, we shouldn't need
         strBufCat(runtime, str, ptr);
     }
-    public static void  rbStrBufCat(Ruby runtime, RubyString str, byte[] ptrBytes, int ptr, int len) {
+    public static void  rbStrBufCat(Ruby runtime, ByteListHolder str, byte[] ptrBytes, int ptr, int len) {
         if (len == 0) return;
         // negative length check here, we shouldn't need
         strBufCat(runtime, str, ptrBytes, ptr, len);
@@ -1476,7 +1478,7 @@ public static void  rbStrBufCat(Ruby runtime, ByteList str, byte[] ptrBytes, int
     public static void strBufCat(Ruby runtime, RubyString str, ByteList ptr) {
         strBufCat(runtime, str, ptr.getUnsafeBytes(), ptr.getBegin(), ptr.getRealSize());
     }
-    public static void strBufCat(Ruby runtime, RubyString str, byte[] ptrBytes, int ptr, int len) {
+    public static void strBufCat(Ruby runtime, ByteListHolder str, byte[] ptrBytes, int ptr, int len) {
         str.modify();
         strBufCat(str.getByteList(), ptrBytes, ptr, len);
     }
@@ -1508,16 +1510,16 @@ public static void encStrBufCat(Ruby runtime, RubyString str, byte[] ptrBytes, i
     }
 
     // rb_enc_cr_str_buf_cat
-    public static void encCrStrBufCat(Ruby runtime, RubyString str, ByteList ptr, Encoding ptrEnc, int ptr_cr, int[] ptr_cr_ret) {
+    public static void encCrStrBufCat(Ruby runtime, CodeRangeable str, ByteList ptr, Encoding ptrEnc, int ptr_cr, int[] ptr_cr_ret) {
         encCrStrBufCat(runtime, str, ptr.getUnsafeBytes(), ptr.getBegin(), ptr.getRealSize(), ptrEnc, ptr_cr, ptr_cr_ret);
     }
-    public static void encCrStrBufCat(Ruby runtime, RubyString str, byte[] ptrBytes, int ptr, int len, Encoding ptrEnc, int ptr_cr, int[] ptr_cr_ret) {
-        Encoding strEnc = str.getEncoding();
+    public static void encCrStrBufCat(Ruby runtime, CodeRangeable str, byte[] ptrBytes, int ptr, int len, Encoding ptrEnc, int ptr_cr, int[] ptr_cr_ret) {
+        Encoding strEnc = str.getByteList().getEncoding();
         Encoding resEnc;
         int str_cr, res_cr;
         boolean incompatible = false;
 
-        str_cr = str.size() > 0 ? str.getCodeRange() : StringSupport.CR_7BIT;
+        str_cr = str.getByteList().getRealSize() > 0 ? str.getCodeRange() : StringSupport.CR_7BIT;
 
         if (strEnc == ptrEnc) {
             if (str_cr == StringSupport.CR_UNKNOWN) {
@@ -1530,9 +1532,10 @@ public static void encCrStrBufCat(Ruby runtime, RubyString str, byte[] ptrBytes,
                 if (len == 0) {
                     return;
                 }
-                if (str.size() == 0) {
+                if (str.getByteList().getRealSize() == 0) {
                     rbStrBufCat(runtime, str, ptrBytes, ptr, len);
-                    str.setEncodingAndCodeRange(ptrEnc, ptr_cr);
+                    str.getByteList().setEncoding(ptrEnc);
+                    str.setCodeRange(ptr_cr);
                     return;
                 }
                 incompatible = true;
@@ -1586,7 +1589,8 @@ public static void encCrStrBufCat(Ruby runtime, RubyString str, byte[] ptrBytes,
         // MRI checks for len < 0 here, but I don't think that's possible for us
 
         strBufCat(runtime, str, ptrBytes, ptr, len);
-        str.setEncodingAndCodeRange(resEnc, res_cr);
+        str.getByteList().setEncoding(resEnc);
+        str.setCodeRange(res_cr);
     }
 
     // econv_args

diff --git a/spec/truffle/tags/core/string/concat_tags.txt b/spec/truffle/tags/core/string/concat_tags.txt
@@ -5,9 +5,3 @@ fails:String#concat with Integer returns a ASCII-8BIT string if self is US-ASCII
 fails:String#concat with Integer raises RangeError if the argument is an invalid codepoint for self's encoding
 fails:String#concat with Integer raises RangeError if the argument is negative
 fails:String#concat with Integer raises a RuntimeError when self is frozen
-fails:String#concat when self is in an ASCII-incompatible encoding incompatible with the argument's encoding uses the argument's encoding if self is empty
-fails:String#concat when self is in an ASCII-incompatible encoding incompatible with the argument's encoding raises Encoding::CompatibilityError if neither are empty
-fails:String#concat when the argument is in an ASCII-incompatible encoding incompatible with self's encoding uses the argument's encoding if self is empty
-fails:String#concat when the argument is in an ASCII-incompatible encoding incompatible with self's encoding raises Encoding::CompatibilityError if neither are empty
-fails:String#concat when self and the argument are in different ASCII-compatible encodings uses the argument's encoding if self is ASCII-only
-fails:String#concat when self and the argument are in different ASCII-compatible encodings raises Encoding::CompatibilityError if neither are ASCII-only
diff --git a/spec/truffle/tags/core/string/valid_encoding_tags.txt b/spec/truffle/tags/core/string/valid_encoding_tags.txt
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/StringNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/StringNodes.java
@@ -43,6 +43,7 @@
 import org.jruby.util.ByteList;
 import org.jruby.util.Pack;
 import org.jruby.util.StringSupport;
+import org.jruby.util.io.EncodingUtils;
 
 import java.math.BigInteger;
 import java.nio.ByteBuffer;
@@ -226,7 +227,23 @@ public RubyString concat(RubyString string, RubyString other) {
                 throw new RaiseException(getContext().getCoreLibrary().frozenError("String", this));
             }
 
-            string.getBytes().append(other.getBytes());
+            final int codeRange = other.getCodeRange();
+            final int[] ptr_cr_ret = { codeRange };
+
+            try {
+                EncodingUtils.encCrStrBufCat(getContext().getRuntime(), string, other.getByteList(), other.getByteList().getEncoding(), codeRange, ptr_cr_ret);
+            } catch (org.jruby.exceptions.RaiseException e) {
+                if (e.getException().getMetaClass().equals(getContext().getRuntime().getEncodingCompatibilityError())) {
+                    CompilerDirectives.transferToInterpreter();
+
+                    throw new RaiseException(getContext().getCoreLibrary().encodingCompatibilityError(e.getException().message.asJavaString(), this));
+                }
+
+                throw e;
+            }
+
+            other.setCodeRange(ptr_cr_ret[0]);
+
             return string;
         }
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/core/RubyString.java b/truffle/src/main/java/org/jruby/truffle/runtime/core/RubyString.java
@@ -205,6 +205,12 @@ public final void clearCodeRange() {
         codeRange = StringSupport.CR_UNKNOWN;
     }
 
+    @Override
+    public final void modify() {
+        // TODO (nirvdrum 16-Feb-15): This should check whether the underlying ByteList is being shared and copy if necessary.
+        bytes.invalidate();
+    }
+
     @Override
     public final void modify(int length) {
         // TODO (nirvdrum Jan. 13, 2015): This should check whether the underlying ByteList is being shared and copy if necessary.