Create frequently used symbols in the vm isolate

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"
 #include "vm/datastream.h"
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/debuginfo.h"
 #include "vm/double_conversion.h"
 #include "vm/exceptions.h"
 #include "vm/growable_array.h"
 #include "vm/heap.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/runtime_entry.h"
 #include "vm/scopes.h"
 #include "vm/stack_frame.h"
+#include "vm/symbols.h"
 #include "vm/timer.h"
 #include "vm/unicode.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, generate_gdb_symbols, false,
     "Generate symbols of generated dart functions for debugging with GDB");
 DEFINE_FLAG(bool, show_internal_names, false,
     "Show names of internal classes (e.g. \"OneByteString\") in error messages "
     "instead of showing the corresponding interface names (e.g. \"String\")");
@@ skipping 207 matching lines @@
   // TODO(iposva): NoGCScope needs to be added here.
   ASSERT(class_class() == null_);
   // Initialize the static vtable values.
   {
     Object fake_object;
     Smi fake_smi;
     Object::handle_vtable_ = fake_object.vtable();
     Smi::handle_vtable_ = fake_smi.vtable();
   }
 
-  Heap* heap = Isolate::Current()->heap();
+  Isolate* isolate = Isolate::Current();
+  Heap* heap = isolate->heap();
   // Allocate and initialize the null instance, except its class_ field.
   // 'null_' must be the first object allocated as it is used in allocation to
   // clear the object.
   {
     uword address = heap->Allocate(Instance::InstanceSize(), Heap::kOld);
     null_ = reinterpret_cast<RawInstance*>(address + kHeapObjectTag);
     // The call below is using 'null_' to initialize itself.
     InitializeObject(address, kNullClassId, Instance::InstanceSize());
   }
 
   // Initialize object_store empty array to null_ in order to be able to check
   // if the empty array was allocated (RAW_NULL is not available).
-  Isolate::Current()->object_store()->set_empty_array(Array::Handle());
+  isolate->object_store()->set_empty_array(Array::Handle());
 
   Class& cls = Class::Handle();
 
   // Allocate and initialize the class class.
   {
     intptr_t size = Class::InstanceSize();
     uword address = heap->Allocate(size, Heap::kOld);
     class_class_ = reinterpret_cast<RawClass*>(address + kHeapObjectTag);
     InitializeObject(address, Class::kInstanceKind, size);
 
     Class fake;
     // Initialization from Class::New<Class>.
     // Directly set raw_ to break a circular dependency: SetRaw will attempt
     // to lookup class class in the class table where it is not registered yet.
     cls.raw_ = class_class_;
     cls.set_handle_vtable(fake.vtable());
     cls.set_instance_size(Class::InstanceSize());
     cls.set_next_field_offset(Class::InstanceSize());
     cls.set_instance_kind(Class::kInstanceKind);
     cls.set_id(Class::kInstanceKind);
     cls.raw_ptr()->is_const_ = false;
     cls.raw_ptr()->is_interface_ = false;
     cls.set_is_finalized();
     cls.raw_ptr()->type_arguments_instance_field_offset_ =
         Class::kNoTypeArguments;
     cls.raw_ptr()->num_native_fields_ = 0;
     cls.InitEmptyFields();
-    Isolate::Current()->class_table()->Register(cls);
+    isolate->class_table()->Register(cls);
   }
 
   // Allocate and initialize the null class.
   cls = Class::New<Instance>(kNullClassId);
   cls.set_is_finalized();
   null_class_ = cls.raw();
 
   // Allocate and initialize the free list element class.
   cls = Class::New<FreeListElement::FakeInstance>(kFreeListElement);
   cls.set_is_finalized();
 
   // Allocate and initialize the sentinel values of Null class.
   {
-    cls = null_class_;
     Instance& sentinel = Instance::Handle();
-    sentinel ^= Object::Allocate(cls, Instance::InstanceSize(), Heap::kOld);
+    sentinel ^=
+        Object::Allocate(kNullClassId, Instance::InstanceSize(), Heap::kOld);
     sentinel_ = sentinel.raw();
 
     Instance& transition_sentinel = Instance::Handle();
     transition_sentinel ^=
-        Object::Allocate(cls, Instance::InstanceSize(), Heap::kOld);
+        Object::Allocate(kNullClassId, Instance::InstanceSize(), Heap::kOld);
     transition_sentinel_ = transition_sentinel.raw();
   }
 
   // The interface "Dynamic" is not a VM internal class. It is the type class of
   // the "unknown type". For efficiency, we allocate it in the VM isolate.
   // Therefore, it cannot have a heap allocated name (the name is hard coded,
   // see GetSingletonClassIndex) and its array fields cannot be set to the empty
   // array, but remain null.
   //
   // TODO(turnidge): Once the empty array is allocated in the vm
@@ skipping 80 matching lines @@
   cls = Class::New<LanguageError>();
   language_error_class_ = cls.raw();
 
   cls = Class::New<UnhandledException>();
   unhandled_exception_class_ = cls.raw();
 
   cls = Class::New<UnwindError>();
   unwind_error_class_ = cls.raw();
 
   ASSERT(class_class() != null_);
+
+  // Pre-allocate the Array and OneByteString class in the vm isolate so that
+  // we can create a symbol table and populate it with some frequently used
+  // strings as symbols.
+  cls = Class::New<Array>();
+  isolate->object_store()->set_array_class(cls);
+  cls = Class::New<OneByteString>();
+  isolate->object_store()->set_one_byte_string_class(cls);
 }
 
 
 RawClass* Object::CreateAndRegisterInterface(const char* cname,
                                              const Script& script,
                                              const Library& lib) {
-  const String& name = String::Handle(String::NewSymbol(cname));
+  const String& name = String::Handle(Symbols::New(cname));
   const Class& cls = Class::Handle(
       Class::NewInterface(name, script, Scanner::kDummyTokenIndex));
   lib.AddClass(cls);
   return cls.raw();
 }
 
 
 void Object::RegisterClass(const Class& cls,
                            const char* cname,
                            const Script& script,
                            const Library& lib) {
-  const String& name = String::Handle(String::NewSymbol(cname));
+  const String& name = String::Handle(Symbols::New(cname));
   cls.set_name(name);
   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 = Symbols::New(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 21 matching lines @@
   // has been created.
   cls.InitEmptyFields();
 
   // Set up the growable object array class (Has to be done after the array
   // class is setup as one of its field is an array object).
   cls = Class::New<GrowableObjectArray>();
   object_store->set_growable_object_array_class(cls);
   cls.set_type_arguments_instance_field_offset(
       GrowableObjectArray::type_arguments_offset());
 
-  // Setup the symbol table used within the String class.
-  const int kInitialSymbolTableSize = 16;
-  array = Array::New(kInitialSymbolTableSize + 1);
-  // Last element contains the count of used slots.
-  array.SetAt(kInitialSymbolTableSize, Smi::Handle(Smi::New(0)));
-  object_store->set_symbol_table(array);
-
   // canonical_type_arguments_ are NULL terminated.
   array = Array::New(4);
   object_store->set_canonical_type_arguments(array);
 
   // Pre-allocate the OneByteString class needed by the symbol table.
   cls = Class::New<OneByteString>();
   object_store->set_one_byte_string_class(cls);
 
+  // Setup the symbol table for the symbols created in the isolate.
+  Symbols::SetupSymbolTable(isolate);
+
   // Set up the libraries array before initializing the core library.
   const GrowableObjectArray& libraries =
       GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld));
   object_store->set_libraries(libraries);
 
   // Basic infrastructure has been setup, initialize the class dictionary.
   Library::InitCoreLibrary(isolate);
   Library& core_lib = Library::Handle(Library::CoreLibrary());
   ASSERT(!core_lib.IsNull());
   Library& core_impl_lib = Library::Handle(Library::CoreImplLibrary());
@@ skipping 97 matching lines @@
   pending_classes.Add(cls, Heap::kOld);
 
   // Initialize the base interfaces used by the core VM classes.
   const Script& script = Script::Handle(Bootstrap::LoadScript());
 
   // Allocate and initialize the Object class and type.  The Object
   // class and ByteArray subclasses are the only pre-allocated,
   // non-interface classes in the core library.
   cls = Class::New<Instance>();
   object_store->set_object_class(cls);
-  cls.set_name(String::Handle(String::NewSymbol("Object")));
+  cls.set_name(String::Handle(Symbols::New("Object")));
   cls.set_script(script);
   cls.set_is_prefinalized();
   core_lib.AddClass(cls);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_object_type(type);
 
   cls = Class::New<Int8Array>();
   object_store->set_int8_array_class(cls);
   RegisterPrivateClass(cls, "_Int8Array", script, core_lib);
@@ skipping 348 matching lines @@
     cur += kWordSize;
   }
   uword tags = 0;
   ASSERT(index != kIllegalObjectKind);
   tags = RawObject::ClassIdTag::update(index, tags);
   tags = RawObject::SizeTag::update(size, tags);
   reinterpret_cast<RawObject*>(address)->tags_ = tags;
 }
 
 
