Add some support for the code-point code-unit distinction.

runtime/vm/object.cc

 // Copyright (c) 2012, 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 "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 123 matching lines @@
 //   _MyClass@6b3832b.named -> _MyClass.named
 //
 static RawString* IdentifierPrettyName(const String& name) {
   intptr_t len = name.Length();
   intptr_t start = 0;
   intptr_t at_pos = len;   // Position of '@' in the name.
   intptr_t dot_pos = len;  // Position of '.' in the name.
   bool is_setter = false;
 
   for (int i = 0; i < name.Length(); i++) {
-    if (name.CharAt(i) == ':') {
+    if (name.CodeUnitAt(i) == ':') {

[cshapiro, 2012/11/15 20:14:51]

This file is an example of why we would like the rename and unsigned type
changes to be removed from this change.

[erikcorry, 2012/11/15 23:47:05]

Done.

       ASSERT(start == 0);
-      if (name.CharAt(0) == 's') {
+      if (name.CodeUnitAt(0) == 's') {
         is_setter = true;
       }
       start = i + 1;
-    } else if (name.CharAt(i) == '@') {
+    } else if (name.CodeUnitAt(i) == '@') {
       ASSERT(at_pos == len);
       at_pos = i;
-    } else if (name.CharAt(i) == '.') {
+    } else if (name.CodeUnitAt(i) == '.') {
       dot_pos = i;
       break;
     }
   }
   intptr_t limit = (at_pos < dot_pos ? at_pos : dot_pos);
   if (start == 0 && limit == len) {
     // This name is fine as it is.
     return name.raw();
   }
 
   const String& result =
       String::Handle(String::SubString(name, start, (limit - start)));
 
   // Look for a second '@' now to correctly handle names like
   // "_ReceivePortImpl@6be832b._internal@6be832b".
   at_pos = len;
   for (int i = dot_pos; i < name.Length(); i++) {
-    if (name.CharAt(i) == '@') {
+    if (name.CodeUnitAt(i) == '@') {
       ASSERT(at_pos == len);
       at_pos = i;
     }
   }
 
   intptr_t suffix_len = at_pos - dot_pos;
   if (suffix_len > 1) {
     // This is a named constructor.  Add the name back to the string.
     const String& suffix =
         String::Handle(String::SubString(name, dot_pos, suffix_len));
@@ skipping 300 matching lines @@
       Class::NewInterface(name, script, Scanner::kDummyTokenIndex));
   lib.AddClass(cls);
   return cls.raw();
 }
 
 
 void Object::RegisterClass(const Class& cls,
                            const String& name,
                            const Library& lib) {
   ASSERT(name.Length() > 0);
-  ASSERT(name.CharAt(0) != '_');
+  ASSERT(name.CodeUnitAt(0) != '_');
   cls.set_name(name);
   lib.AddClass(cls);
 }
 
 
 void Object::RegisterPrivateClass(const Class& cls,
                                   const String& public_class_name,
                                   const Library& lib) {
   ASSERT(public_class_name.Length() > 0);
-  ASSERT(public_class_name.CharAt(0) == '_');
+  ASSERT(public_class_name.CodeUnitAt(0) == '_');
   String& str = String::Handle();
   str = lib.PrivateName(public_class_name);
   cls.set_name(str);
   lib.AddClass(cls);
 }
 
 
 RawError* Object::Init(Isolate* isolate) {
   TIMERSCOPE(time_bootstrap);
   ObjectStore* object_store = isolate->object_store();
@@ skipping 1667 matching lines @@
                                 const char* prefix,
                                 intptr_t prefix_length,
                                 const String& accessor_name) {
   intptr_t name_len = name.Length();
   intptr_t accessor_name_len = accessor_name.Length();
 
   if (name_len != (accessor_name_len + prefix_length)) {
     return false;
   }
   for (intptr_t i = 0; i < prefix_length; i++) {
-    if (name.CharAt(i) != prefix[i]) {
+    if (name.CodeUnitAt(i) != static_cast<uint32_t>(prefix[i])) {
       return false;
     }
   }
   for (intptr_t i = 0, j = prefix_length; i < accessor_name_len; i++, j++) {
-    if (name.CharAt(j) != accessor_name.CharAt(i)) {
+    if (name.CodeUnitAt(j) != accessor_name.CodeUnitAt(i)) {
       return false;
     }
   }
   return true;
 }
 
 
 RawFunction* Class::LookupFunction(const String& name) const {
   Isolate* isolate = Isolate::Current();
   ASSERT(name.IsOneByteString());
@@ skipping 2284 matching lines @@
     literal = iterator.MakeLiteralToken(obj);
     // Advance to be able to use next token kind.
     iterator.Advance();
     Token::Kind next = iterator.CurrentTokenKind();
 
     // Handle the current token.
     if (curr == Token::kSTRING) {
       bool is_raw_string = false;
       bool escape_characters = false;
       for (intptr_t i = 0; i < literal.Length(); i++) {
-        if (IsSpecialCharacter(literal.CharAt(i))) {
+        if (IsSpecialCharacter(literal.CodeUnitAt(i))) {
           escape_characters = true;
         }
         // TODO(4995): Temp solution for raw strings, this will break
         // if we saw a string that is not a raw string but has back slashes
         // in it.
-        if ((literal.CharAt(i) == '\\')) {
+        if ((literal.CodeUnitAt(i) == '\\')) {
           if ((next != Token::kINTERPOL_VAR) &&
               (next != Token::kINTERPOL_START) &&
               (prev != Token::kINTERPOL_VAR) &&
               (prev != Token::kINTERPOL_END)) {
             is_raw_string = true;
           } else {
             escape_characters = true;
           }
         }
       }
       if ((prev != Token::kINTERPOL_VAR) && (prev != Token::kINTERPOL_END)) {
         if (is_raw_string) {
           literals.Add(raw_string);
         }
         literals.Add(double_quotes);
       }
       if (escape_characters) {
         literal = String::EscapeSpecialCharacters(literal, is_raw_string);
         literals.Add(literal);
       } else {
         literals.Add(literal);
       }
       if ((next != Token::kINTERPOL_VAR) && (next != Token::kINTERPOL_START)) {
         literals.Add(double_quotes);
       }
     } else if (curr == Token::kINTERPOL_VAR) {
       literals.Add(dollar);
-      if (literal.CharAt(0) == Scanner::kPrivateIdentifierStart) {
+      if (literal.CodeUnitAt(0) == Scanner::kPrivateIdentifierStart) {
         literal = String::SubString(literal, 0, literal.Length() - private_len);
       }
       literals.Add(literal);
     } else if (curr == Token::kIDENT) {
-      if (literal.CharAt(0) == Scanner::kPrivateIdentifierStart) {
+      if (literal.CodeUnitAt(0) == Scanner::kPrivateIdentifierStart) {
         literal = String::SubString(literal, 0, literal.Length() - private_len);
       }
       literals.Add(literal);
     } else {
       literals.Add(literal);
     }
     // Determine the separation text based on this current token.
     const String* separator = NULL;
     switch (curr) {
       case Token::kLBRACE:
@@ skipping 523 matching lines @@
   const String& src = String::Handle(Source());
   intptr_t current_line = 1;
   intptr_t line_start = -1;
   intptr_t last_char = -1;
   for (intptr_t ix = 0;
        (ix < src.Length()) && (current_line <= line_number);
        ix++) {
     if ((current_line == line_number) && (line_start < 0)) {
       line_start = ix;
     }
-    if (src.CharAt(ix) == '\n') {
+    if (src.CodeUnitAt(ix) == '\n') {
       current_line++;
-    } else if (src.CharAt(ix) == '\r') {
-      if ((ix + 1 != src.Length()) && (src.CharAt(ix + 1) != '\n')) {
+    } else if (src.CodeUnitAt(ix) == '\r') {
+      if ((ix + 1 != src.Length()) && (src.CodeUnitAt(ix + 1) != '\n')) {
         current_line++;
       }
     } else {
       last_char = ix;
     }
   }
   // Guarantee that returned string is never NULL.
   String& line = String::Handle(Symbols::Empty());
   if (line_start >= 0) {
     line = String::SubString(src, line_start, last_char - line_start + 1);
   }
   return line.raw();
 }
 
 
 RawString* Script::GetSnippet(intptr_t from_line,
                               intptr_t from_column,
                               intptr_t to_line,
                               intptr_t to_column) const {
   const String& src = String::Handle(Source());
   intptr_t length = src.Length();
   intptr_t line = 1;
   intptr_t column = 1;
   intptr_t lookahead = 0;
   intptr_t snippet_start = -1;
   intptr_t snippet_end = -1;
-  char c = src.CharAt(lookahead);
+  char c = src.CodeUnitAt(lookahead);
   while (lookahead != length) {
     if (snippet_start == -1) {
       if ((line == from_line) && (column == from_column)) {
         snippet_start = lookahead;
       }
     } else if ((line == to_line) && (column == to_column)) {
       snippet_end = lookahead;
       break;
     }
     if (c == '\n') {
       line++;
       column = 0;
     }
     column++;
     lookahead++;
     if (lookahead != length) {
       // Replace '\r' with '\n' and a sequence of '\r' '\n' with a single '\n'.
-      if (src.CharAt(lookahead) == '\r') {
+      if (src.CodeUnitAt(lookahead) == '\r') {
         c = '\n';
-        if (lookahead + 1 != length && src.CharAt(lookahead) == '\n') {
+        if (lookahead + 1 != length && src.CodeUnitAt(lookahead) == '\n') {
           lookahead++;
         }
       } else {
-        c = src.CharAt(lookahead);
+        c = src.CodeUnitAt(lookahead);
       }
     }
   }
   String& snippet = String::Handle();
   if ((snippet_start != -1) && (snippet_end != -1)) {
     snippet =
         String::SubString(src, snippet_start, snippet_end - snippet_start);
   }
   return snippet.raw();
 }
@@ skipping 379 matching lines @@
 
 RawObject* Library::LookupLocalObject(const String& name) const {
   intptr_t index;
   return LookupEntry(name, &index);
 }
 
 
 static bool ShouldBePrivate(const String& name) {
   return
       (name.Length() >= 1 &&
-       name.CharAt(0) == '_') ||
+       name.CodeUnitAt(0) == '_') ||
       (name.Length() >= 5 &&
-       (name.CharAt(4) == '_' &&
-        (name.CharAt(0) == 'g' || name.CharAt(0) == 's') &&
-        name.CharAt(1) == 'e' &&
-        name.CharAt(2) == 't' &&
-        name.CharAt(3) == ':'));
+       (name.CodeUnitAt(4) == '_' &&
+        (name.CodeUnitAt(0) == 'g' || name.CodeUnitAt(0) == 's') &&
+        name.CodeUnitAt(1) == 'e' &&
+        name.CodeUnitAt(2) == 't' &&
+        name.CodeUnitAt(3) == ':'));
 }
 
 
 RawField* Library::LookupFieldAllowPrivate(const String& name) const {
   // First check if name is found in the local scope of the library.
   Field& field = Field::Handle(LookupLocalField(name));
   if (!field.IsNull()) {
     return field.raw();
   }
 
@@ skipping 4294 matching lines @@
   return result;
 }
 
 
 intptr_t String::Hash(const String& str, intptr_t begin_index, intptr_t len) {
   ASSERT(begin_index >= 0);
   ASSERT(len >= 0);
   ASSERT((begin_index + len) <= str.Length());
   StringHasher hasher;
   for (intptr_t i = 0; i < len; i++) {
-    hasher.Add(str.CharAt(begin_index + i));
+    hasher.Add(str.CodeUnitAt(begin_index + i));
   }
   return hasher.Finalize(String::kHashBits);
 }
 
 
 template<typename T>
 static intptr_t HashImpl(const T* characters, intptr_t len) {
   ASSERT(len >= 0);
   StringHasher hasher;
   for (intptr_t i = 0; i < len; i++) {
@@ skipping 11 matching lines @@
 intptr_t String::Hash(const uint16_t* characters, intptr_t len) {
   return HashImpl(characters, len);
 }
 
 
 intptr_t String::Hash(const uint32_t* characters, intptr_t len) {
   return HashImpl(characters, len);
 }
 
 
-int32_t String::CharAt(intptr_t index) const {
+uint32_t String::CodeUnitAt(intptr_t index) const {
   intptr_t class_id = raw()->GetClassId();
   ASSERT(RawObject::IsStringClassId(class_id));
   NoGCScope no_gc;
   if (class_id == kOneByteStringCid) {
-      return *OneByteString::CharAddr(*this, index);
+      return OneByteString::CodeUnitAt(*this, index);
   }
   if (class_id == kTwoByteStringCid) {
-      return *TwoByteString::CharAddr(*this, index);
+      return TwoByteString::CodeUnitAt(*this, index);
   }
   if (class_id == kExternalOneByteStringCid) {
-      return *ExternalOneByteString::CharAddr(*this, index);
+      return ExternalOneByteString::CodeUnitAt(*this, index);
   }
   ASSERT(class_id == kExternalTwoByteStringCid);
-  return *ExternalTwoByteString::CharAddr(*this, index);
+  return ExternalTwoByteString::CodeUnitAt(*this, index);
 }
 
 
 intptr_t String::CharSize() const {
   intptr_t class_id = raw()->GetClassId();
   if (class_id == kOneByteStringCid || class_id == kExternalOneByteStringCid) {
     return kOneByteChar;
   }
   ASSERT(class_id == kTwoByteStringCid ||
          class_id == kExternalTwoByteStringCid);
@@ skipping 31 matching lines @@
 
 
 bool String::Equals(const char* str) const {
   ASSERT(str != NULL);
   intptr_t len = strlen(str);
   for (intptr_t i = 0; i < this->Length(); ++i) {
     if (*str == '\0') {
       // Lengths don't match.
       return false;
     }
-    int32_t ch;
+    uint32_t ch;
     intptr_t consumed = Utf8::Decode(reinterpret_cast<const uint8_t*>(str),
                                      len,
                                      &ch);
-    if (consumed == 0 || this->CharAt(i) != ch) {
-      return false;
+    if (consumed == 0) return false;
+
+    if (ch <= Utf16::kMaxCodeUnit) {
+      if (this->CodeUnitAt(i) != ch) return false;
+    } else {
+      if (Utf16::CodePointAt(*this, i) != ch) return false;
+      i++;
     }
     str += consumed;
     len -= consumed;
   }
   return *str == '\0';
 }
 
 
 bool String::Equals(const uint8_t* characters, intptr_t len) const {
   if (len != this->Length()) {
     // Lengths don't match.
     return false;
   }
 
   for (intptr_t i = 0; i < len; i++) {
-    if (this->CharAt(i) != characters[i]) {
+    if (this->CodeUnitAt(i) != characters[i]) {
       return false;
     }
   }
   return true;
 }
 
 
 bool String::Equals(const uint16_t* characters, intptr_t len) const {
   if (len != this->Length()) {
     // Lengths don't match.
     return false;
   }
 
   for (intptr_t i = 0; i < len; i++) {
-    if (this->CharAt(i) != characters[i]) {
+    if (this->CodeUnitAt(i) != characters[i]) {
       return false;
     }
   }
   return true;
 }
 
 
 bool String::Equals(const uint32_t* characters, intptr_t len) const {
   if (len != this->Length()) {
     // Lengths don't match.
     return false;
   }
 
   for (intptr_t i = 0; i < len; i++) {
-    if (this->CharAt(i) != static_cast<int32_t>(characters[i])) {
+    uint32_t c = this->CodeUnitAt(i);
+    if (c != characters[i]) {
       return false;
     }
+    if (c > Utf16::kMaxCodeUnit) i++;
   }
   return true;
 }
 
 
 intptr_t String::CompareTo(const String& other) const {
   const intptr_t this_len = this->Length();
   const intptr_t other_len = other.IsNull() ? 0 : other.Length();
   const intptr_t len = (this_len < other_len) ? this_len : other_len;
+  // UTF-16 has the high surrogate before the low surrogate so we can compare
+  // one code unit at a time for efficiency and still get the right ordering.
   for (intptr_t i = 0; i < len; i++) {
-    int32_t this_code_point = this->CharAt(i);
-    int32_t other_code_point = other.CharAt(i);
-    if (this_code_point < other_code_point) {
+    int32_t this_code_unit = this->CodeUnitAt(i);
+    int32_t other_code_unit = other.CodeUnitAt(i);
+    if (this_code_unit < other_code_unit) {
       return -1;
     }
-    if (this_code_point > other_code_point) {
+    if (this_code_unit > other_code_unit) {
       return 1;
     }
   }
   if (this_len < other_len) return -1;
   if (this_len > other_len) return 1;
   return 0;
 }
 
 
 bool String::StartsWith(const String& other) const {
   if (other.IsNull() || (other.Length() > this->Length())) {
     return false;
   }
   intptr_t slen = other.Length();
   for (int i = 0; i < slen; i++) {
-    if (this->CharAt(i) != other.CharAt(i)) {
+    if (this->CodeUnitAt(i) != other.CodeUnitAt(i)) {
       return false;
     }
   }
   return true;
 }
 
 
 RawInstance* String::Canonicalize() const {
   if (IsCanonical()) {
     return this->raw();
   }
   return Symbols::New(*this);
 }
 
 
 RawString* String::New(const char* str, Heap::Space space) {
   ASSERT(str != NULL);
   intptr_t array_len = strlen(str);
   const uint8_t* utf8_array = reinterpret_cast<const uint8_t*>(str);
   return String::New(utf8_array, array_len, space);
 }
 
 
 RawString* String::New(const uint8_t* utf8_array,
                        intptr_t array_len,
                        Heap::Space space) {
   Utf8::Type type;
-  intptr_t len = Utf8::CodePointCount(utf8_array, array_len, &type);
+  intptr_t len = Utf8::CodeUnitCount(utf8_array, array_len, &type);
   if (type == Utf8::kAscii) {
     const String& strobj = String::Handle(OneByteString::New(len, space));
     if (len > 0) {
       NoGCScope no_gc;
       Utf8::DecodeToAscii(utf8_array, array_len,
                           OneByteString::CharAddr(strobj, 0), len);
     }
     return strobj.raw();
   }
   ASSERT((type == Utf8::kBMP) || (type == Utf8::kSMP));
@@ skipping 257 matching lines @@
     return Symbols::Empty();
   }
   if (begin_index > str.Length()) {
     return String::null();
   }
   String& result = String::Handle();
   bool is_one_byte_string = true;
   intptr_t char_size = str.CharSize();
   if (char_size == kTwoByteChar) {
     for (intptr_t i = begin_index; i < begin_index + length; ++i) {
-      if (str.CharAt(i) > 0x7F) {
+      if (str.CodeUnitAt(i) > 0x7F) {
         is_one_byte_string = false;
         break;
       }
     }
   }
   if (is_one_byte_string) {
     result ^= OneByteString::New(length, space);
   } else {
     result ^= TwoByteString::New(length, space);
   }
@@ skipping 24 matching lines @@
     Utf8::Encode(*this, reinterpret_cast<char*>(utf8_array), array_len);
   }
 }
 
 
 RawString* String::Transform(int32_t (*mapping)(int32_t ch),
                              const String& str,
                              Heap::Space space) {
   ASSERT(!str.IsNull());
   bool has_mapping = false;
-  int32_t dst_max = 0;
+  uint32_t dst_max = 0;
   intptr_t len = str.Length();
+  intptr_t out_len = 0;
   // TODO(cshapiro): assume a transform is required, rollback if not.
-  for (intptr_t i = 0; i < len; ++i) {
-    int32_t src = str.CharAt(i);
-    int32_t dst = mapping(src);
+  intptr_t i = 0;
+  for (; i < len; ++i) {
+    uint32_t src = str.CodeUnitAt(i);
+    if (Utf16::IsSurrogate(src)) break;
+    uint32_t dst = mapping(src);
     if (src != dst) {
       has_mapping = true;
     }
     dst_max = Utils::Maximum(dst_max, dst);
+    out_len += dst > Utf16::kMaxCodeUnit ? 2 : 1;
+  }
+  for (; i < len; ++i) {
+    uint32_t src = Utf16::CodePointAt(str, i);
+    uint32_t dst = mapping(src);
+    if (src != dst) {
+      has_mapping = true;
+    }
+    dst_max = Utils::Maximum(dst_max, dst);
+    out_len += dst > Utf16::kMaxCodeUnit ? 2 : 1;
+    if (src > Utf16::kMaxCodeUnit) ++i;
   }
   if (!has_mapping) {
     return str.raw();
   }
   if (dst_max <= 0x7F) {
-    return OneByteString::Transform(mapping, str, space);
+    return OneByteString::Transform(mapping, str, out_len, space);
   }
   ASSERT(dst_max > 0x7F);
-  return TwoByteString::Transform(mapping, str, space);
+  return TwoByteString::Transform(mapping, str, out_len, space);
 }
 
 
 RawString* String::ToUpperCase(const String& str, Heap::Space space) {
   // TODO(cshapiro): create a fast-path for OneByteString instances.
   return Transform(CaseMapping::ToUpper, str, space);
 }
 
 
 RawString* String::ToLowerCase(const String& str, Heap::Space space) {
@@ skipping 186 matching lines @@
     intptr_t str_len = str.Length();
     String::Copy(result, pos, str, 0, str_len);
     pos += str_len;
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::Transform(int32_t (*mapping)(int32_t ch),
                                            const String& str,
+                                           int out_length,
                                            Heap::Space space) {
   ASSERT(!str.IsNull());
   intptr_t len = str.Length();
-  const String& result = String::Handle(OneByteString::New(len, space));
-  for (intptr_t i = 0; i < len; ++i) {
-    int32_t ch = mapping(str.CharAt(i));
-    ASSERT(ch >= 0 && ch <= 0x7F);
-    *CharAddr(result, i) = ch;
+  const String& result =
+      String::Handle(OneByteString::New(out_length, space));
+  for (intptr_t i = 0, j = 0; i < len; ++i, j++) {
+    uint32_t old_ch = str.CodeUnitAt(i);
+    if (old_ch > Utf16::kMaxCodeUnit) i++;
+    uint32_t ch = mapping(old_ch);
+    ASSERT(ch <= 0x7Fu);
+    *CharAddr(result, j) = ch;
   }
   return OneByteString::raw(result);
 }
 
 
 RawTwoByteString* TwoByteString::EscapeSpecialCharacters(const String& str,
                                                          bool raw_str) {
   intptr_t len = str.Length();
   if (len > 0) {
     intptr_t num_escapes = 0;
@@ skipping 63 matching lines @@
 RawTwoByteString* TwoByteString::New(intptr_t utf16_len,
                                      const uint32_t* utf32_array,
                                      intptr_t array_len,
                                      Heap::Space space) {
   ASSERT((array_len > 0) && (utf16_len >= array_len));
   const String& result = String::Handle(TwoByteString::New(utf16_len, space));
   {
     NoGCScope no_gc;
     intptr_t j = 0;
     for (intptr_t i = 0; i < array_len; ++i) {
-      if (utf32_array[i] > 0xffff) {
+      uint32_t code_point = utf32_array[i];
+      if (code_point > Utf16::kMaxCodeUnit) {
         ASSERT(j < (utf16_len - 1));
-        Utf8::ConvertUTF32ToUTF16(utf32_array[i], CharAddr(result, j));
+        *CharAddr(result, j) = Utf16::LeadFromCodePoint(code_point);
+        *CharAddr(result, j + 1) = Utf16::TrailFromCodePoint(code_point);
         j += 2;
       } else {
         ASSERT(j < utf16_len);
         *CharAddr(result, j) = utf32_array[i];
         j += 1;
       }
     }
   }
   return TwoByteString::raw(result);
 }
@@ skipping 33 matching lines @@
     intptr_t str_len = str.Length();
     String::Copy(result, pos, str, 0, str_len);
     pos += str_len;
   }
   return TwoByteString::raw(result);
 }
 
 
 RawTwoByteString* TwoByteString::Transform(int32_t (*mapping)(int32_t ch),
                                            const String& str,
+                                           int out_length,
                                            Heap::Space space) {
   ASSERT(!str.IsNull());
   intptr_t len = str.Length();
-  const String& result = String::Handle(TwoByteString::New(len, space));
-  for (intptr_t i = 0; i < len; ++i) {
-    int32_t ch = mapping(str.CharAt(i));
-    ASSERT(ch >= 0 && ch <= 0xFFFF);
-    *CharAddr(result, i) = ch;
+  const String& result =
+      String::Handle(TwoByteString::New(out_length, space));
+  for (intptr_t i = 0, j = 0; i < len; ++i, j++) {
+    uint32_t old_ch = Utf16::CodePointAt(str, i);
+    if (old_ch > Utf16::kMaxCodeUnit) i++;
+    uint32_t ch = mapping(old_ch);
+    ASSERT(ch <= Utf16::kMaxCodePoint);
+    if (ch <= Utf16::kMaxCodeUnit) {
+      *CharAddr(result, j) = ch;
+    } else {
+      *CharAddr(result, j) = Utf16::LeadFromCodePoint(ch);
+      *CharAddr(result, j + 1) = Utf16::TrailFromCodePoint(ch);
+      ++j;
+    }
+    ASSERT(j <= out_length);
   }
   return TwoByteString::raw(result);
 }
 
 
 static void AddFinalizer(const Object& referent,
                          void* peer,
                          Dart_WeakPersistentHandleFinalizer callback) {
   ASSERT(callback != NULL);
   ApiState* state = Isolate::Current()->api_state();
@@ skipping 1221 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart