Make ImmutableArray a sub class of AllStatic.

runtime/vm/object.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 512 matching lines @@
   cls = Class::New<UnwindError>();
   unwind_error_class_ = cls.raw();
 
   ASSERT(class_class() != null_);
 
   // Pre-allocate classes in the vm isolate so that we can for example 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.set_type_arguments_field_offset(Array::type_arguments_offset());
-  cls = Class::New<ImmutableArray>();
+  cls = Class::New<Array>(kImmutableArrayCid);
   isolate->object_store()->set_immutable_array_class(cls);
   cls.set_type_arguments_field_offset(Array::type_arguments_offset());
   cls = Class::NewStringClass(kOneByteStringCid);
   isolate->object_store()->set_one_byte_string_class(cls);
   cls = Class::NewStringClass(kTwoByteStringCid);
   isolate->object_store()->set_two_byte_string_class(cls);
 
   // Allocate and initialize the empty_array instance.
   {
     uword address = heap->Allocate(Array::InstanceSize(0), Heap::kOld);
@@ skipping 281 matching lines @@
                     TypeArguments::Handle(),
                     Scanner::kDummyTokenIndex);
   type.SetIsFinalized();
   type ^= type.Canonicalize();
   object_store->set_array_type(type);
 
   cls = object_store->growable_object_array_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::GrowableObjectArray(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
-  cls = Class::New<ImmutableArray>();
+  cls = Class::New<Array>(kImmutableArrayCid);
   object_store->set_immutable_array_class(cls);
   cls.set_type_arguments_field_offset(Array::type_arguments_offset());
   ASSERT(object_store->immutable_array_class() != object_store->array_class());
+  cls.set_is_prefinalized();
   RegisterPrivateClass(cls, Symbols::ImmutableArray(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = object_store->one_byte_string_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::OneByteString(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = object_store->two_byte_string_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::TwoByteString(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
@@ skipping 264 matching lines @@
 
   cls = Class::New<BoundedType>();
   object_store->set_bounded_type_class(cls);
 
   cls = Class::New<MixinAppType>();
   object_store->set_mixin_app_type_class(cls);
 
   cls = Class::New<Array>();
   object_store->set_array_class(cls);
 
-  cls = Class::New<ImmutableArray>();
+  cls = Class::New<Array>(kImmutableArrayCid);
   object_store->set_immutable_array_class(cls);
 
   cls = Class::New<GrowableObjectArray>();
   object_store->set_growable_object_array_class(cls);
 
   cls = Class::New<Float32x4>();
   object_store->set_float32x4_class(cls);
 
   cls = Class::New<Uint32x4>();
   object_store->set_uint32x4_class(cls);
@@ skipping 11401 matching lines @@
 void Array::MakeImmutable() const {
   NoGCScope no_gc;
   uword tags = raw_ptr()->tags_;
   tags = RawObject::ClassIdTag::update(kImmutableArrayCid, tags);
   raw_ptr()->tags_ = tags;
 }
 
 
 const char* Array::ToCString() const {
   if (IsNull()) {
-    return "Array NULL";
+    return IsImmutable() ? "ImmutableArray NULL" : "Array NULL";
   }
-  const char* format = "Array len:%"Pd"";
+  const char* format = !IsImmutable() ? "Array len:%"Pd"" :
+      "Immutable Array len:%"Pd"";
   intptr_t len = OS::SNPrint(NULL, 0, format, Length()) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, Length());
   return chars;
 }
 
 
 RawArray* Array::Grow(const Array& source, int new_length, Heap::Space space) {
   const Array& result = Array::Handle(Array::New(new_length, space));
   intptr_t len = 0;
@@ skipping 47 matching lines @@
 
 
 RawImmutableArray* ImmutableArray::New(intptr_t len,
                                        Heap::Space 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 {
-  if (IsNull()) {
-    return "ImmutableArray NULL";
-  }
-  const char* format = "ImmutableArray len:%"Pd"";
-  intptr_t len = OS::SNPrint(NULL, 0, format, Length()) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, format, Length());
-  return chars;
-}
-
-
 void GrowableObjectArray::Add(const Object& value, Heap::Space space) const {
   ASSERT(!IsNull());
   if (Length() == Capacity()) {
     // TODO(Issue 2500): Need a better growth strategy.
     intptr_t new_capacity = (Capacity() == 0) ? 4 : Capacity() * 2;
     if (new_capacity <= Capacity()) {
       // Use the preallocated out of memory exception to avoid calling
       // into dart code or allocating any code.
       Isolate* isolate = Isolate::Current();
       const Instance& exception =
@@ skipping 760 matching lines @@
                                     space);
   return reinterpret_cast<RawWeakProperty*>(raw);
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart