Remove some unnecessary class handle creations.

vm/object.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 11038 matching lines @@
   for (intptr_t i = 0; i < len; i++) {
     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);
+  ASSERT(Isolate::Current()->object_store()->array_class() != Class::null());
+  return New(kClassId, len, space);
 }
 
 
-RawArray* Array::New(const Class& cls, intptr_t len, Heap::Space space) {
+RawArray* Array::New(intptr_t class_id, intptr_t len, Heap::Space space) {
   if (len < 0 || len > Array::kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Array::New: invalid len %"Pd"\n", len);
   }
   Array& result = Array::Handle();
   {
-    RawObject* raw = Object::Allocate(cls.id(),
+    RawObject* raw = Object::Allocate(class_id,
                                       Array::InstanceSize(len),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
   }
   return result.raw();
 }
 
 
 void Array::MakeImmutable() const {
-  Isolate* isolate = Isolate::Current();
-  const Class& cls = Class::Handle(
-      isolate, isolate->object_store()->immutable_array_class());
-  {
-    NoGCScope no_gc;
-    uword tags = raw_ptr()->tags_;
-    tags = RawObject::ClassIdTag::update(cls.id(), tags);
-    raw_ptr()->tags_ = tags;
-  }
+  NoGCScope no_gc;
+  uword tags = raw_ptr()->tags_;
+  tags = RawObject::ClassIdTag::update(kImmutableArrayCid, tags);
+  raw_ptr()->tags_ = tags;
 }
 
 
 const char* Array::ToCString() const {
   return "Array";
 }
 
 
 RawArray* Array::Grow(const Array& source, int new_length, Heap::Space space) {
   const Array& result = Array::Handle(Array::New(new_length, space));
@@ skipping 40 matching lines @@
   // that it can be traversed over successfully during garbage collection.
   if (capacity_size != used_size) {
     ASSERT(capacity_len > used_len);
     intptr_t leftover_size = capacity_size - used_size;
 
     uword addr = RawObject::ToAddr(array.raw()) + used_size;
     if (leftover_size >= Array::InstanceSize(0)) {
       // As we have enough space to use an array object, update the leftover
       // space as an Array object.
       RawArray* raw = reinterpret_cast<RawArray*>(RawObject::FromAddr(addr));
-      const Class& cls = Class::Handle(isolate->object_store()->array_class());
       tags = 0;
       tags = RawObject::SizeTag::update(leftover_size, tags);
-      tags = RawObject::ClassIdTag::update(cls.id(), tags);
+      tags = RawObject::ClassIdTag::update(kArrayCid, tags);
       raw->ptr()->tags_ = tags;
       intptr_t leftover_len =
           ((leftover_size - Array::InstanceSize(0)) / kWordSize);
       raw->ptr()->tags_ = tags;
       raw->ptr()->length_ = Smi::New(leftover_len);
     } else {
       // Update the leftover space as a basic object.
       ASSERT(leftover_size == Object::InstanceSize());
       RawObject* raw = reinterpret_cast<RawObject*>(RawObject::FromAddr(addr));
       tags = 0;
       tags = RawObject::SizeTag::update(leftover_size, tags);
       tags = RawObject::ClassIdTag::update(kInstanceCid, tags);
       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));
+  ASSERT(Isolate::Current()->object_store()->immutable_array_class() !=
+         Class::null());
+  return reinterpret_cast<RawImmutableArray*>(Array::New(kClassId, len, space));
 }
 
 
 const char* ImmutableArray::ToCString() const {
   return "ImmutableArray";
 }
 
 
 void GrowableObjectArray::Add(const Object& value, Heap::Space space) const {
   ASSERT(!IsNull());
@@ skipping 155 matching lines @@
 
 
 template<typename T>
 static void ExternalByteArrayFinalize(Dart_Handle handle, void* peer) {
   delete reinterpret_cast<ExternalByteArrayData<T>*>(peer);
   DeleteWeakPersistentHandle(handle);
 }
 
 
 template<typename HandleT, typename RawT, typename ElementT>
-RawT* ByteArray::NewExternalImpl(const Class& cls,
+RawT* ByteArray::NewExternalImpl(intptr_t class_id,
                                  ElementT* data,
                                  intptr_t len,
                                  void* peer,
                                  Dart_PeerFinalizer callback,
                                  Heap::Space space) {
   if (len < 0 || len > HandleT::kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in ByteArray::NewExternalImpl: invalid len %"Pd"\n",
            len);
   }
   HandleT& result = HandleT::Handle();
   ExternalByteArrayData<ElementT>* external_data =
       new ExternalByteArrayData<ElementT>(data, peer, callback);
   {
-    RawObject* raw = Object::Allocate(cls.id(), HandleT::InstanceSize(), space);
+    RawObject* raw = Object::Allocate(class_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 12 matching lines @@
 
 
 const char* ByteArray::ToCString() const {
   // 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) {
+RawT* ByteArray::NewImpl(intptr_t class_id, intptr_t len, Heap::Space space) {
   if (len < 0 || len > HandleT::kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in ByteArray::NewImpl: invalid len %"Pd"\n", len);
   }
   HandleT& result = HandleT::Handle();
   {
-    RawObject* raw = Object::Allocate(cls.id(),
+    RawObject* raw = Object::Allocate(class_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,
+RawT* ByteArray::NewImpl(intptr_t class_id,
                          const ElementT* data,
                          intptr_t len,
                          Heap::Space space) {
   if (len < 0 || len > HandleT::kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in ByteArray::NewImpl: invalid len %"Pd"\n", len);
   }
   HandleT& result = HandleT::Handle();
   {
-    RawObject* raw = Object::Allocate(cls.id(),
+    RawObject* raw = Object::Allocate(class_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);
+  ASSERT(Isolate::Current()->object_store()->int8_array_class() !=
+         Class::null());
+  return NewImpl<Int8Array, RawInt8Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->int8_array_class() !=
+         Class::null());
+  return NewImpl<Int8Array, RawInt8Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->uint8_array_class() !=
+         Class::null());
+  return NewImpl<Uint8Array, RawUint8Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->uint8_array_class() !=
+         Class::null());
+  return NewImpl<Uint8Array, RawUint8Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->int16_array_class() !=
+         Class::null());
+  return NewImpl<Int16Array, RawInt16Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->int16_array_class() !=
+         Class::null());
+  return NewImpl<Int16Array, RawInt16Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->uint16_array_class() !=
+         Class::null());
+  return NewImpl<Uint16Array, RawUint16Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->uint16_array_class() !=
+         Class::null());
+  return NewImpl<Uint16Array, RawUint16Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->int32_array_class() !=
+         Class::null());
+  return NewImpl<Int32Array, RawInt32Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->int32_array_class() !=
+         Class::null());
+  return NewImpl<Int32Array, RawInt32Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->uint32_array_class() !=
+         Class::null());
+  return NewImpl<Uint32Array, RawUint32Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->uint32_array_class() !=
+         Class::null());
+  return NewImpl<Uint32Array, RawUint32Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->int64_array_class() !=
+         Class::null());
+  return NewImpl<Int64Array, RawInt64Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->int64_array_class() !=
+         Class::null());
+  return NewImpl<Int64Array, RawInt64Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->uint64_array_class() !=
+         Class::null());
+  return NewImpl<Uint64Array, RawUint64Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->uint64_array_class() !=
+         Class::null());
+  return NewImpl<Uint64Array, RawUint64Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->float32_array_class() !=
+         Class::null());
+  return NewImpl<Float32Array, RawFloat32Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->float32_array_class() !=
+         Class::null());
+  return NewImpl<Float32Array, RawFloat32Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->float64_array_class() !=
+         Class::null());
+  return NewImpl<Float64Array, RawFloat64Array>(kClassId, 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);
+  ASSERT(Isolate::Current()->object_store()->float64_array_class() !=
+         Class::null());
+  return NewImpl<Float64Array, RawFloat64Array>(kClassId, 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());
+  ASSERT(Isolate::Current()->object_store()->external_int8_array_class() !=
+         Class::null());
   return NewExternalImpl<ExternalInt8Array, RawExternalInt8Array>(
-      cls, data, len, peer, callback, space);
+      kClassId, 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() !=
+  ASSERT(Isolate::Current()->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);
+      kClassId, 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() !=
+  ASSERT(Isolate::Current()->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);
+      kClassId, 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() !=
+  ASSERT(Isolate::Current()->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);
+      kClassId, 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() !=
+  ASSERT(Isolate::Current()->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);
+      kClassId, 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() !=
+  ASSERT(Isolate::Current()->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);
+      kClassId, 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() !=
+  ASSERT(Isolate::Current()->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);
+      kClassId, 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() !=
+  ASSERT(Isolate::Current()->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);
+      kClassId, 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() !=
+  ASSERT(Isolate::Current()->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);
+      kClassId, 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() !=
+  ASSERT(Isolate::Current()->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);
+      kClassId, data, len, peer, callback, space);
 }
 
 
 const char* ExternalFloat64Array::ToCString() const {
   return "_ExternalFloat64Array";
 }
 
 
 const char* Closure::ToCString(const Instance& closure) {
   const Function& fun = Function::Handle(Closure::function(closure));
@@ skipping 296 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart