Use the narrowest character width possible for substrings.

runtime/vm/object.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/object.h"
 
 #include "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 5799 matching lines @@
   for (intptr_t i = 0; i < strings_len; i++) {
     str ^= strings.At(i);
     intptr_t str_len = str.Length();
     String::Copy(result, pos, str, 0, str_len);
     pos += str_len;
   }
   return result.raw();
 }
 
 
-RawOneByteString* OneByteString::SubString(const OneByteString& str,
-                                           intptr_t begin_index,
-                                           intptr_t length,
-                                           Heap::Space space) {
+RawString* OneByteString::SubString(const OneByteString& str,
+                                    intptr_t begin_index,
+                                    intptr_t length,
+                                    Heap::Space space) {
   ASSERT(!str.IsNull());
   ASSERT(begin_index < str.Length());
   OneByteString& result = OneByteString::Handle();
   if (length <= (str.Length() - begin_index)) {
     result ^= OneByteString::New(length, space);
     String::Copy(result, 0, str, begin_index, length);
   }
   // TODO(5418937): return a non-null object on error.
   return result.raw();
 }
@@ skipping 79 matching lines @@
   for (intptr_t i = 0; i < strings_len; i++) {
     str ^= strings.At(i);
     intptr_t str_len = str.Length();
     String::Copy(result, pos, str, 0, str_len);
     pos += str_len;
   }
   return result.raw();
 }
 
 
-RawTwoByteString* TwoByteString::SubString(const TwoByteString& str,
-                                           intptr_t begin_index,
-                                           intptr_t length,
-                                           Heap::Space space) {
+RawString* TwoByteString::SubString(const TwoByteString& str,
+                                    intptr_t begin_index,
+                                    intptr_t length,
+                                    Heap::Space space) {
   ASSERT(!str.IsNull());
   ASSERT(begin_index < str.Length());
-  TwoByteString& result = TwoByteString::Handle();
+  String& result = String::Handle();
   if (length <= (str.Length() - begin_index)) {
-    result ^= TwoByteString::New(length, space);
+    bool is_one_byte_string = true;
+    for (intptr_t i = begin_index; i < begin_index + length; ++i) {
+      if (str.CharAt(i) > 0xFF) {
+        is_one_byte_string = false;
+        break;
+      }
+    }
+    if (is_one_byte_string) {
+      result ^= OneByteString::New(length, space);
+    } else {
+      result ^= TwoByteString::New(length, space);
+    }
     String::Copy(result, 0, str, begin_index, length);
   }
   // TODO(5418937): return a non-null object on error.
   return result.raw();
 }
 
 
 const char* TwoByteString::ToCString() const {
   return String::ToCString();
 }
@@ skipping 63 matching lines @@
       str ^= strings.At(i);
       intptr_t str_len = str.Length();
       String::Copy(result, pos, str, 0, str_len);
       pos += str_len;
     }
   }
   return result.raw();
 }
 
 
-RawFourByteString* FourByteString::SubString(const FourByteString& str,
-                                             intptr_t begin_index,
-                                             intptr_t length,
-                                             Heap::Space space) {
+RawString* FourByteString::SubString(const FourByteString& str,
+                                     intptr_t begin_index,
+                                     intptr_t length,
+                                     Heap::Space space) {
   ASSERT(!str.IsNull());
   ASSERT(begin_index < str.Length());
-  FourByteString& result = FourByteString::Handle();
+  String& result = String::Handle();
   if (length <= (str.Length() - begin_index)) {
-    result ^= FourByteString::New(length, space);
+    bool is_one_byte_string = true;
+    bool is_two_byte_string = true;
+    for (intptr_t i = begin_index; i < begin_index + length; ++i) {
+      if (str.CharAt(i) > 0xFFFF) {
+        is_one_byte_string = false;
+        is_two_byte_string = false;
+        break;
+      } else if (str.CharAt(i) > 0xFF) {
+        is_one_byte_string = false;
+      }
+    }
+    if (is_one_byte_string) {
+      result ^= OneByteString::New(length, space);
+    } else if (is_two_byte_string) {
+      result ^= TwoByteString::New(length, space);
+    } else {
+      result ^= FourByteString::New(length, space);
+    }
     String::Copy(result, 0, str, begin_index, length);
   }
   // TODO(5418937): return a non-null object on error.
   return result.raw();
 }
 
 
 const char* FourByteString::ToCString() const {
   return String::ToCString();
 }
@@ skipping 425 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart