Use VM type cast and save handles.

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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 422 matching lines @@
   cls.set_script(script);
   lib.AddClass(cls);
 }
 
 
 void Object::RegisterPrivateClass(const Class& cls,
                                   const char* public_class_name,
                                   const Script& script,
                                   const Library& lib) {
   String& str = String::Handle();
-  str ^= String::NewSymbol(public_class_name);
-  str ^= lib.PrivateName(str);
+  str = String::NewSymbol(public_class_name);
+  str = lib.PrivateName(str);
   cls.set_name(str);
   cls.set_script(script);
   lib.AddClass(cls);
 }
 
 
 RawError* Object::Init(Isolate* isolate) {
   TIMERSCOPE(time_bootstrap);
   ObjectStore* object_store = isolate->object_store();
 
@@ skipping 2222 matching lines @@
 
 
 bool Type::IsIdentical(const AbstractType& other,
                        bool check_type_parameter_bounds) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsType()) {
     return false;
   }
-  Type& other_type = Type::Handle();
-  other_type ^= other.raw();
   // Both type classes may not be resolved yet.
   String& name = String::Handle(TypeClassName());
-  String& other_name = String::Handle(other_type.TypeClassName());
+  String& other_name = String::Handle(Type::Cast(other).TypeClassName());
   if (!name.Equals(other_name)) {
     return false;
   }
   return AbstractTypeArguments::AreIdentical(
       AbstractTypeArguments::Handle(arguments()),
       AbstractTypeArguments::Handle(other.arguments()),
       false);  // Bounds are only checked at the top level.
 }
 
 
@@ skipping 1704 matching lines @@
       String& str = String::Handle(isolate, String::null());
       const Array& symbols = Array::Handle(isolate,
                                            object_store->keyword_symbols());
       ASSERT(!symbols.IsNull());
       str ^= symbols.At(kind - Token::kFirstKeyword);
       ASSERT(!str.IsNull());
       return str.raw();
     }
     return String::NewSymbol(Token::Str(kind));
   } else {
-    LiteralToken& token = LiteralToken::Handle();
-    token ^= obj.raw();  // Must be a literal token.
-    return token.literal();
+    // Must be a literal token.
+    return LiteralToken::Cast(obj).literal();
   }
 }
 
 
 RawString* TokenStream::GenerateSource() const {
   GrowableObjectArray& literals =
       GrowableObjectArray::Handle(GrowableObjectArray::New(Length()));
   String& literal = String::Handle();
   String& blank = String::Handle(String::New(" "));
   String& newline = String::Handle(String::New("\n"));
@@ skipping 255 matching lines @@
     : DictionaryIterator(library) {
   MoveToNextClass();
 }
 
 
 RawClass* ClassDictionaryIterator::GetNextClass() {
   ASSERT(HasNext());
   int ix = next_ix_++;
   Object& obj = Object::Handle(array_.At(ix));
   MoveToNextClass();
-  Class& cls = Class::Handle();
-  cls ^= obj.raw();
-  return cls.raw();
+  return Class::Cast(obj).raw();
 }
 
 
 void ClassDictionaryIterator::MoveToNextClass() {
   Object& obj = Object::Handle(array_.At(next_ix_));
   while (!obj.IsClass() && HasNext()) {
     next_ix_++;
     obj = array_.At(next_ix_);
   }
 }
 
 
 LibraryPrefixIterator::LibraryPrefixIterator(const Library& library)
     : DictionaryIterator(library) {
   Advance();
 }
 
 
 RawLibraryPrefix* LibraryPrefixIterator::GetNext() {
   ASSERT(HasNext());
   int ix = next_ix_++;
   Object& obj = Object::Handle(array_.At(ix));
   Advance();
-  LibraryPrefix& prefix = LibraryPrefix::Handle();
-  prefix ^= obj.raw();
-  return prefix.raw();
+  return LibraryPrefix::Cast(obj).raw();
 }
 
 
 void LibraryPrefixIterator::Advance() {
   Object& obj = Object::Handle(array_.At(next_ix_));
   while (!obj.IsLibraryPrefix() && HasNext()) {
     next_ix_++;
     obj = array_.At(next_ix_);
   }
 }
@@ skipping 379 matching lines @@
     if (!function.IsNull()) {
       return function.raw();
     }
   }
   return Function::null();
 }
 
 
 RawFunction* Library::LookupLocalFunction(const String& name) const {
   Isolate* isolate = Isolate::Current();
-  Function& function = Function::Handle(isolate, Function::null());
   Object& obj = Object::Handle(isolate, Object::null());
   obj = LookupLocalObject(name);
   if (obj.IsNull() && ShouldBePrivate(name)) {
     String& private_name = String::Handle(isolate, PrivateName(name));
     obj = LookupLocalObject(private_name);
   }
-  if (!obj.IsNull()) {
-    if (obj.IsFunction()) {
-      function ^= obj.raw();
-      return function.raw();
-    }
+  if (obj.IsFunction()) {
+    return Function::Cast(obj).raw();
   }
 
   // No function found.
   return Function::null();
 }
 
 
 RawObject* Library::LookupObjectFiltered(const String& name,
                                          const Library& filter_lib) const {
   // First check if name is found in the local scope of the library.
@@ skipping 146 matching lines @@
     return Class::CheckedHandle(obj.raw()).raw();
   }
   return Class::null();
 }
 
 
 RawClass* Library::LookupClassAllowPrivate(const String& name) const {
   // See if the class is available in this library or in the top level
   // scope of any imported library.
   Isolate* isolate = Isolate::Current();
-  Class& cls = Class::Handle(isolate);
-  cls = LookupClass(name);
+  const Class& cls = Class::Handle(isolate, LookupClass(name));
   if (!cls.IsNull()) {
     return cls.raw();
   }
 
   // Now try to lookup the class using its private name, but only in
   // this library (not in imported libraries).
   if (ShouldBePrivate(name)) {
     String& private_name = String::Handle(isolate, PrivateName(name));
     const Object& obj = Object::Handle(LookupLocalObject(private_name));
-    if (!obj.IsNull()) {
-      if (obj.IsClass()) {
-        cls ^= obj.raw();
-        return cls.raw();
-      }
+    if (obj.IsClass()) {
+      return Class::Cast(obj).raw();
     }
   }
 
   return Class::null();
 }
 
 
 RawLibraryPrefix* Library::LookupLocalLibraryPrefix(const String& name) const {
-  Object& obj = Object::Handle(LookupLocalObject(name));
-  if (!obj.IsNull() && obj.IsLibraryPrefix()) {
-    return LibraryPrefix::CheckedHandle(obj.raw()).raw();
+  const Object& obj = Object::Handle(LookupLocalObject(name));
+  if (obj.IsLibraryPrefix()) {
+    return LibraryPrefix::Cast(obj).raw();
   }
   return LibraryPrefix::null();
 }
 
 
 void Library::AddAnonymousClass(const Class& cls) const {
   intptr_t num_anonymous = this->raw_ptr()->num_anonymous_;
   Array& anon_array = Array::Handle(this->raw_ptr()->anonymous_classes_);
   if (num_anonymous == anon_array.Length()) {
     intptr_t new_len = (num_anonymous == 0) ? 4 : num_anonymous * 2;
@@ skipping 33 matching lines @@
   return lib.raw();
 }
 
 
 RawLibraryPrefix* Library::ImportPrefixAt(intptr_t index) const {
   const Library& imported = Library::Handle(ImportAt(index));
   if (imported.IsNull()) {
     return LibraryPrefix::null();
   }
   DictionaryIterator it(*this);
-  LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
   Object& obj = Object::Handle();
   while (it.HasNext()) {
     obj = it.GetNext();
     if (obj.IsLibraryPrefix()) {
-      lib_prefix ^= obj.raw();
+      const LibraryPrefix& lib_prefix = LibraryPrefix::Cast(obj);
       if (lib_prefix.ContainsLibrary(imported)) {
         return lib_prefix.raw();
       }
     }
   }
   return LibraryPrefix::null();
 }
 
 
 void Library::AddImport(const Library& library) const {
@@ skipping 1988 matching lines @@
 int Integer::CompareWith(const Integer& other) const {
   UNIMPLEMENTED();
   return 0;
 }
 
 
 bool Smi::Equals(const Instance& other) const {
   if (other.IsNull() || !other.IsSmi()) {
     return false;
   }
-
-  Smi& other_smi = Smi::Handle();
-  other_smi ^= other.raw();
-  return (this->Value() == other_smi.Value());
+  return (this->Value() == Smi::Cast(other).Value());
 }
 
 
 double Smi::AsDoubleValue() const {
   return static_cast<double>(this->Value());
 }
 
 
 int64_t Smi::AsInt64Value() const {
   return this->Value();
 }
 
 
 static bool FitsIntoSmi(const Integer& integer) {
   if (integer.IsSmi()) {
     return true;
   }
   if (integer.IsMint()) {
     int64_t mint_value = integer.AsInt64Value();
     return Smi::IsValid64(mint_value);
   }
   if (integer.IsBigint()) {
-    Bigint& big = Bigint::Handle();
-    big ^= integer.raw();
-    return BigintOperations::FitsIntoSmi(big);
+    return BigintOperations::FitsIntoSmi(Bigint::Cast(integer));
   }
   UNREACHABLE();
   return false;
 }
 
 
 int Smi::CompareWith(const Integer& other) const {
   if (other.IsSmi()) {
-    Smi& smi = Smi::Handle();
-    smi ^= other.raw();
-    if (this->Value() < smi.Value()) {
+    const Smi& other_smi = Smi::Cast(other);
+    if (this->Value() < other_smi.Value()) {
       return -1;
-    } else if (this->Value() > smi.Value()) {
+    } else if (this->Value() > other_smi.Value()) {
       return 1;
     } else {
       return 0;
     }
   }
   ASSERT(!FitsIntoSmi(other));
   if (other.IsMint() || other.IsBigint()) {
     if (this->IsNegative() == other.IsNegative()) {
       return this->IsNegative() ? 1 : -1;
     }
@@ skipping 70 matching lines @@
   canonical_value.SetCanonical();
   return canonical_value.raw();
 }
 
 
 bool Mint::Equals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     // Both handles point to the same raw instance.
     return true;
   }
-
   if (!other.IsMint() || other.IsNull()) {
     return false;
   }
-
-  Mint& other_mint = Mint::Handle();
-  other_mint ^= other.raw();
-
-  return value() == other_mint.value();
+  return value() == Mint::Cast(other).value();
 }
 
 
 double Mint::AsDoubleValue() const {
   return static_cast<double>(this->value());
 }
 
 
 int64_t Mint::AsInt64Value() const {
   return this->value();
 }
 
 
 int Mint::CompareWith(const Integer& other) const {
   ASSERT(!FitsIntoSmi(*this));
   if (other.IsMint() || other.IsSmi()) {
     int64_t a = AsInt64Value();
     int64_t b = other.AsInt64Value();
     if (a < b) {
       return -1;
     } else if (a > b) {
       return 1;
     } else {
       return 0;
     }
   }
   if (other.IsBigint()) {
-    Bigint& bigi = Bigint::Handle();
-    bigi ^= other.raw();
-    ASSERT(!BigintOperations::FitsIntoMint(bigi));
+    ASSERT(!BigintOperations::FitsIntoMint(Bigint::Cast(other)));
     if (this->IsNegative() == other.IsNegative()) {
       return this->IsNegative() ? 1 : -1;
     }
     return this->IsNegative() ? -1 : 1;
   }
   UNREACHABLE();
   return 0;
 }
 
 
@@ skipping 22 matching lines @@
 }
 
 
 bool Double::Equals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     return true;  // "===".
   }
   if (other.IsNull() || !other.IsDouble()) {
     return false;
   }
-  Double& other_dbl = Double::Handle();
-  other_dbl ^= other.raw();
-  return EqualsToDouble(other_dbl.value());
+  return EqualsToDouble(Double::Cast(other).value());
 }
 
 
 RawDouble* Double::New(double d, Heap::Space space) {
   Isolate* isolate = Isolate::Current();
   const Class& cls =
       Class::Handle(isolate->object_store()->double_class());
   Double& result = Double::Handle();
   {
     RawObject* raw = Object::Allocate(cls, Double::InstanceSize(), space);
@@ skipping 90 matching lines @@
 bool Bigint::Equals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     // Both handles point to the same raw instance.
     return true;
   }
 
   if (!other.IsBigint() || other.IsNull()) {
     return false;
   }
 
-  Bigint& other_bgi = Bigint::Handle();
-  other_bgi ^= other.raw();
+  const Bigint& other_bgi = Bigint::Cast(other);
 
   intptr_t len = this->Length();
   if (len != other_bgi.Length()) {
     return false;
   }
 
   for (intptr_t i = 0; i < len; i++) {
     if (this->GetChunkAt(i) != other_bgi.GetChunkAt(i)) {
       return false;
     }
@@ skipping 23 matching lines @@
   }
   return BigintOperations::ToMint(*this);
 }
 
 
 // For positive values: Smi < Mint < Bigint.
 int Bigint::CompareWith(const Integer& other) const {
   ASSERT(!FitsIntoSmi(*this));
   ASSERT(!BigintOperations::FitsIntoMint(*this));
   if (other.IsBigint()) {
-    Bigint& big = Bigint::Handle();
-    big ^= other.raw();
-    return BigintOperations::Compare(*this, big);
+    return BigintOperations::Compare(*this, Bigint::Cast(other));
   }
   if (this->IsNegative() == other.IsNegative()) {
     return this->IsNegative() ? -1 : 1;
   }
   return this->IsNegative() ? -1 : 1;
 }
 
 
 RawBigint* Bigint::Allocate(intptr_t length, Heap::Space space) {
   ASSERT(length >= 0);
@@ skipping 111 matching lines @@
 bool String::Equals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     // Both handles point to the same raw instance.
     return true;
   }
 
   if (!other.IsString() || other.IsNull()) {
     return false;
   }
 
-  String& other_string = String::Handle();
-  other_string ^= other.raw();
+  const String& other_string = String::Cast(other);
   if (this->HasHash() && other_string.HasHash() &&
       (this->Hash() != other_string.Hash())) {
     // Both sides have a hash code and it does not match.
     return false;
   }
 
   intptr_t len = this->Length();
   if (len != other_string.Length()) {
     // Lengths don't match.
     return false;
@@ skipping 255 matching lines @@
 }
 
 
 void String::Copy(const String& dst, intptr_t dst_offset,
                   const uint8_t* characters,
                   intptr_t len) {
   ASSERT(dst_offset >= 0);
   ASSERT(len >= 0);
   ASSERT(len <= (dst.Length() - dst_offset));
   if (dst.IsOneByteString()) {
-    OneByteString& onestr = OneByteString::Handle();
-    onestr ^= dst.raw();
+    const OneByteString& onestr = OneByteString::Cast(dst);
     NoGCScope no_gc;
     if (len > 0) {
       memmove(onestr.CharAddr(dst_offset), characters, len);
     }
   } else if (dst.IsTwoByteString()) {
-    TwoByteString& twostr = TwoByteString::Handle();
-    twostr ^= dst.raw();
+    const TwoByteString& twostr = TwoByteString::Cast(dst);
     NoGCScope no_gc;
     for (intptr_t i = 0; i < len; ++i) {
       *twostr.CharAddr(i + dst_offset) = characters[i];
     }
   } else {
     ASSERT(dst.IsFourByteString());
-    FourByteString& fourstr = FourByteString::Handle();
-    fourstr ^= dst.raw();
+    const FourByteString& fourstr = FourByteString::Cast(dst);
     NoGCScope no_gc;
     for (intptr_t i = 0; i < len; ++i) {
       *fourstr.CharAddr(i + dst_offset) = characters[i];
     }
   }
 }
 
 
 void String::Copy(const String& dst, intptr_t dst_offset,
                   const uint16_t* characters,
                   intptr_t len) {
   ASSERT(dst_offset >= 0);
   ASSERT(len >= 0);
   ASSERT(len <= (dst.Length() - dst_offset));
   if (dst.IsOneByteString()) {
-    OneByteString& onestr = OneByteString::Handle();
-    onestr ^= dst.raw();
+    const OneByteString& onestr = OneByteString::Cast(dst);
     NoGCScope no_gc;
     for (intptr_t i = 0; i < len; ++i) {
       ASSERT(characters[i] <= 0xFF);
       *onestr.CharAddr(i + dst_offset) = characters[i];
     }
   } else if (dst.IsTwoByteString()) {
-    TwoByteString& twostr = TwoByteString::Handle();
-    twostr ^= dst.raw();
+    const TwoByteString& twostr = TwoByteString::Cast(dst);
     NoGCScope no_gc;
     if (len > 0) {
       memmove(twostr.CharAddr(dst_offset), characters, len * 2);
     }
   } else {
     ASSERT(dst.IsFourByteString());
-    FourByteString& fourstr = FourByteString::Handle();
-    fourstr ^= dst.raw();
+    const FourByteString& fourstr = FourByteString::Cast(dst);
     NoGCScope no_gc;
     for (intptr_t i = 0; i < len; ++i) {
       *fourstr.CharAddr(i + dst_offset) = characters[i];
     }
   }
 }
 
 
 void String::Copy(const String& dst, intptr_t dst_offset,
                   const uint32_t* characters,
                   intptr_t len) {
   ASSERT(dst_offset >= 0);
   ASSERT(len >= 0);
   ASSERT(len <= (dst.Length() - dst_offset));
   if (dst.IsOneByteString()) {
-    OneByteString& onestr = OneByteString::Handle();
-    onestr ^= dst.raw();
+    const OneByteString& onestr = OneByteString::Cast(dst);
     NoGCScope no_gc;
     for (intptr_t i = 0; i < len; ++i) {
       ASSERT(characters[i] <= 0xFF);
       *onestr.CharAddr(i + dst_offset) = characters[i];
     }
   } else if (dst.IsTwoByteString()) {
-    TwoByteString& twostr = TwoByteString::Handle();
-    twostr ^= dst.raw();
+    const TwoByteString& twostr = TwoByteString::Cast(dst);
     NoGCScope no_gc;
     for (intptr_t i = 0; i < len; ++i) {
       ASSERT(characters[i] <= 0xFFFF);
       *twostr.CharAddr(i + dst_offset) = characters[i];
     }
   } else {
     ASSERT(dst.IsFourByteString());
-    FourByteString& fourstr = FourByteString::Handle();
-    fourstr ^= dst.raw();
+    const FourByteString& fourstr = FourByteString::Cast(dst);
     NoGCScope no_gc;
     if (len > 0) {
       memmove(fourstr.CharAddr(dst_offset), characters, len * 4);
     }
   }
 }
 
 
 void String::Copy(const String& dst, intptr_t dst_offset,
                   const String& src, intptr_t src_offset,
                   intptr_t len) {
   ASSERT(dst_offset >= 0);
   ASSERT(src_offset >= 0);
   ASSERT(len >= 0);
   ASSERT(len <= (dst.Length() - dst_offset));
   ASSERT(len <= (src.Length() - src_offset));
   if (len > 0) {
     intptr_t char_size = src.CharSize();
     if (char_size == kOneByteChar) {
       if (src.IsOneByteString()) {
-        OneByteString& onestr = OneByteString::Handle();
-        onestr ^= src.raw();
+        const OneByteString& onestr = OneByteString::Cast(src);
         NoGCScope no_gc;
         String::Copy(dst, dst_offset, onestr.CharAddr(0) + src_offset, len);
       } else {
         ASSERT(src.IsExternalOneByteString());
-        ExternalOneByteString& onestr = ExternalOneByteString::Handle();
-        onestr ^= src.raw();
+        const ExternalOneByteString& onestr = ExternalOneByteString::Cast(src);
         NoGCScope no_gc;
         String::Copy(dst, dst_offset, onestr.CharAddr(0) + src_offset, len);
       }
     } else if (char_size == kTwoByteChar) {
       if (src.IsTwoByteString()) {
-        TwoByteString& twostr = TwoByteString::Handle();
-        twostr ^= src.raw();
+        const TwoByteString& twostr = TwoByteString::Cast(src);
         NoGCScope no_gc;
         String::Copy(dst, dst_offset, twostr.CharAddr(0) + src_offset, len);
       } else {
         ASSERT(src.IsExternalTwoByteString());
-        ExternalTwoByteString& twostr = ExternalTwoByteString::Handle();
-        twostr ^= src.raw();
+        const ExternalTwoByteString& twostr = ExternalTwoByteString::Cast(src);
         NoGCScope no_gc;
         String::Copy(dst, dst_offset, twostr.CharAddr(0) + src_offset, len);
       }
     } else {
       ASSERT(char_size == kFourByteChar);
       if (src.IsFourByteString()) {
-        FourByteString& fourstr = FourByteString::Handle();
-        fourstr ^= src.raw();
+        const FourByteString& fourstr = FourByteString::Cast(src);
         NoGCScope no_gc;
         String::Copy(dst, dst_offset, fourstr.CharAddr(0) + src_offset, len);
       } else {
         ASSERT(src.IsExternalFourByteString());
-        ExternalFourByteString& fourstr = ExternalFourByteString::Handle();
-        fourstr ^= src.raw();
+        const ExternalFourByteString& fourstr =
+            ExternalFourByteString::Cast(src);
         NoGCScope no_gc;
         String::Copy(dst, dst_offset, fourstr.CharAddr(0) + src_offset, len);
       }
     }
   }
 }
 
 
 static void GrowSymbolTable(const Array& symbol_table, intptr_t table_size) {
   // TODO(iposva): Avoid exponential growth.
@@ skipping 802 matching lines @@
     return false;
   }
 
   // Must have the same type arguments.
   if (!AbstractTypeArguments::AreEqual(
       AbstractTypeArguments::Handle(GetTypeArguments()),
       AbstractTypeArguments::Handle(other.GetTypeArguments()))) {
     return false;
   }
 
-  Array& other_arr = Array::Handle();
-  other_arr ^= other.raw();
+  const Array& other_arr = Array::Cast(other);
 
   intptr_t len = this->Length();
   if (len != other_arr.Length()) {
     return false;
   }
 
   for (intptr_t i = 0; i < len; i++) {
     if (this->At(i) != other_arr.At(i)) {
       return false;
     }
@@ skipping 193 matching lines @@
   // If both handles point to the same raw instance they are equal.
   if (this->raw() == other.raw()) {
     return true;
   }
 
   // Other instance must be non null and a GrowableObjectArray.
   if (!other.IsGrowableObjectArray() || other.IsNull()) {
     return false;
   }
 
-  GrowableObjectArray& other_arr = GrowableObjectArray::Handle();
-  other_arr ^= other.raw();
+  const GrowableObjectArray& other_arr = GrowableObjectArray::Cast(other);
 
   // The capacity and length of both objects must be equal.
   if (Capacity() != other_arr.Capacity() || Length() != other_arr.Length()) {
     return false;
   }
 
   // Both must have the same type arguments.
   if (!AbstractTypeArguments::AreEqual(
       AbstractTypeArguments::Handle(GetTypeArguments()),
       AbstractTypeArguments::Handle(other.GetTypeArguments()))) {
@@ skipping 865 matching lines @@
 }
 
 
 bool JSRegExp::Equals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     return true;  // "===".
   }
   if (other.IsNull() || !other.IsJSRegExp()) {
     return false;
   }
-  JSRegExp& other_js = JSRegExp::Handle();
-  other_js ^= other.raw();
+  const JSRegExp& other_js = JSRegExp::Cast(other);
   // Match the pattern.
   const String& str1 = String::Handle(pattern());
   const String& str2 = String::Handle(other_js.pattern());
   if (!str1.Equals(str2)) {
     return false;
   }
   // Match the flags.
   if ((is_global() != other_js.is_global()) ||
       (is_ignore_case() != other_js.is_ignore_case()) ||
       (is_multi_line() != other_js.is_multi_line())) {
     return false;
   }
   return true;
 }
 
 
 const char* JSRegExp::ToCString() const {
   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