Revert "Revert "Implement {Int,Uint}{8,16,32,64} and Float{32,64} typed arrays.""

runtime/vm/class_finalizer.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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 204 matching lines @@
   cls = object_store->mint_class();
   ASSERT(Mint::InstanceSize() == cls.instance_size());
   cls = object_store->bigint_class();
   ASSERT(Bigint::InstanceSize() == cls.instance_size());
   cls = object_store->bool_class();
   ASSERT(Bool::InstanceSize() == cls.instance_size());
   cls = object_store->array_class();
   ASSERT(Array::InstanceSize() == cls.instance_size());
   cls = object_store->immutable_array_class();
   ASSERT(ImmutableArray::InstanceSize() == cls.instance_size());
-  cls = object_store->internal_byte_array_class();
-  ASSERT(InternalByteArray::InstanceSize() == cls.instance_size());
-  cls = object_store->external_byte_array_class();
-  ASSERT(ExternalByteArray::InstanceSize() == cls.instance_size());
+  cls = object_store->uint8_array_class();
+  ASSERT(Uint8Array::InstanceSize() == cls.instance_size());
+  cls = object_store->int16_array_class();
+  ASSERT(Int16Array::InstanceSize() == cls.instance_size());
+  cls = object_store->uint16_array_class();
+  ASSERT(Uint16Array::InstanceSize() == cls.instance_size());
+  cls = object_store->int32_array_class();
+  ASSERT(Int32Array::InstanceSize() == cls.instance_size());
+  cls = object_store->uint32_array_class();
+  ASSERT(Uint32Array::InstanceSize() == cls.instance_size());
+  cls = object_store->int64_array_class();
+  ASSERT(Int64Array::InstanceSize() == cls.instance_size());
+  cls = object_store->uint64_array_class();
+  ASSERT(Uint64Array::InstanceSize() == cls.instance_size());
+  cls = object_store->float32_array_class();
+  ASSERT(Float32Array::InstanceSize() == cls.instance_size());
+  cls = object_store->float64_array_class();
+  ASSERT(Float64Array::InstanceSize() == cls.instance_size());
+  cls = object_store->external_int8_array_class();
+  ASSERT(ExternalInt8Array::InstanceSize() == cls.instance_size());
+  cls = object_store->external_uint8_array_class();
+  ASSERT(ExternalUint8Array::InstanceSize() == cls.instance_size());
+  cls = object_store->external_int16_array_class();
+  ASSERT(ExternalInt16Array::InstanceSize() == cls.instance_size());
+  cls = object_store->external_uint16_array_class();
+  ASSERT(ExternalUint16Array::InstanceSize() == cls.instance_size());
+  cls = object_store->external_int32_array_class();
+  ASSERT(ExternalInt32Array::InstanceSize() == cls.instance_size());
+  cls = object_store->external_uint32_array_class();
+  ASSERT(ExternalUint32Array::InstanceSize() == cls.instance_size());
+  cls = object_store->external_int64_array_class();
+  ASSERT(ExternalInt64Array::InstanceSize() == cls.instance_size());
+  cls = object_store->external_uint64_array_class();
+  ASSERT(ExternalUint64Array::InstanceSize() == cls.instance_size());
+  cls = object_store->external_float32_array_class();
+  ASSERT(ExternalFloat32Array::InstanceSize() == cls.instance_size());
+  cls = object_store->external_float64_array_class();
+  ASSERT(ExternalFloat64Array::InstanceSize() == cls.instance_size());
 #endif  // defined(DEBUG)
 
   // Remember the currently pending classes.
   const GrowableObjectArray& class_array =
       GrowableObjectArray::Handle(object_store->pending_classes());
   for (intptr_t i = 0; i < class_array.Length(); i++) {
     // TODO(iposva): Add real checks.
     cls ^= class_array.At(i);
     if (cls.is_finalized() || cls.is_prefinalized()) {
       // Pre-finalized bootstrap classes must not define any fields.
-      ASSERT(Array::Handle(cls.fields()).Length() == 0);
+      ASSERT(!cls.HasInstanceFields());
     }
   }
 
   // Finalize classes that aren't pre-finalized by Object::Init().
   if (!FinalizePendingClasses()) {
     // TODO(srdjan): Exit like a real VM instead.
     const Error& err = Error::Handle(object_store->sticky_error());
     OS::PrintErr("Could not verify bootstrap classes : %s\n",
                  err.ToErrorCString());
     OS::Exit(255);
@@ skipping 62 matching lines @@
         Class::Handle(core_impl_lib.LookupClass(integer_implementation_name));
     const String& growable_object_array_name =
         String::Handle(String::NewSymbol("GrowableObjectArray"));
     const Class& growable_object_array_class =
         Class::Handle(core_impl_lib.LookupClass(growable_object_array_name));
     if ((super_class.raw() == object_store->bool_class()) ||
         (super_class.raw() == object_store->double_class()) ||
         (super_class.raw() == object_store->array_class()) ||
         (super_class.raw() == object_store->immutable_array_class()) ||
         (super_class.raw() == growable_object_array_class.raw()) ||
-        (super_class.raw() == object_store->internal_byte_array_class()) ||
-        (super_class.raw() == object_store->external_byte_array_class()) ||
+        (super_class.raw() == object_store->int8_array_class()) ||
+        (super_class.raw() == object_store->uint8_array_class()) ||
+        (super_class.raw() == object_store->int16_array_class()) ||
+        (super_class.raw() == object_store->uint16_array_class()) ||
+        (super_class.raw() == object_store->int32_array_class()) ||
+        (super_class.raw() == object_store->uint32_array_class()) ||
+        (super_class.raw() == object_store->int64_array_class()) ||
+        (super_class.raw() == object_store->uint64_array_class()) ||
+        (super_class.raw() == object_store->float32_array_class()) ||
+        (super_class.raw() == object_store->float64_array_class()) ||
+        (super_class.raw() == object_store->external_int8_array_class()) ||
+        (super_class.raw() == object_store->external_uint8_array_class()) ||
+        (super_class.raw() == object_store->external_int16_array_class()) ||
+        (super_class.raw() == object_store->external_uint16_array_class()) ||
+        (super_class.raw() == object_store->external_int32_array_class()) ||
+        (super_class.raw() == object_store->external_uint32_array_class()) ||
+        (super_class.raw() == object_store->external_int64_array_class()) ||
+        (super_class.raw() == object_store->external_uint64_array_class()) ||
+        (super_class.raw() == object_store->external_float32_array_class()) ||
+        (super_class.raw() == object_store->external_float64_array_class()) ||
         (super_class.raw() == integer_implementation_class.raw()) ||
         (super_class.raw() == object_store->smi_class()) ||
         (super_class.raw() == object_store->mint_class()) ||
         (super_class.raw() == object_store->bigint_class()) ||
         (super_class.raw() == object_store->one_byte_string_class()) ||
         (super_class.raw() == object_store->two_byte_string_class()) ||
         (super_class.raw() == object_store->four_byte_string_class())) {
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_index(),
                   "'%s' is not allowed to extend '%s'",
@@ skipping 1028 matching lines @@
 void ClassFinalizer::ReportError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
   va_end(args);
   ReportError(error);
 }
 
 }  // namespace dart