-RawObject* Object::Allocate(const Class& cls,
+RawObject* Object::Allocate(intptr_t cls_id,
                             intptr_t size,
                             Heap::Space space) {
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
 
   uword address = heap->Allocate(size, space);
   if (address == 0) {
     // Use the preallocated out of memory exception to avoid calling
     // into dart code or allocating any code.
     const Instance& exception =
         Instance::Handle(isolate->object_store()->out_of_memory());
     Exceptions::Throw(exception);
     UNREACHABLE();
   }
   NoGCScope no_gc;
-  InitializeObject(address, cls.id(), size);
+  InitializeObject(address, cls_id, size);
   RawObject* raw_obj = reinterpret_cast<RawObject*>(address + kHeapObjectTag);
-  ASSERT(cls.id() == RawObject::ClassIdTag::decode(raw_obj->ptr()->tags_));
+  ASSERT(cls_id == RawObject::ClassIdTag::decode(raw_obj->ptr()->tags_));
   return raw_obj;
 }
 
 
 class StoreBufferObjectPointerVisitor : public ObjectPointerVisitor {
  public:
   explicit StoreBufferObjectPointerVisitor(Isolate* isolate) :
       ObjectPointerVisitor(isolate) {
   }
   void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** curr = first; curr <= last; ++curr) {
       if ((*curr)->IsNewObject()) {
         uword ptr = reinterpret_cast<uword>(curr);
         isolate()->store_buffer()->AddPointer(ptr);
       }
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StoreBufferObjectPointerVisitor);
 };
 
 
 RawObject* Object::Clone(const Object& src, Heap::Space space) {
   const Class& cls = Class::Handle(src.clazz());
   intptr_t size = src.raw()->Size();
-  RawObject* raw_obj = Object::Allocate(cls, size, space);
+  RawObject* raw_obj = Object::Allocate(cls.id(), size, space);
   NoGCScope no_gc;
   memmove(raw_obj->ptr(), src.raw()->ptr(), size);
   if (space == Heap::kOld) {
     StoreBufferObjectPointerVisitor visitor(Isolate::Current());
     raw_obj->VisitPointers(&visitor);
   }
   return raw_obj;
 }
 
 
 RawString* Class::Name() const {
   if (raw_ptr()->name_ != String::null()) {
     return raw_ptr()->name_;
   }
   ASSERT(class_class() != Class::null());  // class_class_ should be set up.
   intptr_t index = GetSingletonClassIndex(raw());
-  return String::NewSymbol(GetSingletonClassName(index));
+  return Symbols::New(GetSingletonClassName(index));
 }
 
 
 RawString* Class::UserVisibleName() const {
   if (FLAG_show_internal_names) {
     return Name();
   }
   switch (id()) {
     case kInteger:
     case kSmi:
     case kMint:
     case kBigint:
-      return String::NewSymbol("int");
+      return Symbols::New("int");
     case kDouble:
-      return String::NewSymbol("double");
+      return Symbols::New("double");
     case kOneByteString:
     case kTwoByteString:
     case kFourByteString:
     case kExternalOneByteString:
     case kExternalTwoByteString:
     case kExternalFourByteString:
-      return String::NewSymbol("String");
+      return Symbols::New("String");
     case kBool:
-      return String::NewSymbol("bool");
+      return Symbols::New("bool");
     case kArray:
     case kImmutableArray:
     case kGrowableObjectArray:
-      return String::NewSymbol("List");
+      return Symbols::New("List");
     case kInt8Array:
     case kExternalInt8Array:
-      return String::NewSymbol("Int8List");
+      return Symbols::New("Int8List");
     case kUint8Array:
     case kExternalUint8Array:
-      return String::NewSymbol("Uint8List");
+      return Symbols::New("Uint8List");
     case kInt16Array:
     case kExternalInt16Array:
-      return String::NewSymbol("Int16List");
+      return Symbols::New("Int16List");
     case kUint16Array:
     case kExternalUint16Array:
-      return String::NewSymbol("Uint16List");
+      return Symbols::New("Uint16List");
     case kInt32Array:
     case kExternalInt32Array:
-      return String::NewSymbol("Int32List");
+      return Symbols::New("Int32List");
     case kUint32Array:
     case kExternalUint32Array:
-      return String::NewSymbol("Uint32List");
+      return Symbols::New("Uint32List");
     case kInt64Array:
     case kExternalInt64Array:
-      return String::NewSymbol("Int64List");
+      return Symbols::New("Int64List");
     case kUint64Array:
     case kExternalUint64Array:
-      return String::NewSymbol("Uint64List");
+      return Symbols::New("Uint64List");
     case kFloat32Array:
     case kExternalFloat32Array:
-      return String::NewSymbol("Float32List");
+      return Symbols::New("Float32List");
     case kFloat64Array:
     case kExternalFloat64Array:
-      return String::NewSymbol("Float64List");
+      return Symbols::New("Float64List");
     default:
       return Name();
   }
   UNREACHABLE();
 }
 
 
 RawType* Class::SignatureType() const {
   ASSERT(IsSignatureClass());
   const Function& function = Function::Handle(signature_function());
@@ skipping 29 matching lines @@
       Type::New(*this, signature_type_arguments, token_pos()));
 
   // Return the still unfinalized signature type.
   ASSERT(!signature_type.IsFinalized());
   return signature_type.raw();
 }
 
 
 template <class FakeObject>
 RawClass* Class::New() {
-  Class& class_class = Class::Handle(Object::class_class());
+  ASSERT(Object::class_class() != Class::null());
   Class& result = Class::Handle();
   {
-    RawObject* raw = Object::Allocate(class_class,
+    RawObject* raw = Object::Allocate(Class::kInstanceKind,
                                       Class::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   FakeObject fake;
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeObject::InstanceSize());
   result.set_next_field_offset(FakeObject::InstanceSize());
   result.set_instance_kind(FakeObject::kInstanceKind);
@@ skipping 311 matching lines @@
     ASSERT(!(field.is_static() && field.is_final()) ||
            (field.value() == Object::sentinel()));
   }
   // The value of static fields is already initialized to null.
   StorePointer(&raw_ptr()->fields_, value.raw());
 }
 
 
 template <class FakeInstance>
 RawClass* Class::New(intptr_t index) {
-  Class& class_class = Class::Handle(Object::class_class());
+  ASSERT(Object::class_class() != Class::null());
   Class& result = Class::Handle();
   {
-    RawObject* raw = Object::Allocate(class_class,
+    RawObject* raw = Object::Allocate(Class::kInstanceKind,
                                       Class::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   FakeInstance fake;
   ASSERT(fake.IsInstance());
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeInstance::InstanceSize());
   result.set_next_field_offset(FakeInstance::InstanceSize());
@@ skipping 703 matching lines @@
                                          intptr_t token_pos) {
   const UnresolvedClass& type = UnresolvedClass::Handle(UnresolvedClass::New());
   type.set_library_prefix(library_prefix);
   type.set_ident(ident);
   type.set_token_pos(token_pos);
   return type.raw();
 }
 
 
 RawUnresolvedClass* UnresolvedClass::New() {
-  const Class& unresolved_class_class =
-      Class::Handle(Object::unresolved_class_class());
-  RawObject* raw = Object::Allocate(unresolved_class_class,
+  ASSERT(Object::unresolved_class_class() != Class::null());
+  RawObject* raw = Object::Allocate(UnresolvedClass::kInstanceKind,
                                     UnresolvedClass::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawUnresolvedClass*>(raw);
 }
 
 
 void UnresolvedClass::set_token_pos(intptr_t token_pos) const {
   ASSERT(token_pos >= 0);
   raw_ptr()->token_pos_ = token_pos;
 }
@@ skipping 14 matching lines @@
   StorePointer(&raw_ptr()->factory_signature_class_, value.raw());
 }
 
 
 RawString* UnresolvedClass::Name() const {
   if (library_prefix() != LibraryPrefix::null()) {
     const LibraryPrefix& lib_prefix = LibraryPrefix::Handle(library_prefix());
     String& name = String::Handle();
     String& str = String::Handle();
     name = lib_prefix.name();  // Qualifier.
-    str = String::New(".");
+    str = Symbols::Dot();
     name = String::Concat(name, str);
     str = ident();
     name = String::Concat(name, str);
     return name.raw();
   } else {
     return ident();
   }
 }
 
 
@@ skipping 180 matching lines @@
   } else {
     const String& args_name = String::Handle(
         args.SubvectorName(first_type_param_index,
                            num_type_params,
                            name_visibility));
     type_name = String::Concat(class_name, args_name);
   }
   // The name is only used for type checking and debugging purposes.
   // Unless profiling data shows otherwise, it is not worth caching the name in
   // the type.
-  return String::NewSymbol(type_name);
+  return Symbols::New(type_name);
 }
 
 
 RawString* AbstractType::ClassName() const {
   if (HasResolvedTypeClass()) {
     return Class::Handle(type_class()).Name();
   } else {
     return UnresolvedClass::Handle(unresolved_class()).Name();
   }
 }
@@ skipping 391 matching lines @@
   StorePointer(&raw_ptr()->type_class_, value.raw());
 }
 
 
 void Type::set_arguments(const AbstractTypeArguments& value) const {
   StorePointer(&raw_ptr()->arguments_, value.raw());
 }
 
 
 RawType* Type::New(Heap::Space space) {
-  const Class& type_class = Class::Handle(Object::type_class());
-  RawObject* raw = Object::Allocate(type_class,
+  ASSERT(Object::type_class() != Class::null());
+  RawObject* raw = Object::Allocate(Type::kInstanceKind,
                                     Type::InstanceSize(),
                                     space);
   return reinterpret_cast<RawType*>(raw);
 }
 
 
 RawType* Type::New(const Object& clazz,
                    const AbstractTypeArguments& arguments,
                    intptr_t token_pos,
                    Heap::Space space) {
@@ skipping 139 matching lines @@
     const AbstractTypeArguments& instantiator_type_arguments) const {
   ASSERT(IsFinalized());
   if (instantiator_type_arguments.IsNull()) {
     return Type::DynamicType();
   }
   return instantiator_type_arguments.TypeAt(index());
 }
 
 
 RawTypeParameter* TypeParameter::New() {
-  const Class& type_parameter_class =
-      Class::Handle(Object::type_parameter_class());
-  RawObject* raw = Object::Allocate(type_parameter_class,
+  ASSERT(Object::type_parameter_class() != Class::null());
+  RawObject* raw = Object::Allocate(TypeParameter::kInstanceKind,
                                     TypeParameter::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawTypeParameter*>(raw);
 }
 
 
 RawTypeParameter* TypeParameter::New(const Class& parameterized_class,
                                      intptr_t index,
                                      const String& name,
                                      const AbstractType& bound,
@@ skipping 78 matching lines @@
 
 RawString* AbstractTypeArguments::SubvectorName(
     intptr_t from_index,
     intptr_t len,
     NameVisibility name_visibility) const {
   ASSERT(from_index + len <= Length());
   String& name = String::Handle();
   const intptr_t num_strings = 2*len + 1;  // "<""T"", ""T"">".
   const Array& strings = Array::Handle(Array::New(num_strings));
   intptr_t s = 0;
-  strings.SetAt(s++, String::Handle(String::NewSymbol("<")));
-  const String& kCommaSpace = String::Handle(String::NewSymbol(", "));
+  strings.SetAt(s++, String::Handle(Symbols::New("<")));
+  const String& kCommaSpace = String::Handle(Symbols::New(", "));
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(from_index + i);
     name = type.BuildName(name_visibility);
     strings.SetAt(s++, name);
     if (i < len - 1) {
       strings.SetAt(s++, kCommaSpace);
     }
   }
-  strings.SetAt(s++, String::Handle(String::NewSymbol(">")));
+  strings.SetAt(s++, String::Handle(Symbols::New(">")));
   ASSERT(s == num_strings);
   name = String::ConcatAll(strings);
-  return String::NewSymbol(name);
+  return Symbols::New(name);
 }
 
 
 bool AbstractTypeArguments::Equals(const AbstractTypeArguments& other) const {
   ASSERT(!IsNull());  // Use AbstractTypeArguments::AreEqual().
   if (this->raw() == other.raw()) {
     return true;
   }
   if (other.IsNull()) {
     return false;
@@ skipping 290 matching lines @@
 }
 
 
 RawTypeArguments* TypeArguments::New(intptr_t len, Heap::Space space) {
   if ((len < 0) || (len > kMaxTypes)) {
     // TODO(iposva): Should we throw an illegal parameter exception?
     UNIMPLEMENTED();
     return null();
   }
 
-  const Class& type_arguments_class =
-      Class::Handle(Object::type_arguments_class());
   TypeArguments& result = TypeArguments::Handle();
   {
-    RawObject* raw = Object::Allocate(type_arguments_class,
+    RawObject* raw = Object::Allocate(TypeArguments::kInstanceKind,
                                       TypeArguments::InstanceSize(len),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     // Length must be set before we start storing into the array.
     result.SetLength(len);
   }
   return result.raw();
 }
 
@@ skipping 99 matching lines @@
 }
 
 
 void InstantiatedTypeArguments::set_instantiator_type_arguments(
     const AbstractTypeArguments& value) const {
   StorePointer(&raw_ptr()->instantiator_type_arguments_, value.raw());
 }
 
 
 RawInstantiatedTypeArguments* InstantiatedTypeArguments::New() {
-  const Class& instantiated_type_arguments_class =
-      Class::Handle(Object::instantiated_type_arguments_class());
-  RawObject* raw = Object::Allocate(instantiated_type_arguments_class,
+  ASSERT(Object::instantiated_type_arguments_class() != Class::null());
+  RawObject* raw = Object::Allocate(InstantiatedTypeArguments::kInstanceKind,
                                     InstantiatedTypeArguments::InstanceSize(),
                                     Heap::kNew);
   return reinterpret_cast<RawInstantiatedTypeArguments*>(raw);
 }
 
 
 RawInstantiatedTypeArguments* InstantiatedTypeArguments::New(
     const AbstractTypeArguments& uninstantiated_type_arguments,
     const AbstractTypeArguments& instantiator_type_arguments) {
   const InstantiatedTypeArguments& result =
@@ skipping 481 matching lines @@
 bool Function::IsImplicitClosureFunction() const {
   if (!IsClosureFunction()) {
     return false;
   }
   const Function& parent = Function::Handle(parent_function());
   return parent.raw_ptr()->implicit_closure_function_ == raw();
 }
 
 
 RawFunction* Function::New() {
-  const Class& function_class = Class::Handle(Object::function_class());
-  RawObject* raw = Object::Allocate(function_class,
+  ASSERT(Object::function_class() != Class::null());
+  RawObject* raw = Object::Allocate(Function::kInstanceKind,
                                     Function::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawFunction*>(raw);
 }
 
 
 RawFunction* Function::New(const String& name,
                            RawFunction::Kind kind,
                            bool is_static,
                            bool is_const,
@@ skipping 110 matching lines @@
   return closure_function.raw();
 }
 
 
 RawString* Function::BuildSignature(
     bool instantiate,
     NameVisibility name_visibility,
     const AbstractTypeArguments& instantiator) const {
   const GrowableObjectArray& pieces =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
-  const String& kCommaSpace = String::Handle(String::NewSymbol(", "));
-  const String& kColonSpace = String::Handle(String::NewSymbol(": "));
-  const String& kLParen = String::Handle(String::NewSymbol("("));
-  const String& kRParen = String::Handle(String::NewSymbol(") => "));
-  const String& kLBracket = String::Handle(String::NewSymbol("["));
-  const String& kRBracket = String::Handle(String::NewSymbol("]"));
+  const String& kCommaSpace = String::Handle(Symbols::New(", "));
+  const String& kColonSpace = String::Handle(Symbols::New(": "));
+  const String& kLParen = String::Handle(Symbols::New("("));
+  const String& kRParen = String::Handle(Symbols::New(") => "));
+  const String& kLBracket = String::Handle(Symbols::New("["));
+  const String& kRBracket = String::Handle(Symbols::New("]"));
   String& name = String::Handle();
   if (!instantiate && !is_static()) {
     // Prefix the signature with its type parameters, if any (e.g. "<K, V>").
     // The signature of static functions cannot be type parameterized.
     const String& kSpaceExtendsSpace =
-        String::Handle(String::NewSymbol(" extends "));
-    const String& kLAngleBracket = String::Handle(String::NewSymbol("<"));
-    const String& kRAngleBracket = String::Handle(String::NewSymbol(">"));
+        String::Handle(Symbols::New(" extends "));
+    const String& kLAngleBracket = String::Handle(Symbols::New("<"));
+    const String& kRAngleBracket = String::Handle(Symbols::New(">"));
     const Class& function_class = Class::Handle(owner());
     ASSERT(!function_class.IsNull());
     const TypeArguments& type_parameters = TypeArguments::Handle(
         function_class.type_parameters());
     if (!type_parameters.IsNull()) {
       intptr_t num_type_parameters = type_parameters.Length();
       pieces.Add(kLAngleBracket);
       TypeParameter& type_parameter = TypeParameter::Handle();
       AbstractType& bound = AbstractType::Handle();
       for (intptr_t i = 0; i < num_type_parameters; i++) {
@@ skipping 51 matching lines @@
     pieces.Add(kRBracket);
   }
   pieces.Add(kRParen);
   AbstractType& res_type = AbstractType::Handle(result_type());
   if (instantiate && !res_type.IsInstantiated()) {
     res_type = res_type.InstantiateFrom(instantiator);
   }
   name = res_type.BuildName(name_visibility);
   pieces.Add(name);
   const Array& strings = Array::Handle(Array::MakeArray(pieces));
-  return String::NewSymbol(String::Handle(String::ConcatAll(strings)));
+  return Symbols::New(String::Handle(String::ConcatAll(strings)));
 }
 
 
 bool Function::HasInstantiatedSignature() const {
   AbstractType& type = AbstractType::Handle(result_type());
   if (!type.IsInstantiated()) {
     return false;
   }
   const intptr_t num_parameters = NumberOfParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
@@ skipping 57 matching lines @@
   String& str = String::Handle();
   str = String::New(kGetterPrefix);
   str = String::Concat(str, field_name);
   return str.raw();
 }
 
 
 RawString* Field::GetterSymbol(const String& field_name) {
   String& str = String::Handle();
   str = Field::GetterName(field_name);
-  return String::NewSymbol(str);
+  return Symbols::New(str);
 }
 
 
 RawString* Field::SetterName(const String& field_name) {
   String& str = String::Handle();
   str = String::New(kSetterPrefix);
   str = String::Concat(str, field_name);
   return str.raw();
 }
 
 
 RawString* Field::SetterSymbol(const String& field_name) {
   String& str = String::Handle();
   str = Field::SetterName(field_name);
-  return String::NewSymbol(str);
+  return Symbols::New(str);
 }
 
 
 RawString* Field::NameFromGetter(const String& getter_name) {
   String& str = String::Handle();
   str = String::SubString(getter_name, strlen(kGetterPrefix));
   return str.raw();
 }
 
 
@@ skipping 32 matching lines @@
 }
 
 
 void Field::set_type(const AbstractType& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->type_, value.raw());
 }
 
 
 RawField* Field::New() {
-  const Class& field_class = Class::Handle(Object::field_class());
-  RawObject* raw = Object::Allocate(field_class,
+  ASSERT(Object::field_class() != Class::null());
+  RawObject* raw = Object::Allocate(Field::kInstanceKind,
                                     Field::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawField*>(raw);
 }
 
 
 RawField* Field::New(const String& name,
                      bool is_static,
                      bool is_final,
                      intptr_t token_pos) {
@@ skipping 33 matching lines @@
   StorePointer(&raw_ptr()->literal_, literal.raw());
 }
 
 
 void LiteralToken::set_value(const Object& value) const {
   StorePointer(&raw_ptr()->value_, value.raw());
 }
 
 
 RawLiteralToken* LiteralToken::New() {
-  const Class& cls = Class::Handle(Object::literal_token_class());
-  RawObject* raw = Object::Allocate(cls,
+  ASSERT(Object::literal_token_class() != Class::null());
+  RawObject* raw = Object::Allocate(LiteralToken::kInstanceKind,
                                     LiteralToken::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawLiteralToken*>(raw);
 }
 
 
 RawLiteralToken* LiteralToken::New(Token::Kind kind, const String& literal) {
   const LiteralToken& result = LiteralToken::Handle(LiteralToken::New());
   result.set_kind(kind);
   result.set_literal(literal);
@@ skipping 98 matching lines @@
   while (index < src_pos && kind != Token::kEOS) {
     iterator.Advance();
     kind = iterator.CurrentTokenKind();
     index += 1;
   }
   return iterator.CurrentPosition();
 }
 
 
 RawTokenStream* TokenStream::New(intptr_t len) {
-  const Class& token_stream_class = Class::Handle(Object::token_stream_class());
+  ASSERT(Object::token_stream_class() != Class::null());
   TokenStream& result = TokenStream::Handle();
   {
-    RawObject* raw = Object::Allocate(token_stream_class,
+    RawObject* raw = Object::Allocate(TokenStream::kInstanceKind,
                                       TokenStream::InstanceSize(len),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
   }
   return result.raw();
 }
 
 
@@ skipping 278 matching lines @@
       Isolate* isolate = Isolate::Current();
       ObjectStore* object_store = isolate->object_store();
       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));
+    return Symbols::New(Token::Str(kind));
   } else {
     ASSERT(obj.IsLiteralToken());  // Must be a literal token.
     const LiteralToken& literal_token = LiteralToken::Cast(obj);
     return literal_token.literal();
   }
 }
 
 
 intptr_t TokenStream::Iterator::ReadToken() {
   uint8_t b = ReadByte();
@@ skipping 117 matching lines @@
       current_line++;
     } else if (src.CharAt(ix) == '\r') {
       if ((ix + 1 != src.Length()) && (src.CharAt(ix + 1) != '\n')) {
         current_line++;
       }
     } else {
       last_char = ix;
     }
   }
   // Guarantee that returned string is never NULL.
-  String& line = String::Handle(String::NewSymbol(""));
+  String& line = String::Handle(Symbols::New(""));
   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,
@@ skipping 36 matching lines @@
   String& snippet = String::Handle();
   if ((snippet_start != -1) && (snippet_end != -1)) {
     snippet =
         String::SubString(src, snippet_start, snippet_end - snippet_start);
   }
   return snippet.raw();
 }
 
 
 RawScript* Script::New() {
-  const Class& script_class = Class::Handle(Object::script_class());
-  RawObject* raw = Object::Allocate(script_class,
+  ASSERT(Object::script_class() != Class::null());
+  RawObject* raw = Object::Allocate(Script::kInstanceKind,
                                     Script::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawScript*>(raw);
 }
 
 
 RawScript* Script::New(const String& url,
                        const String& source,
                        RawScript::Kind kind) {
   const Script& result = Script::Handle(Script::New());
-  result.set_url(String::Handle(String::NewSymbol(url)));
+  result.set_url(String::Handle(Symbols::New(url)));
   result.set_source(source);
   result.set_kind(kind);
   return result.raw();
 }
 
 
 const char* Script::ToCString() const {
   return "Script";
 }
 
@@ skipping 775 matching lines @@
 
 void Library::InitImportedIntoList() const {
   const Array& imported_into =
       Array::Handle(Array::New(kInitialImportedIntoCapacity, Heap::kOld));
   StorePointer(&raw_ptr()->imported_into_, imported_into.raw());
   raw_ptr()->num_imported_into_ = 0;
 }
 
 
 RawLibrary* Library::New() {
-  const Class& library_class = Class::Handle(Object::library_class());
-  RawObject* raw = Object::Allocate(library_class,
+  ASSERT(Object::library_class() != Class::null());
+  RawObject* raw = Object::Allocate(Library::kInstanceKind,
                                     Library::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawLibrary*>(raw);
 }
 
 
 RawLibrary* Library::NewLibraryHelper(const String& url,
                                       bool import_core_lib) {
   const Library& result = Library::Handle(Library::New());
   result.StorePointer(&result.raw_ptr()->name_, url.raw());
@@ skipping 20 matching lines @@
   return result.raw();
 }
 
 
 RawLibrary* Library::New(const String& url) {
   return NewLibraryHelper(url, true);
 }
 
 
 void Library::InitCoreLibrary(Isolate* isolate) {
-  const String& core_lib_url = String::Handle(String::NewSymbol("dart:core"));
+  const String& core_lib_url = String::Handle(Symbols::New("dart:core"));
   const Library& core_lib =
       Library::Handle(Library::NewLibraryHelper(core_lib_url, false));
   core_lib.Register();
   isolate->object_store()->set_core_library(core_lib);
   const String& core_impl_lib_url =
-      String::Handle(String::NewSymbol("dart:coreimpl"));
+      String::Handle(Symbols::New("dart:coreimpl"));
   const Library& core_impl_lib =
       Library::Handle(Library::NewLibraryHelper(core_impl_lib_url, false));
   isolate->object_store()->set_core_impl_library(core_impl_lib);
   core_impl_lib.Register();
   core_lib.AddImport(core_impl_lib);
   core_impl_lib.AddImport(core_lib);
   isolate->object_store()->set_root_library(Library::Handle());
 }
 
 
 void Library::InitMathLibrary(Isolate* isolate) {
-  const String& url = String::Handle(String::NewSymbol("dart:math"));
+  const String& url = String::Handle(Symbols::New("dart:math"));
   const Library& lib = Library::Handle(Library::New(url));
   lib.Register();
   const Library& core_impl_lib = Library::Handle(Library::CoreImplLibrary());
   lib.AddImport(core_impl_lib);
   isolate->object_store()->set_math_library(lib);
 }
 
 
 void Library::InitIsolateLibrary(Isolate* isolate) {
-  const String& url = String::Handle(String::NewSymbol("dart:isolate"));
+  const String& url = String::Handle(Symbols::New("dart:isolate"));
   const Library& lib = Library::Handle(Library::New(url));
   lib.Register();
   isolate->object_store()->set_isolate_library(lib);
 }
 
 
 void Library::InitMirrorsLibrary(Isolate* isolate) {
-  const String& url = String::Handle(String::NewSymbol("dart:mirrors"));
+  const String& url = String::Handle(Symbols::New("dart:mirrors"));
   const Library& lib = Library::Handle(Library::New(url));
   lib.Register();
   const Library& isolate_lib = Library::Handle(Library::IsolateLibrary());
   lib.AddImport(isolate_lib);
   const Library& wrappers_lib =
       Library::Handle(Library::NativeWrappersLibrary());
   lib.AddImport(wrappers_lib);
   isolate->object_store()->set_mirrors_library(lib);
 }
 
 
 void Library::InitNativeWrappersLibrary(Isolate* isolate) {
   static const int kNumNativeWrappersClasses = 4;
   ASSERT(kNumNativeWrappersClasses > 0 && kNumNativeWrappersClasses < 10);
   const String& native_flds_lib_url = String::Handle(
-      String::NewSymbol("dart:nativewrappers"));
+      Symbols::New("dart:nativewrappers"));
   Library& native_flds_lib = Library::Handle(
       Library::NewLibraryHelper(native_flds_lib_url, false));
   native_flds_lib.Register();
   isolate->object_store()->set_native_wrappers_library(native_flds_lib);
   static const char* const kNativeWrappersClass = "NativeFieldWrapperClass";
   static const int kNameLength = 25;
   ASSERT(kNameLength == (strlen(kNativeWrappersClass) + 1 + 1));
   char name_buffer[kNameLength];
   String& cls_name = String::Handle();
   for (int fld_cnt = 1; fld_cnt <= kNumNativeWrappersClasses; fld_cnt++) {
     OS::SNPrint(name_buffer,
                 kNameLength,
                 "%s%d",
                 kNativeWrappersClass,
                 fld_cnt);
-    cls_name = String::NewSymbol(name_buffer);
+    cls_name = Symbols::New(name_buffer);
     Class::NewNativeWrapper(&native_flds_lib, cls_name, fld_cnt);
   }
 }
 
 
 RawLibrary* Library::LookupLibrary(const String &url) {
   Isolate* isolate = Isolate::Current();
   Library& lib = Library::Handle(isolate, Library::null());
   String& lib_url = String::Handle(isolate, String::null());
   GrowableObjectArray& libs = GrowableObjectArray::Handle(
@@ skipping 46 matching lines @@
   return false;
 }
 
 
 RawString* Library::PrivateName(const String& name) const {
   ASSERT(ShouldBePrivate(name));
   // ASSERT(strchr(name, '@') == NULL);
   String& str = String::Handle();
   str ^= name.raw();
   str = String::Concat(str, String::Handle(this->private_key()));
-  str = String::NewSymbol(str);
+  str = Symbols::New(str);
   return str.raw();
 }
 
 
 RawLibrary* Library::GetLibrary(intptr_t index) {
   Isolate* isolate = Isolate::Current();
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate->object_store()->libraries());
   ASSERT(!libs.IsNull());
   if ((0 <= index) && (index < libs.Length())) {
@@ skipping 117 matching lines @@
     resolved_class = lib.LookupLocalClass(class_name);
     if (!resolved_class.IsNull()) {
       return resolved_class.raw();
     }
   }
   return Class::null();
 }
 
 
 RawLibraryPrefix* LibraryPrefix::New() {
-  const Class& library_prefix_class =
-      Class::Handle(Object::library_prefix_class());
-  RawObject* raw = Object::Allocate(library_prefix_class,
+  ASSERT(Object::library_prefix_class() != Class::null());
+  RawObject* raw = Object::Allocate(LibraryPrefix::kInstanceKind,
                                     LibraryPrefix::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawLibraryPrefix*>(raw);
 }
 
 
 RawLibraryPrefix* LibraryPrefix::New(const String& name, const Library& lib) {
   const LibraryPrefix& result = LibraryPrefix::Handle(LibraryPrefix::New());
   result.set_name(name);
   result.set_num_libs(0);
@@ skipping 104 matching lines @@
       if (!error.IsNull()) {
         return error.raw();
       }
     }
   }
   return error.raw();
 }
 
 
 RawInstructions* Instructions::New(intptr_t size) {
-  const Class& instructions_class = Class::Handle(Object::instructions_class());
+  ASSERT(Object::instructions_class() != Class::null());
   Instructions& result = Instructions::Handle();
   {
     uword aligned_size = Instructions::InstanceSize(size);
-    RawObject* raw = Object::Allocate(instructions_class,
+    RawObject* raw = Object::Allocate(Instructions::kInstanceKind,
                                       aligned_size,
                                       Heap::kCode);
     NoGCScope no_gc;
     // TODO(iposva): Remove premarking once old and code spaces are merged.
     raw->SetMarkBit();
     result ^= raw;
     result.set_size(size);
   }
   return result.raw();
 }
@@ skipping 60 matching lines @@
   return *(EntryAddr(index, kTryIndexEntry));
 }
 
 
 void PcDescriptors::SetTryIndex(intptr_t index, intptr_t value) const {
   *(EntryAddr(index, kTryIndexEntry)) = value;
 }
 
 
 RawPcDescriptors* PcDescriptors::New(intptr_t num_descriptors) {
-  const Class& cls = Class::Handle(Object::pc_descriptors_class());
+  ASSERT(Object::pc_descriptors_class() != Class::null());
   PcDescriptors& result = PcDescriptors::Handle();
   {
     uword size = PcDescriptors::InstanceSize(num_descriptors);
-    RawObject* raw = Object::Allocate(cls, size, Heap::kOld);
+    RawObject* raw = Object::Allocate(PcDescriptors::kInstanceKind,
+                                      size,
+                                      Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(num_descriptors);
   }
   return result.raw();
 }
 
 
 const char* PcDescriptors::KindAsStr(intptr_t index) const {
   switch (DescriptorKind(index)) {
@@ skipping 96 matching lines @@
   uint8_t* byte_addr = &(raw_ptr()->data_[byte_offset]);
   if (value) {
     *byte_addr |= byte_mask;
   } else {
     *byte_addr &= ~byte_mask;
   }
 }
 
 
 RawStackmap* Stackmap::New(uword pc_offset, BitmapBuilder* bmap) {
-  const Class& cls = Class::Handle(Object::stackmap_class());
-  ASSERT(!cls.IsNull());
+  ASSERT(Object::stackmap_class() != Class::null());
   ASSERT(bmap != NULL);
   Stackmap& result = Stackmap::Handle();
   intptr_t size = bmap->SizeInBytes();
   {
     // Stackmap data objects are associated with a code object, allocate them
     // in old generation.
-    RawObject* raw =
-        Object::Allocate(cls, Stackmap::InstanceSize(size), Heap::kOld);
+    RawObject* raw = Object::Allocate(Stackmap::kInstanceKind,
+                                      Stackmap::InstanceSize(size),
+                                      Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.set_bitmap_size_in_bytes(size);
   }
   result.SetPC(pc_offset);
   intptr_t bound = bmap->SizeInBits();
   for (intptr_t i = 0; i < bound; i++) {
     result.SetBit(i, bmap->Get(i));
   }
   result.SetMinBitOffset(bmap->Minimum());
@@ skipping 59 matching lines @@
 }
 
 
 const char* LocalVarDescriptors::ToCString() const {
   UNIMPLEMENTED();
   return "LocalVarDescriptors";
 }
 
 
 RawLocalVarDescriptors* LocalVarDescriptors::New(intptr_t num_variables) {
-  const Class& cls = Class::Handle(Object::var_descriptors_class());
+  ASSERT(Object::var_descriptors_class() != Class::null());
   LocalVarDescriptors& result = LocalVarDescriptors::Handle();
   {
     uword size = LocalVarDescriptors::InstanceSize(num_variables);
-    RawObject* raw = Object::Allocate(cls, size, Heap::kOld);
+    RawObject* raw = Object::Allocate(LocalVarDescriptors::kInstanceKind,
+                                      size,
+                                      Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.raw_ptr()->length_ = num_variables;
   }
   const Array& names = Array::Handle(Array::New(num_variables, Heap::kOld));
   result.raw_ptr()->names_ = names.raw();
   return result.raw();
 }
 
 
@@ skipping 29 matching lines @@
 }
 
 
 void ExceptionHandlers::SetHandlerPC(intptr_t index,
                                      intptr_t value) const {
   *(EntryAddr(index, kHandlerPcEntry)) = value;
 }
 
 
 RawExceptionHandlers* ExceptionHandlers::New(intptr_t num_handlers) {
-  const Class& cls = Class::Handle(Object::exception_handlers_class());
+  ASSERT(Object::exception_handlers_class() != Class::null());
   ExceptionHandlers& result = ExceptionHandlers::Handle();
   {
     uword size = ExceptionHandlers::InstanceSize(num_handlers);
-    RawObject* raw = Object::Allocate(cls, size, Heap::kOld);
+    RawObject* raw = Object::Allocate(ExceptionHandlers::kInstanceKind,
+                                      size,
+                                      Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(num_handlers);
   }
   return result.raw();
 }
 
 
 const char* ExceptionHandlers::ToCString() const {
   if (Length() == 0) {
@@ skipping 78 matching lines @@
   return *comments;
 }
 
 
 void Code::set_comments(const Code::Comments& comments) const {
   StorePointer(&raw_ptr()->comments_, comments.comments_.raw());
 }
 
 
 RawCode* Code::New(int pointer_offsets_length) {
-  const Class& cls = Class::Handle(Object::code_class());
+  ASSERT(Object::code_class() != Class::null());
   Code& result = Code::Handle();
   {
     uword size = Code::InstanceSize(pointer_offsets_length);
-    RawObject* raw = Object::Allocate(cls, size, Heap::kOld);
+    RawObject* raw = Object::Allocate(Code::kInstanceKind, size, Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.set_pointer_offsets_length(pointer_offsets_length);
     result.set_is_optimized(false);
     result.set_comments(Comments::New(0));
   }
   return result.raw();
 }
 
 
@@ skipping 203 matching lines @@
       break;
     }
     previous_map = map->raw();
   }
   return map->raw();
 }
 
 
 RawContext* Context::New(intptr_t num_variables, Heap::Space space) {
   ASSERT(num_variables >= 0);
+  ASSERT(Object::context_class() != Class::null());
 
-  const Class& context_class = Class::Handle(Object::context_class());
   Context& result = Context::Handle();
   {
-    RawObject* raw = Object::Allocate(context_class,
+    RawObject* raw = Object::Allocate(Context::kInstanceKind,
                                       Context::InstanceSize(num_variables),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.set_num_variables(num_variables);
   }
   result.set_isolate(Isolate::Current());
   return result.raw();
 }
 
 
 const char* Context::ToCString() const {
   return "Context";
 }
 
 
 RawContextScope* ContextScope::New(intptr_t num_variables) {
-  const Class& context_scope_class =
-    Class::Handle(Object::context_scope_class());
+  ASSERT(Object::context_scope_class() != Class::null());
   intptr_t size = ContextScope::InstanceSize(num_variables);
   ContextScope& result = ContextScope::Handle();
   {
-    RawObject* raw = Object::Allocate(context_scope_class, size, Heap::kOld);
+    RawObject* raw = Object::Allocate(ContextScope::kInstanceKind,
+                                      size,
+                                      Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.set_num_variables(num_variables);
   }
   return result.raw();
 }
 
 
 intptr_t ContextScope::TokenIndexAt(intptr_t scope_index) const {
   return Smi::Value(VariableDescAddr(scope_index)->token_pos);
@@ skipping 250 matching lines @@
     }
   }
   return result.raw();
 }
 
 
 RawICData* ICData::New(const Function& function,
                        const String& target_name,
                        intptr_t id,
                        intptr_t num_args_tested) {
+  ASSERT(Object::icdata_class() != Class::null());
   ASSERT(num_args_tested > 0);
-  const Class& cls = Class::Handle(Object::icdata_class());
-  ASSERT(!cls.IsNull());
   ICData& result = ICData::Handle();
   {
     // IC data objects are long living objects, allocate them in old generation.
-    RawObject* raw = Object::Allocate(cls, ICData::InstanceSize(), Heap::kOld);
+    RawObject* raw = Object::Allocate(ICData::kInstanceKind,
+                                      ICData::InstanceSize(),
+                                      Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_function(function);
   result.set_target_name(target_name);
   result.set_id(id);
   result.set_num_args_tested(num_args_tested);
   // Number of array elements in one test entry (num_args_tested + 1)
   intptr_t len = result.TestEntryLength();
   // IC data array must be null terminated (sentinel entry).
   const Array& ic_data = Array::Handle(Array::New(len, Heap::kOld));
   result.set_ic_data(ic_data);
   return result.raw();
 }
 
 
 RawSubtypeTestCache* SubtypeTestCache::New() {
-  const Class& cls = Class::Handle(Object::subtypetestcache_class());
-  ASSERT(!cls.IsNull());
+  ASSERT(Object::subtypetestcache_class() != Class::null());
   SubtypeTestCache& result = SubtypeTestCache::Handle();
   {
     // SubtypeTestCache objects are long living objects, allocate them in the
     // old generation.
-    RawObject* raw =
-        Object::Allocate(cls, SubtypeTestCache::InstanceSize(), Heap::kOld);
+    RawObject* raw = Object::Allocate(SubtypeTestCache::kInstanceKind,
+                                      SubtypeTestCache::InstanceSize(),
+                                      Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   const Array& cache = Array::Handle(Array::New(kTestEntryLength));
   result.set_cache(cache);
   return result.raw();
 }
 
 
 void SubtypeTestCache::set_cache(const Array& value) const {
@@ skipping 57 matching lines @@
 
 
 const char* Error::ToCString() const {
   // Error is an abstract class.  We should never reach here.
   UNREACHABLE();
   return "Error";
 }
 
 
 RawApiError* ApiError::New(const String& message, Heap::Space space) {
-  const Class& cls = Class::Handle(Object::api_error_class());
+  ASSERT(Object::api_error_class() != Class::null());
   ApiError& result = ApiError::Handle();
   {
-    RawObject* raw = Object::Allocate(cls,
+    RawObject* raw = Object::Allocate(ApiError::kInstanceKind,
                                       ApiError::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_message(message);
   return result.raw();
 }
 
 
 void ApiError::set_message(const String& message) const {
   StorePointer(&raw_ptr()->message_, message.raw());
 }
 
 
 const char* ApiError::ToErrorCString() const {
   const String& msg_str = String::Handle(message());
   return msg_str.ToCString();
 }
 
 
 const char* ApiError::ToCString() const {
   return "ApiError";
 }
 
 
 RawLanguageError* LanguageError::New(const String& message, Heap::Space space) {
-  const Class& cls = Class::Handle(Object::language_error_class());
+  ASSERT(Object::language_error_class() != Class::null());
   LanguageError& result = LanguageError::Handle();
   {
-    RawObject* raw = Object::Allocate(cls,
+    RawObject* raw = Object::Allocate(LanguageError::kInstanceKind,
                                       LanguageError::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_message(message);
   return result.raw();
 }
 
 
 void LanguageError::set_message(const String& message) const {
   StorePointer(&raw_ptr()->message_, message.raw());
 }
 
 
 const char* LanguageError::ToErrorCString() const {
   const String& msg_str = String::Handle(message());
   return msg_str.ToCString();
 }
 
 
 const char* LanguageError::ToCString() const {
   return "LanguageError";
 }
 
 
 RawUnhandledException* UnhandledException::New(const Instance& exception,
                                                const Instance& stacktrace,
                                                Heap::Space space) {
-  const Class& cls = Class::Handle(Object::unhandled_exception_class());
+  ASSERT(Object::unhandled_exception_class() != Class::null());
   UnhandledException& result = UnhandledException::Handle();
   {
-    RawObject* raw = Object::Allocate(cls,
+    RawObject* raw = Object::Allocate(UnhandledException::kInstanceKind,
                                       UnhandledException::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_exception(exception);
   result.set_stacktrace(stacktrace);
   return result.raw();
 }
 
@@ skipping 37 matching lines @@
   return chars;
 }
 
 
 const char* UnhandledException::ToCString() const {
   return "UnhandledException";
 }
 
 
 RawUnwindError* UnwindError::New(const String& message, Heap::Space space) {
-  const Class& cls = Class::Handle(Object::unwind_error_class());
+  ASSERT(Object::unwind_error_class() != Class::null());
   UnwindError& result = UnwindError::Handle();
   {
-    RawObject* raw = Object::Allocate(cls,
+    RawObject* raw = Object::Allocate(UnwindError::kInstanceKind,
                                       UnwindError::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_message(message);
   return result.raw();
 }
 
 
@@ skipping 203 matching lines @@
   const Class& cls = Class::Handle(clazz());
   return (index >= 0 && index < cls.num_native_fields());
 }
 
 
 RawInstance* Instance::New(const Class& cls, Heap::Space space) {
   Instance& result = Instance::Handle();
   {
     intptr_t instance_size = cls.instance_size();
     ASSERT(instance_size > 0);
-    RawObject* raw = Object::Allocate(cls, instance_size, space);
+    RawObject* raw = Object::Allocate(cls.id(), instance_size, space);
     NoGCScope no_gc;
     result ^= raw;
     uword addr = reinterpret_cast<uword>(result.raw_ptr());
     // Initialize fields.
     intptr_t offset = sizeof(RawObject);
     // Initialize all native fields to NULL.
     for (intptr_t i = 0; i < cls.num_native_fields(); i++) {
       *reinterpret_cast<uword*>(addr + offset) = 0;
       offset += kWordSize;
     }
@@ skipping 169 matching lines @@
 
 
 void Mint::set_value(int64_t value) const {
   raw_ptr()->value_ = value;
 }
 
 
 RawMint* Mint::New(int64_t val, Heap::Space space) {
   // Do not allocate a Mint if Smi would do.
   ASSERT(!Smi::IsValid64(val));
-  Isolate* isolate = Isolate::Current();
-  const Class& cls =
-      Class::Handle(isolate->object_store()->mint_class());
+  ASSERT(Isolate::Current()->object_store()->mint_class() != Class::null());
   Mint& result = Mint::Handle();
   {
-    RawObject* raw = Object::Allocate(cls, Mint::InstanceSize(), space);
+    RawObject* raw = Object::Allocate(Mint::kInstanceKind,
+                                      Mint::InstanceSize(),
+                                      space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_value(val);
   return result.raw();
 }
 
 
 RawMint* Mint::NewCanonical(int64_t value) {
   // Do not allocate a Mint if Smi would do.
@@ skipping 102 matching lines @@
     return true;  // "===".
   }
   if (other.IsNull() || !other.IsDouble()) {
     return false;
   }
   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());
+  ASSERT(Isolate::Current()->object_store()->double_class() != Class::null());
   Double& result = Double::Handle();
   {
-    RawObject* raw = Object::Allocate(cls, Double::InstanceSize(), space);
+    RawObject* raw = Object::Allocate(Double::kInstanceKind,
+                                      Double::InstanceSize(),
+                                      space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_value(d);
   return result.raw();
 }
 
 
 static bool IsWhiteSpace(char ch) {
   return ch == '\0' || ch == '\n' || ch == '\r' || ch == ' ' || ch == '\t';
@@ skipping 135 matching lines @@
   }
   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);
-  Isolate* isolate = Isolate::Current();
-  const Class& cls = Class::Handle(isolate->object_store()->bigint_class());
+  ASSERT(Isolate::Current()->object_store()->bigint_class() != Class::null());
   Bigint& result = Bigint::Handle();
   {
-    RawObject* raw = Object::Allocate(cls, Bigint::InstanceSize(length), space);
+    RawObject* raw = Object::Allocate(Bigint::kInstanceKind,
+                                      Bigint::InstanceSize(length),
+                                      space);
     NoGCScope no_gc;
     result ^= raw;
     result.raw_ptr()->allocated_length_ = length;  // Chunk length allocated.
     result.raw_ptr()->signed_length_ = length;  // Chunk length in use.
   }
   return result.raw();
 }
 
 
 static uword ZoneAllocator(intptr_t size) {
@@ skipping 205 matching lines @@
     }
   }
   return true;
 }
 
 
 RawInstance* String::Canonicalize() const {
   if (IsCanonical()) {
     return this->raw();
   }
-  return NewSymbol(*this);
+  return Symbols::New(*this);
 }
 
 
 RawString* String::New(const char* str, Heap::Space space) {
   intptr_t width = 0;
   intptr_t len = Utf8::CodePointCount(str, &width);
   if (width == 1) {
     const OneByteString& onestr
         = OneByteString::Handle(OneByteString::New(len, space));
     if (len > 0) {
@@ skipping 260 matching lines @@
   if (str.IsTwoByteString()) {
     const TwoByteString& twostr = TwoByteString::Cast(str);
     return twostr.EscapeDoubleQuotes();
   }
   ASSERT(str.IsFourByteString());
   const FourByteString& fourstr = FourByteString::Cast(str);
   return fourstr.EscapeDoubleQuotes();
 }
 
 
-static void GrowSymbolTable(const Array& symbol_table, intptr_t table_size) {
-  // TODO(iposva): Avoid exponential growth.
-  intptr_t new_table_size = table_size * 2;
-  Array& new_symbol_table = Array::Handle(Array::New(new_table_size + 1));
-  // Copy all elements from the original symbol table to the newly allocated
-  // array.
-  String& element = String::Handle();
-  Object& new_element = Object::Handle();
-  for (intptr_t i = 0; i < table_size; i++) {
-    element ^= symbol_table.At(i);
-    if (!element.IsNull()) {
-      intptr_t hash = element.Hash();
-      intptr_t index = hash % new_table_size;
-      new_element = new_symbol_table.At(index);
-      while (!new_element.IsNull()) {
-        index = (index + 1) % new_table_size;  // Move to next element.
-        new_element = new_symbol_table.At(index);
-      }
-      new_symbol_table.SetAt(index, element);
-    }
-  }
-  // Copy used count.
-  new_element = symbol_table.At(table_size);
-  new_symbol_table.SetAt(new_table_size, new_element);
-  // Remember the new symbol table now.
-  Isolate::Current()->object_store()->set_symbol_table(new_symbol_table);
-}
-
-
-static void InsertIntoSymbolTable(const Array& symbol_table,
-                                  const String& symbol,
-                                  intptr_t index,
-                                  intptr_t table_size) {
-  symbol.SetCanonical();  // Mark object as being canonical.
-  symbol_table.SetAt(index, symbol);  // Remember the new symbol.
-  Smi& used = Smi::Handle();
-  used ^= symbol_table.At(table_size);
-  intptr_t used_elements = used.Value() + 1;  // One more element added.
-  used = Smi::New(used_elements);
-  symbol_table.SetAt(table_size, used);  // Update used count.
-
-  // Rehash if symbol_table is 75% full.
-  if (used_elements > ((table_size / 4) * 3)) {
-    GrowSymbolTable(symbol_table, table_size);
-  }
-}
-
-
-RawString* String::NewSymbol(const char* str) {
-  intptr_t width = 0;
-  intptr_t len = Utf8::CodePointCount(str, &width);
-  intptr_t size = len * width;
-  Zone* zone = Isolate::Current()->current_zone();
-  if (len == 0) {
-    return String::NewSymbol(reinterpret_cast<uint8_t*>(NULL), 0);
-  } else if (width == 1) {
-    uint8_t* characters = reinterpret_cast<uint8_t*>(zone->Allocate(size));
-    Utf8::Decode(str, characters, len);
-    return NewSymbol(characters, len);
-  } else if (width == 2) {
-    uint16_t* characters = reinterpret_cast<uint16_t*>(zone->Allocate(size));
-    Utf8::Decode(str, characters, len);
-    return NewSymbol(characters, len);
-  }
-  ASSERT(width == 4);
-  uint32_t* characters = reinterpret_cast<uint32_t*>(zone->Allocate(size));
-  Utf8::Decode(str, characters, len);
-  return NewSymbol(characters, len);
-}
-
-
-template<typename T>
-RawString* String::NewSymbol(const T* characters, intptr_t len) {
-  Isolate* isolate = Isolate::Current();
-
-  // Calculate the String hash for this sequence of characters.
-  intptr_t hash = Hash(characters, len);
-
-  const Array& symbol_table =
-      Array::Handle(isolate, isolate->object_store()->symbol_table());
-  // Last element of the array is the number of used elements.
-  intptr_t table_size = symbol_table.Length() - 1;
-  intptr_t index = hash % table_size;
-
-  String& symbol = String::Handle(isolate, String::null());
-  symbol ^= symbol_table.At(index);
-  while (!symbol.IsNull() && !symbol.Equals(characters, len)) {
-    index = (index + 1) % table_size;  // Move to next element.
-    symbol ^= symbol_table.At(index);
-  }
-  // Since we leave enough room in the table to guarantee, that we find an
-  // empty spot, index is the insertion point if symbol is null.
-  if (symbol.IsNull()) {
-    // Allocate new result string.
-    symbol = String::New(characters, len, Heap::kOld);
-    symbol.SetHash(hash);  // Remember the calculated hash value.
-    InsertIntoSymbolTable(symbol_table, symbol, index, table_size);
-  }
-  ASSERT(symbol.IsSymbol());
-  return symbol.raw();
-}
-
-template RawString* String::NewSymbol(const uint8_t* characters, intptr_t len);
-template RawString* String::NewSymbol(const uint16_t* characters, intptr_t len);
-template RawString* String::NewSymbol(const uint32_t* characters, intptr_t len);
-
-
-RawString* String::NewSymbol(const String& str) {
-  if (str.IsSymbol()) {
-    return str.raw();
-  }
-  return NewSymbol(str, 0, str.Length());
-}
-
-
-RawString* String::NewSymbol(const String& str,
-                             intptr_t begin_index,
-                             intptr_t len) {
-  ASSERT(begin_index >= 0);
-  ASSERT(len >= 0);
-  ASSERT((begin_index + len) <= str.Length());
-  Isolate* isolate = Isolate::Current();
-
-  // Calculate the String hash for this sequence of characters.
-  intptr_t hash = String::Hash(str, begin_index, len);
-
-  const Array& symbol_table =
-      Array::Handle(isolate, isolate->object_store()->symbol_table());
-  // Last element of the array is the number of used elements.
-  intptr_t table_size = symbol_table.Length() - 1;
-  intptr_t index = hash % table_size;
-
-  String& symbol = String::Handle(isolate, String::null());
-  symbol ^= symbol_table.At(index);
-  while (!symbol.IsNull() && !symbol.Equals(str, begin_index, len)) {
-    index = (index + 1) % table_size;  // Move to next element.
-    symbol ^= symbol_table.At(index);
-  }
-  // Since we leave enough room in the table to guarantee, that we find an
-  // empty spot, index is the insertion point if symbol is null.
-  if (symbol.IsNull()) {
-    if (str.IsOld() && begin_index == 0 && len == str.Length()) {
-      // Reuse the incoming str as the symbol value.
-      symbol = str.raw();
-    } else {
-      // Allocate a copy in old space.
-      symbol = String::SubString(str, begin_index, len, Heap::kOld);
-    }
-    symbol.SetHash(hash);
-    InsertIntoSymbolTable(symbol_table, symbol, index, table_size);
-  }
-  ASSERT(symbol.IsSymbol());
-  return symbol.raw();
-}
-
-
 RawString* String::NewFormatted(const char* format, ...) {
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
   Zone* zone = Isolate::Current()->current_zone();
   char* buffer = reinterpret_cast<char*>(zone->Allocate(len + 1));
   va_list args2;
   va_start(args2, format);
@@ skipping 225 matching lines @@
   }
 
   // We have reached the end of mangled_name string.
   ASSERT(pos == len);
   return (name_pos == name_len);
 }
 
 
 RawOneByteString* OneByteString::New(intptr_t len,
                                      Heap::Space space) {
-  Isolate* isolate = Isolate::Current();
-
-  const Class& cls =
-      Class::Handle(isolate->object_store()->one_byte_string_class());
+  ASSERT(Isolate::Current() == Dart::vm_isolate() ||
+         Isolate::Current()->object_store()->one_byte_string_class() !=
+         Class::null());
   OneByteString& result = OneByteString::Handle();
   {
-    RawObject* raw = Object::Allocate(cls,
+    RawObject* raw = Object::Allocate(OneByteString::kInstanceKind,
                                       OneByteString::InstanceSize(len),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
   }
   return result.raw();
 }
 
@@ skipping 114 matching lines @@
       }
     }
     return dststr.raw();
   }
   return TwoByteString::null();
 }
 
 
 RawTwoByteString* TwoByteString::New(intptr_t len,
                                      Heap::Space space) {
-  Isolate* isolate = Isolate::Current();
-
-  const Class& cls =
-      Class::Handle(isolate->object_store()->two_byte_string_class());
+  ASSERT(Isolate::Current()->object_store()->two_byte_string_class());
   TwoByteString& result = TwoByteString::Handle();
   {
-    RawObject* raw = Object::Allocate(cls,
+    RawObject* raw = Object::Allocate(TwoByteString::kInstanceKind,
                                       TwoByteString::InstanceSize(len),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
   }
   return result.raw();
 }
 
@@ skipping 104 matching lines @@
       }
     }
     return dststr.raw();
   }
   return FourByteString::null();
 }
 
 
 RawFourByteString* FourByteString::New(intptr_t len,
                                        Heap::Space space) {
-  Isolate* isolate = Isolate::Current();
-
-  const Class& cls =
-      Class::Handle(isolate->object_store()->four_byte_string_class());
+  ASSERT(Isolate::Current()->object_store()->four_byte_string_class() !=
+         Class::null());
   FourByteString& result = FourByteString::Handle();
   {
-    RawObject* raw = Object::Allocate(cls,
+    RawObject* raw = Object::Allocate(FourByteString::kInstanceKind,
                                       FourByteString::InstanceSize(len),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
   }
   return result.raw();
 }
 
@@ skipping 82 matching lines @@
   weak_ref->set_callback(callback);
 }
 
 
 RawExternalOneByteString* ExternalOneByteString::New(
     const uint8_t* data,
     intptr_t len,
     void* peer,
     Dart_PeerFinalizer callback,
     Heap::Space space) {
-  Isolate* isolate = Isolate::Current();
-
-  const Class& cls =
-      Class::Handle(isolate->object_store()->external_one_byte_string_class());
+  ASSERT(Isolate::Current()->object_store()->external_one_byte_string_class() !=
+         Class::null());
   ExternalOneByteString& result = ExternalOneByteString::Handle();
   ExternalStringData<uint8_t>* external_data =
       new ExternalStringData<uint8_t>(data, peer, callback);
   {
-    RawObject* raw = Object::Allocate(cls,
+    RawObject* raw = Object::Allocate(ExternalOneByteString::kInstanceKind,
                                       ExternalOneByteString::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
     result.SetExternalData(external_data);
   }
   AddFinalizer(result, external_data, ExternalOneByteString::Finalize);
   return result.raw();
@@ skipping 20 matching lines @@
   return String::ToCString();
 }
 
 
 RawExternalTwoByteString* ExternalTwoByteString::New(
     const uint16_t* data,
     intptr_t len,
     void* peer,
     Dart_PeerFinalizer callback,
     Heap::Space space) {
-  Isolate* isolate = Isolate::Current();
-
-  const Class& cls =
-      Class::Handle(isolate->object_store()->external_two_byte_string_class());
+  ASSERT(Isolate::Current()->object_store()->external_two_byte_string_class() !=
+         Class::null());
   ExternalTwoByteString& result = ExternalTwoByteString::Handle();
   ExternalStringData<uint16_t>* external_data =
       new ExternalStringData<uint16_t>(data, peer, callback);
   {
-    RawObject* raw = Object::Allocate(cls,
+    RawObject* raw = Object::Allocate(ExternalTwoByteString::kInstanceKind,
                                       ExternalTwoByteString::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
     result.SetExternalData(external_data);
   }
   AddFinalizer(result, external_data, ExternalTwoByteString::Finalize);
   return result.raw();
@@ skipping 10 matching lines @@
   return String::ToCString();
 }
 
 
 RawExternalFourByteString* ExternalFourByteString::New(
     const uint32_t* data,
     intptr_t len,
     void* peer,
     Dart_PeerFinalizer callback,
     Heap::Space space) {
-  Isolate* isolate = Isolate::Current();
-
-  const Class& cls =
-      Class::Handle(isolate->object_store()->external_four_byte_string_class());
+  ASSERT(Isolate::Current()->object_store()->
+         external_four_byte_string_class() != Class::null());
   ExternalFourByteString& result = ExternalFourByteString::Handle();
   ExternalStringData<uint32_t>* external_data =
       new ExternalStringData<uint32_t>(data, peer, callback);
   {
-    RawObject* raw = Object::Allocate(cls,
+    RawObject* raw = Object::Allocate(ExternalFourByteString::kInstanceKind,
                                       ExternalFourByteString::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
     result.SetExternalData(external_data);
   }
   AddFinalizer(result, external_data, ExternalFourByteString::Finalize);
   return result.raw();
@@ skipping 15 matching lines @@
   return Isolate::Current()->object_store()->true_value();
 }
 
 
 RawBool* Bool::False() {
   return Isolate::Current()->object_store()->false_value();
 }
 
 
 RawBool* Bool::New(bool value) {
-  Isolate* isolate = Isolate::Current();
-
-  const Class& cls = Class::Handle(isolate->object_store()->bool_class());
+  ASSERT(Isolate::Current()->object_store()->bool_class() != Class::null());
   Bool& result = Bool::Handle();
   {
     // Since the two boolean instances are singletons we allocate them straight
     // in the old generation.
-    RawObject* raw = Object::Allocate(cls, Bool::InstanceSize(), Heap::kOld);
+    RawObject* raw = Object::Allocate(Bool::kInstanceKind,
+                                      Bool::InstanceSize(),
+                                      Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_value(value);
   return result.raw();
 }
 
 
 const char* Bool::ToCString() const {
   return value() ? "true" : "false";
@@ skipping 28 matching lines @@
     if (this->At(i) != other_arr.At(i)) {
       return false;
     }
   }
   return true;
 }
 
 
 RawArray* Array::New(intptr_t len, Heap::Space space) {
   ObjectStore* object_store = Isolate::Current()->object_store();
+  ASSERT(object_store->array_class() != Class::null());
   Class& cls = Class::Handle(object_store->array_class());
   return New(cls, len, space);
 }
 
 
 RawArray* Array::New(const Class& cls, intptr_t len, Heap::Space space) {
   if ((len < 0) || (len > kMaxArrayElements)) {
     // TODO(srdjan): Verify that illegal argument is the right thing to throw.
     GrowableArray<const Object*> args;
     args.Add(&Smi::Handle(Smi::New(len)));
     Exceptions::ThrowByType(Exceptions::kIllegalArgument, args);
   }
   Array& result = Array::Handle();
   {
-    RawObject* raw = Object::Allocate(cls,
+    RawObject* raw = Object::Allocate(cls.id(),
                                       Array::InstanceSize(len),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
   }
   return result.raw();
 }
 
 
@@ skipping 92 matching lines @@
       raw->ptr()->tags_ = tags;
     }
   }
   return array.raw();
 }
 
 
 RawImmutableArray* ImmutableArray::New(intptr_t len,
                                        Heap::Space space) {
   ObjectStore* object_store = Isolate::Current()->object_store();
+  ASSERT(object_store->immutable_array_class() != Class::null());
   Class& cls = Class::Handle(object_store->immutable_array_class());
   return reinterpret_cast<RawImmutableArray*>(Array::New(cls, len, space));
 }
 
 
 const char* ImmutableArray::ToCString() const {
   return "ImmutableArray";
 }
 
 
@@ skipping 84 matching lines @@
 
 RawGrowableObjectArray* GrowableObjectArray::New(intptr_t capacity,
                                                  Heap::Space space) {
   const Array& data = Array::Handle(Array::New(capacity, space));
   return New(data, space);
 }
 
 
 RawGrowableObjectArray* GrowableObjectArray::New(const Array& array,
                                                  Heap::Space space) {
-  ObjectStore* object_store = Isolate::Current()->object_store();
-  Class& cls = Class::Handle(object_store->growable_object_array_class());
+  ASSERT(Isolate::Current()->object_store()->growable_object_array_class()
+         != Class::null());
   GrowableObjectArray& result = GrowableObjectArray::Handle();
   {
-    RawObject* raw = Object::Allocate(cls,
+    RawObject* raw = Object::Allocate(GrowableObjectArray::kInstanceKind,
                                       GrowableObjectArray::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(0);
     result.SetData(array);
   }
   return result.raw();
 }
 
@@ skipping 58 matching lines @@
 RawT* ByteArray::NewExternalImpl(const Class& cls,
                                  ElementT* data,
                                  intptr_t len,
                                  void* peer,
                                  Dart_PeerFinalizer callback,
                                  Heap::Space space) {
   HandleT& result = HandleT::Handle();
   ExternalByteArrayData<ElementT>* external_data =
       new ExternalByteArrayData<ElementT>(data, peer, callback);
   {
-    RawObject* raw = Object::Allocate(cls, HandleT::InstanceSize(), space);
+    RawObject* raw = Object::Allocate(cls.id(), HandleT::InstanceSize(), space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     result.SetExternalData(external_data);
   }
   AddFinalizer(result, external_data, ExternalByteArrayFinalize<ElementT>);
   return result.raw();
 }
 
 
@@ skipping 15 matching lines @@
   // ByteArray is an abstract class.
   UNREACHABLE();
   return "ByteArray";
 }
 
 
 template<typename HandleT, typename RawT>
 RawT* ByteArray::NewImpl(const Class& cls, intptr_t len, Heap::Space space) {
   HandleT& result = HandleT::Handle();
   {
-    RawObject* raw = Object::Allocate(cls, HandleT::InstanceSize(len), space);
+    RawObject* raw = Object::Allocate(cls.id(),
+                                      HandleT::InstanceSize(len),
+                                      space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     if (len > 0) {
       memset(result.ByteAddr(0), 0, result.ByteLength());
     }
   }
   return result.raw();
 }
 
 
 template<typename HandleT, typename RawT, typename ElementT>
 RawT* ByteArray::NewImpl(const Class& cls,
                          const ElementT* data,
                          intptr_t len,
                          Heap::Space space) {
   HandleT& result = HandleT::Handle();
   {
-    RawObject* raw = Object::Allocate(cls, HandleT::InstanceSize(len), space);
+    RawObject* raw = Object::Allocate(cls.id(),
+                                      HandleT::InstanceSize(len),
+                                      space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     if (len > 0) {
       memmove(result.ByteAddr(0), data, result.ByteLength());
     }
   }
   return result.raw();
 }
 
 
 RawInt8Array* Int8Array::New(intptr_t len, Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->int8_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->int8_array_class());
   return NewImpl<Int8Array, RawInt8Array>(cls, len, space);
 }
 
 
 RawInt8Array* Int8Array::New(const int8_t* data,
                              intptr_t len,
                              Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->int8_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->int8_array_class());
   return NewImpl<Int8Array, RawInt8Array>(cls, data, len, space);
 }
 
 
 const char* Int8Array::ToCString() const {
   return "_Int8Array";
 }
 
 
 RawUint8Array* Uint8Array::New(intptr_t len, Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->uint8_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->uint8_array_class());
   return NewImpl<Uint8Array, RawUint8Array>(cls, len, space);
 }
 
 
 RawUint8Array* Uint8Array::New(const uint8_t* data,
                                intptr_t len,
                                Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->uint8_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->uint8_array_class());
   return NewImpl<Uint8Array, RawUint8Array>(cls, data, len, space);
 }
 
 
 const char* Uint8Array::ToCString() const {
   return "_Uint8Array";
 }
 
 
 RawInt16Array* Int16Array::New(intptr_t len, Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->int16_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->int16_array_class());
   return NewImpl<Int16Array, RawInt16Array>(cls, len, space);
 }
 
 
 RawInt16Array* Int16Array::New(const int16_t* data,
                                intptr_t len,
                                Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->int16_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->int16_array_class());
   return NewImpl<Int16Array, RawInt16Array>(cls, data, len, space);
 }
 
 
 const char* Int16Array::ToCString() const {
   return "_Int16Array";
 }
 
 
 RawUint16Array* Uint16Array::New(intptr_t len, Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->uint16_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->uint16_array_class());
   return NewImpl<Uint16Array, RawUint16Array>(cls, len, space);
 }
 
 
 RawUint16Array* Uint16Array::New(const uint16_t* data,
                                  intptr_t len,
                                  Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->uint16_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->uint16_array_class());
   return NewImpl<Uint16Array, RawUint16Array>(cls, data, len, space);
 }
 
 
 const char* Uint16Array::ToCString() const {
   return "_Uint16Array";
 }
 
 
 RawInt32Array* Int32Array::New(intptr_t len, Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->int32_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->int32_array_class());
   return NewImpl<Int32Array, RawInt32Array>(cls, len, space);
 }
 
 
 RawInt32Array* Int32Array::New(const int32_t* data,
                                intptr_t len,
                                Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->int32_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->int32_array_class());
   return NewImpl<Int32Array, RawInt32Array>(cls, data, len, space);
 }
 
 
 const char* Int32Array::ToCString() const {
   return "_Int32Array";
 }
 
 
 RawUint32Array* Uint32Array::New(intptr_t len, Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->uint32_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->uint32_array_class());
   return NewImpl<Uint32Array, RawUint32Array>(cls, len, space);
 }
 
 
 RawUint32Array* Uint32Array::New(const uint32_t* data,
                                  intptr_t len,
                                  Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->uint32_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->uint32_array_class());
   return NewImpl<Uint32Array, RawUint32Array>(cls, data, len, space);
 }
 
 
 const char* Uint32Array::ToCString() const {
   return "_Uint32Array";
 }
 
 
 RawInt64Array* Int64Array::New(intptr_t len, Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->int64_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->int64_array_class());
   return NewImpl<Int64Array, RawInt64Array>(cls, len, space);
 }
 
 
 RawInt64Array* Int64Array::New(const int64_t* data,
                                intptr_t len,
                                Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->int64_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->int64_array_class());
   return NewImpl<Int64Array, RawInt64Array>(cls, data, len, space);
 }
 
 
 const char* Int64Array::ToCString() const {
   return "_Int64Array";
 }
 
 
 RawUint64Array* Uint64Array::New(intptr_t len, Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->uint64_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->uint64_array_class());
   return NewImpl<Uint64Array, RawUint64Array>(cls, len, space);
 }
 
 
 RawUint64Array* Uint64Array::New(const uint64_t* data,
                                  intptr_t len,
                                  Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->uint64_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->uint64_array_class());
   return NewImpl<Uint64Array, RawUint64Array>(cls, data, len, space);
 }
 
 
 const char* Uint64Array::ToCString() const {
   return "_Uint64Array";
 }
 
 
 RawFloat32Array* Float32Array::New(intptr_t len, Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->float32_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->float32_array_class());
   return NewImpl<Float32Array, RawFloat32Array>(cls, len, space);
 }
 
 
 RawFloat32Array* Float32Array::New(const float* data,
                                    intptr_t len,
                                    Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->float32_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->float32_array_class());
   return NewImpl<Float32Array, RawFloat32Array>(cls, data, len, space);
 }
 
 
 const char* Float32Array::ToCString() const {
   return "_Float32Array";
 }
 
 
 RawFloat64Array* Float64Array::New(intptr_t len, Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->float64_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->float64_array_class());
   return NewImpl<Float64Array, RawFloat64Array>(cls, len, space);
 }
 
 
 RawFloat64Array* Float64Array::New(const double* data,
                                    intptr_t len,
                                    Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->float64_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->float64_array_class());
   return NewImpl<Float64Array, RawFloat64Array>(cls, data, len, space);
 }
 
 
 const char* Float64Array::ToCString() const {
   return "_Float64Array";
 }
 
 
 RawExternalInt8Array* ExternalInt8Array::New(int8_t* data,
                                              intptr_t len,
                                              void* peer,
                                              Dart_PeerFinalizer callback,
                                              Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->external_int8_array_class() != Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->external_int8_array_class());
   return NewExternalImpl<ExternalInt8Array, RawExternalInt8Array>(
       cls, data, len, peer, callback, space);
 }
 
 
 const char* ExternalInt8Array::ToCString() const {
   return "_ExternalInt8Array";
 }
 
 
 RawExternalUint8Array* ExternalUint8Array::New(uint8_t* data,
                                                intptr_t len,
                                                void* peer,
                                                Dart_PeerFinalizer callback,
                                                Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->external_uint8_array_class() !=
+         Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->external_uint8_array_class());
   return NewExternalImpl<ExternalUint8Array, RawExternalUint8Array>(
       cls, data, len, peer, callback, space);
 }
 
 
 const char* ExternalUint8Array::ToCString() const {
   return "_ExternalUint8Array";
 }
 
 
 RawExternalInt16Array* ExternalInt16Array::New(int16_t* data,
                                                intptr_t len,
                                                void* peer,
                                                Dart_PeerFinalizer callback,
                                                Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->external_int16_array_class() !=
+         Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->external_int16_array_class());
   return NewExternalImpl<ExternalInt16Array, RawExternalInt16Array>(
       cls, data, len, peer, callback, space);
 }
 
 
 const char* ExternalInt16Array::ToCString() const {
   return "_ExternalInt16Array";
 }
 
 
 RawExternalUint16Array* ExternalUint16Array::New(uint16_t* data,
                                                  intptr_t len,
                                                  void* peer,
                                                  Dart_PeerFinalizer callback,
                                                  Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->external_uint16_array_class() !=
+         Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->external_uint16_array_class());
   return NewExternalImpl<ExternalUint16Array, RawExternalUint16Array>(
       cls, data, len, peer, callback, space);
 }
 
 
 const char* ExternalUint16Array::ToCString() const {
   return "_ExternalUint16Array";
 }
 
 
 RawExternalInt32Array* ExternalInt32Array::New(int32_t* data,
                                                intptr_t len,
                                                void* peer,
                                                Dart_PeerFinalizer callback,
                                                Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->external_int32_array_class() !=
+         Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->external_int32_array_class());
   return NewExternalImpl<ExternalInt32Array, RawExternalInt32Array>(
       cls, data, len, peer, callback, space);
 }
 
 
 const char* ExternalInt32Array::ToCString() const {
   return "_ExternalInt32Array";
 }
 
 
 RawExternalUint32Array* ExternalUint32Array::New(uint32_t* data,
                                                  intptr_t len,
                                                  void* peer,
                                                  Dart_PeerFinalizer callback,
                                                  Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->external_uint32_array_class() !=
+         Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->external_uint32_array_class());
   return NewExternalImpl<ExternalUint32Array, RawExternalUint32Array>(
       cls, data, len, peer, callback, space);
 }
 
 
 const char* ExternalUint32Array::ToCString() const {
   return "_ExternalUint32Array";
 }
 
 
 RawExternalInt64Array* ExternalInt64Array::New(int64_t* data,
                                                intptr_t len,
                                                void* peer,
                                                Dart_PeerFinalizer callback,
                                                Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->external_int64_array_class() !=
+         Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->external_int64_array_class());
   return NewExternalImpl<ExternalInt64Array, RawExternalInt64Array>(
       cls, data, len, peer, callback, space);
 }
 
 
 const char* ExternalInt64Array::ToCString() const {
   return "_ExternalInt64Array";
 }
 
 
 RawExternalUint64Array* ExternalUint64Array::New(uint64_t* data,
                                                  intptr_t len,
                                                  void* peer,
                                                  Dart_PeerFinalizer callback,
                                                  Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->external_uint64_array_class() !=
+         Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->external_uint64_array_class());
   return NewExternalImpl<ExternalUint64Array, RawExternalUint64Array>(
       cls, data, len, peer, callback, space);
 }
 
 
 const char* ExternalUint64Array::ToCString() const {
   return "_ExternalUint64Array";
 }
 
 
 RawExternalFloat32Array* ExternalFloat32Array::New(float* data,
                                                    intptr_t len,
                                                    void* peer,
                                                    Dart_PeerFinalizer callback,
                                                    Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->external_float32_array_class() !=
+         Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->external_float32_array_class());
   return NewExternalImpl<ExternalFloat32Array, RawExternalFloat32Array>(
       cls, data, len, peer, callback, space);
 }
 
 
 const char* ExternalFloat32Array::ToCString() const {
   return "_ExternalFloat32Array";
 }
 
 
 RawExternalFloat64Array* ExternalFloat64Array::New(double* data,
                                                    intptr_t len,
                                                    void* peer,
                                                    Dart_PeerFinalizer callback,
                                                    Heap::Space space) {
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->external_float64_array_class() !=
+         Class::null());
   const Class& cls =
       Class::Handle(isolate->object_store()->external_float64_array_class());
   return NewExternalImpl<ExternalFloat64Array, RawExternalFloat64Array>(
       cls, data, len, peer, callback, space);
 }
 
 
 const char* ExternalFloat64Array::ToCString() const {
   return "_ExternalFloat64Array";
 }
 
 
 
 RawClosure* Closure::New(const Function& function,
                          const Context& context,
                          Heap::Space space) {
   Isolate* isolate = Isolate::Current();
   ASSERT(context.isolate() == isolate);
 
   const Class& cls = Class::Handle(function.signature_class());
   Closure& result = Closure::Handle();
   {
-    RawObject* raw = Object::Allocate(cls, Closure::InstanceSize(), space);
+    RawObject* raw = Object::Allocate(cls.id(), Closure::InstanceSize(), space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_function(function);
   result.set_context(context);
   return result.raw();
 }
 
 
 void Closure::set_context(const Context& value) const {
@@ skipping 77 matching lines @@
     function_array.SetAt((index + i), function);
     code_array.SetAt((index + i), code);
     pc_offset = Smi::New(frame_pcs[i] - code.EntryPoint());
     pc_offset_array.SetAt((index + i), pc_offset);
   }
 }
 
 
 RawStacktrace* Stacktrace::New(const GrowableArray<uword>& stack_frame_pcs,
                                Heap::Space space) {
-  const Class& cls = Class::Handle(
-      Isolate::Current()->object_store()->stacktrace_class());
+  ASSERT(Isolate::Current()->object_store()->stacktrace_class() !=
+         Class::null());
   Stacktrace& result = Stacktrace::Handle();
   {
-    RawObject* raw = Object::Allocate(cls,
+    RawObject* raw = Object::Allocate(Stacktrace::kInstanceKind,
                                       Stacktrace::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
   intptr_t length = stack_frame_pcs.length();
   // Create arrays for the function, code and pc_offset triplet for each frame.
   const Array& function_array = Array::Handle(Array::New(length));
   const Array& code_array = Array::Handle(Array::New(length));
   const Array& pc_offset_array = Array::Handle(Array::New(length));
@@ skipping 102 matching lines @@
   StorePointer(&raw_ptr()->pattern_, pattern.raw());
 }
 
 
 void JSRegExp::set_num_bracket_expressions(intptr_t value) const {
   raw_ptr()->num_bracket_expressions_ = Smi::New(value);
 }
 
 
 RawJSRegExp* JSRegExp::New(intptr_t len, Heap::Space space) {
-  const Class& cls = Class::Handle(
-      Isolate::Current()->object_store()->jsregexp_class());
+  ASSERT(Isolate::Current()->object_store()->jsregexp_class() !=
+         Class::null());
   JSRegExp& result = JSRegExp::Handle();
   {
-    RawObject* raw = Object::Allocate(cls,
+    RawObject* raw = Object::Allocate(JSRegExp::kInstanceKind,
                                       JSRegExp::InstanceSize(len),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.set_type(kUnitialized);
     result.set_flags(0);
     result.SetLength(len);
   }
   return result.raw();
 }
@@ skipping 59 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