Add Primitive.string_binary_append and start using it

Author: eregon

src/main/java/org/truffleruby/core/string/StringNodes.java

@@ -4247,6 +4247,8 @@ private Object bytesToInum(AbstractTruffleString tstring, RubyEncoding encoding,
         }
     }
 
+    /** The semantics of this primitive are such that the original string's byte[] should be extended without
+     * negotiating the encoding. */
     @Primitive(name = "string_byte_append")
     public abstract static class StringByteAppendPrimitiveNode extends PrimitiveArrayArgumentsNode {
         @Specialization(guards = "libOther.isRubyString(other)", limit = "1")
@@ -4255,8 +4257,7 @@ protected RubyString stringByteAppend(RubyString string, Object other,
                 @Cached RubyStringLibrary libOther,
                 @Cached TruffleString.ConcatNode concatNode,
                 @Cached TruffleString.ForceEncodingNode forceEncodingNode) {
-            // The semantics of this primitive are such that the original string's byte[] should be extended without
-            // negotiating the encoding.
+
             var leftEncoding = libString.getEncoding(string);
             var left = string.tstring;
             var right = forceEncodingNode.execute(libOther.getTString(other), libOther.getTEncoding(other),
@@ -4266,6 +4267,28 @@ protected RubyString stringByteAppend(RubyString string, Object other,
         }
     }
 
+    /** The semantics of this primitive are such that the LHS string must be BINARY and then the result is BINARY as
+     * well, and the RHS bytes are just appended to the LHS bytes, without encoding negotiation (which could cause the
+     * LHS encoding to change). */
+    @Primitive(name = "string_binary_append")
+    public abstract static class StringBinaryAppendNode extends PrimitiveArrayArgumentsNode {
+        @Specialization(guards = "libOther.isRubyString(other)", limit = "1")
+        protected RubyString stringBinaryAppend(RubyString string, Object other,
+                @Cached RubyStringLibrary libString,
+                @Cached RubyStringLibrary libOther,
+                @Cached TruffleString.ConcatNode concatNode,
+                @Cached TruffleString.ForceEncodingNode forceEncodingNode) {
+            if (libString.getEncoding(string) != Encodings.BINARY) {
+                throw CompilerDirectives.shouldNotReachHere("LHS String must be BINARY");
+            }
+            var left = string.tstring;
+            var right = forceEncodingNode.execute(libOther.getTString(other), libOther.getTEncoding(other),
+                    Encodings.BINARY.tencoding);
+            string.setTString(concatNode.execute(left, right, Encodings.BINARY.tencoding, true), Encodings.BINARY);
+            return string;
+        }
+    }
+
     @Primitive(name = "string_substring", lowerFixnum = { 1, 2 })
     @ImportStatic(StringGuards.class)
     public abstract static class StringSubstringPrimitiveNode extends PrimitiveArrayArgumentsNode {

src/main/ruby/truffleruby/core/marshal.rb

@@ -158,30 +158,31 @@ def __custom_marshal__(ms)
     end
 
     ivars = Primitive.object_ivars(self)
-    out << 'I'.b
+    Primitive.string_binary_append out, 'I'
 
     cls = Primitive.object_class self
     if Primitive.module_anonymous?(cls)
       raise TypeError, "can't dump anonymous class #{cls}"
     end
     name = Primitive.module_name cls
-    out << Truffle::Type.binary_string("u#{ms.serialize(name.to_sym)}")
+    Primitive.string_binary_append out, "u#{ms.serialize(name.to_sym)}"
 
     str = _dump
-    out << ms.serialize_integer(str.bytesize) + str.b
+    Primitive.string_binary_append out, ms.serialize_integer(str.bytesize)
+    Primitive.string_binary_append out, str
 
     count = ivars.size + extra_values.size
-    out << ms.serialize_integer(count)
+    Primitive.string_binary_append out, ms.serialize_integer(count)
 
     ivars.each do |ivar|
       val = Primitive.object_ivar_get self, ivar
-      out << ms.serialize(ivar)
-      out << ms.serialize(val)
+      Primitive.string_binary_append out, ms.serialize(ivar)
+      Primitive.string_binary_append out, ms.serialize(val)
     end
 
     extra_values.each_pair do |key, value|
-      out << ms.serialize(key)
-      out << ms.serialize(value)
+      Primitive.string_binary_append out, ms.serialize(key)
+      Primitive.string_binary_append out, ms.serialize(value)
     end
 
     out