TruffleStrings: fix SwitchEncodingNode breaking string compaction invariants on native UTF-32 strings

Author: djoooooe

truffle/src/com.oracle.truffle.api.strings.test/src/com/oracle/truffle/api/strings/test/ops/TStringSwitchEncodingTest.java

@@ -133,8 +133,9 @@ public void testAll() throws Exception {
                                 : new TranscodingErrorHandler[]{TranscodingErrorHandler.DEFAULT}) {
                     TruffleString b = node.execute(a, targetEncoding, errorHandler);
                     MutableTruffleString bMutable = nodeMutable.execute(a, targetEncoding, errorHandler);
-                    if (a instanceof TruffleString &&
-                                    (encoding == targetEncoding || !isDebugStrictEncodingChecks() && codeRange == TruffleString.CodeRange.ASCII && isAsciiCompatible(targetEncoding))) {
+                    if (a instanceof TruffleString && (encoding == targetEncoding || !isDebugStrictEncodingChecks() &&
+                                    codeRange == TruffleString.CodeRange.ASCII && isAsciiCompatible(targetEncoding) &&
+                                    a.getStringCompactionLevelUncached(encoding).getLog2() <= getNaturalStride(targetEncoding))) {
                         Assert.assertSame(a, b);
                     }
                     if (a instanceof MutableTruffleString && encoding == targetEncoding) {

truffle/src/com.oracle.truffle.api.strings/src/com/oracle/truffle/api/strings/TruffleString.java

@@ -6395,33 +6395,35 @@ abstract static class InternalSwitchEncodingNode extends AbstractInternalNode {
 
         abstract TruffleString execute(Node node, AbstractTruffleString a, Encoding targetEncoding, TranscodingErrorHandler errorHandler);
 
-        @Specialization(guards = "a.isCompatibleToIntl(targetEncoding)")
-        static TruffleString compatibleImmutable(TruffleString a, @SuppressWarnings("unused") Encoding targetEncoding, @SuppressWarnings("unused") TranscodingErrorHandler errorHandler) {
-            assert !a.isJavaString();
-            return a;
-        }
-
-        @Specialization(guards = "a.isCompatibleToIntl(targetEncoding)")
-        static TruffleString compatibleMutable(Node node, MutableTruffleString a, Encoding targetEncoding, @SuppressWarnings("unused") TranscodingErrorHandler errorHandler,
-                        @Cached InternalAsTruffleStringNode asTruffleStringNode) {
-            return asTruffleStringNode.execute(node, a, targetEncoding);
-        }
-
-        @Specialization(guards = "!a.isCompatibleToIntl(targetEncoding)")
-        static TruffleString transCode(Node node, TruffleString a, Encoding targetEncoding, TranscodingErrorHandler errorHandler,
+        @Specialization
+        static TruffleString immutable(Node node, TruffleString a, Encoding targetEncoding, TranscodingErrorHandler errorHandler,
                         @Cached @Shared TStringInternalNodes.GetPreciseCodeRangeNode getPreciseCodeRangeNode,
-                        @Cached InlinedConditionProfile preciseCodeRangeIsCompatibleProfile,
+                        @Cached InlinedConditionProfile isCompatibleProfile,
+                        @Cached InlinedConditionProfile noOpProfile,
+                        @Cached InlinedConditionProfile mustCompactProfile,
+                        @Cached InlinedConditionProfile compact10Profile,
+                        @Cached InlinedConditionProfile compact20Profile,
                         @Exclusive @Cached InlinedConditionProfile cacheHit,
                         @Cached ToIndexableNode toIndexableNode,
                         @Cached @Shared TStringInternalNodes.TransCodeNode transCodeNode) {
-            if (a.isEmpty()) {
-                return targetEncoding.getEmpty();
+            final boolean isCompatible;
+            final int preciseCodeRangeA;
+            if (isCompatibleProfile.profile(node, a.isCompatibleToIntl(targetEncoding))) {
+                isCompatible = true;
+                preciseCodeRangeA = a.codeRange();
+            } else {
+                Encoding encodingA = Encoding.get(a.encoding());
+                preciseCodeRangeA = getPreciseCodeRangeNode.execute(node, a, encodingA);
+                isCompatible = a.isCodeRangeCompatibleTo(preciseCodeRangeA, targetEncoding);
             }
-            Encoding encodingA = Encoding.get(a.encoding());
-            int preciseCodeRangeA = getPreciseCodeRangeNode.execute(node, a, encodingA);
-            if (preciseCodeRangeIsCompatibleProfile.profile(node, a.isCodeRangeCompatibleTo(preciseCodeRangeA, targetEncoding))) {
+            final boolean mustCompact = a.stride() > targetEncoding.naturalStride;
+            if (noOpProfile.profile(node, isCompatible && !mustCompact)) {
+                assert !a.isJavaString();
                 return a;
             }
+            if (a.isEmpty()) {
+                return targetEncoding.getEmpty();
+            }
             TruffleString cur = a.next;
             assert !a.isJavaString();
             if (cur != null) {
@@ -6433,13 +6435,40 @@ static TruffleString transCode(Node node, TruffleString a, Encoding targetEncodi
                     return cur;
                 }
             }
-            TruffleString transCoded = transCodeNode.execute(node, a, toIndexableNode.execute(node, a, a.data()), a.codePointLength(), preciseCodeRangeA, targetEncoding, errorHandler);
+            final TruffleString transCoded;
+            if (mustCompactProfile.profile(node, isCompatible && mustCompact)) {
+                final Object arrayA = a.data();
+                assert arrayA instanceof NativePointer;
+                final int offsetA = a.offset();
+                final int strideA = a.stride();
+                final int offset = 0;
+                final int lengthA = a.length();
+                final int stride = Stride.fromCodeRangeUTF16(preciseCodeRangeA);
+                final byte[] array = new byte[lengthA << stride];
+                if (compact10Profile.profile(node, strideA == 1 && stride == 0)) {
+                    TStringOps.arraycopyWithStride(node, arrayA, offsetA, 1, 0, array, offset, 0, 0, lengthA);
+                } else if (compact20Profile.profile(node, strideA == 2 && stride == 0)) {
+                    TStringOps.arraycopyWithStride(node, arrayA, offsetA, 2, 0, array, offset, 0, 0, lengthA);
+                } else {
+                    assert strideA == 2 && stride == 1;
+                    TStringOps.arraycopyWithStride(node, arrayA, offsetA, 2, 0, array, offset, 1, 0, lengthA);
+                }
+                transCoded = TruffleString.createFromArray(array, offset, lengthA, stride, targetEncoding, a.codePointLength(), preciseCodeRangeA, false);
+            } else {
+                transCoded = transCodeNode.execute(node, a, toIndexableNode.execute(node, a, a.data()), a.codePointLength(), preciseCodeRangeA, targetEncoding, errorHandler);
+            }
             if (!transCoded.isCacheHead()) {
                 a.cacheInsert(transCoded);
             }
             return transCoded;
         }
 
+        @Specialization(guards = "a.isCompatibleToIntl(targetEncoding)")
+        static TruffleString compatibleMutable(Node node, MutableTruffleString a, Encoding targetEncoding, @SuppressWarnings("unused") TranscodingErrorHandler errorHandler,
+                        @Cached InternalAsTruffleStringNode asTruffleStringNode) {
+            return asTruffleStringNode.execute(node, a, targetEncoding);
+        }
+
         @Specialization(guards = "!a.isCompatibleToIntl(targetEncoding)")
         static TruffleString transCodeMutable(Node node, MutableTruffleString a, Encoding targetEncoding, TranscodingErrorHandler errorHandler,
                         @Cached TStringInternalNodes.GetCodePointLengthNode getCodePointLengthNode,