Revert r1380 that is breaking frog.

runtime/vm/object.cc

 // Copyright (c) 2011, 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 "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 221 matching lines @@
   // be true before calling Class::New<Class>(), or it will fail.
   class_class_ = Class::Handle().raw();  // Set 'class_class_' to 'null_'.
   cls = Class::New<Class>();
   cls.set_is_finalized();
   class_class_ = cls.raw();
   // Make the class_ field point to itself.
   class_class_->ptr()->class_ = class_class_;
 
   // Allocate and initialize the null class.
   cls = Class::New<Instance>();
-  cls.set_is_finalized();
   null_class_ = cls.raw();
 
   // Complete initialization of null_ instance, i.e. initialize its class_
   // field.
   null_->ptr()->class_ = null_class_;
 
   // Allocate and initialize the sentinel values of an instance class.
   {
     cls = Class::New<Instance>();
     Instance& sentinel = Instance::Handle();
     sentinel ^= Object::Allocate(cls, Instance::InstanceSize(), Heap::kOld);
     sentinel_ = sentinel.raw();
 
     Instance& transition_sentinel = Instance::Handle();
     transition_sentinel ^=
         Object::Allocate(cls, 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.
   cls = Class::New<Instance>();
-  cls.set_is_finalized();
   cls.set_is_interface();
   dynamic_class_ = cls.raw();
 
   // Allocate the remaining VM internal classes.
   cls = Class::New<UnresolvedClass>();
   unresolved_class_class_ = cls.raw();
 
   cls = Class::New<Instance>();
-  cls.set_is_finalized();
   void_class_ = cls.raw();
 
   cls = Class::New<ParameterizedType>();
   parameterized_type_class_ = cls.raw();
 
   cls = Class::New<TypeParameter>();
   type_parameter_class_ = cls.raw();
 
   cls = Class::New<InstantiatedType>();
   instantiated_type_class_ = cls.raw();
@@ skipping 43 matching lines @@
   cls = Class::New<ContextScope>();
   context_scope_class_ = cls.raw();
 
   cls = Class::New<ApiFailure>();
   api_failure_class_ = cls.raw();
 
   ASSERT(class_class() != null_);
 }
 
 
-RawClass* Object::CreateAndRegisterCoreInterface(const char* cname,
-                                                 const Script& script,
-                                                 const Library& core_lib) {
-  const String& name = String::Handle(String::NewSymbol(cname));
-  const Class& cls = Class::Handle(Class::NewInterface(name, script));
-  core_lib.AddClass(cls);
-  return cls.raw();
-}
-
-
-void Object::RegisterCoreImplClass(const Class& cls,
-                                   const char* cname,
-                                   const Script& impl_script,
-                                   const Library& core_impl_lib) {
-  const String& name = String::Handle(String::NewSymbol(cname));
-  cls.set_name(name);
-  cls.set_script(impl_script);
-  core_impl_lib.AddClass(cls);
-}
-
-
 void Object::Init(Isolate* isolate) {
   TIMERSCOPE(time_bootstrap);
   ObjectStore* object_store = isolate->object_store();
 
   Class& cls = Class::Handle();
   Type& type = Type::Handle();
+  String& name = String::Handle();
   Array& array = Array::Handle();
 
   // All RawArray fields will be initialized to an empty array, therefore
   // initialize array class first.
   cls = Class::New<Array>();
   object_store->set_array_class(cls);
 
   // Array and ImmutableArray are the only VM classes that are parameterized.
   // Since they are pre-finalized, CalculateFieldOffsets() is not called, so we
   // need to set the offset of their type_arguments_ field, which is explicitly
   // declared in RawArray.
   cls.set_type_arguments_instance_field_offset(Array::type_arguments_offset());
 
   Array& empty_array = Array::Handle();
   empty_array = Array::New(0, Heap::kOld);
   object_store->set_empty_array(empty_array);
 
   // Re-initialize fields of the array class now that the empty array
   // has been created.
   cls.InitEmptyFields();
 
+  cls = Class::New<ImmutableArray>();
+  object_store->set_immutable_array_class(cls);
+  cls.set_type_arguments_instance_field_offset(Array::type_arguments_offset());
+
+  // Allocate and initialize the object class and type.
+  cls = Class::New<Instance>();
+  object_store->set_object_class(cls);
+  type = Type::NewNonParameterizedType(cls);
+  object_store->set_object_type(type);
+
+  cls = Class::New<Smi>();
+  object_store->set_smi_class(cls);
+
+  cls = Class::New<Mint>();
+  object_store->set_mint_class(cls);
+
+  cls = Class::New<Bigint>();
+  object_store->set_bigint_class(cls);
+
+  cls = Class::New<Double>();
+  object_store->set_double_class(cls);
+
+  cls = Class::New<OneByteString>();
+  object_store->set_one_byte_string_class(cls);
+
+  cls = Class::New<TwoByteString>();
+  object_store->set_two_byte_string_class(cls);
+
+  cls = Class::New<FourByteString>();
+  object_store->set_four_byte_string_class(cls);
+
+  cls = Class::New<Bool>();
+  object_store->set_bool_class(cls);
+
+  cls = Class::New<UnhandledException>();
+  object_store->set_unhandled_exception_class(cls);
+
+  cls = Class::New<Stacktrace>();
+  object_store->set_stacktrace_class(cls);
+  // Set the super type so that the 'toString' method is implemented.
+  type = object_store->object_type();
+  cls.set_super_type(type);
+
+  cls = Class::New<JSRegExp>();
+  object_store->set_jsregexp_class(cls);
+
   // 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);
 
-  // Pre-allocate the OneByteString class needed by the symbol table.
-  cls = Class::New<OneByteString>();
-  object_store->set_one_byte_string_class(cls);
-
   // Basic infrastructure has been setup, initialize the class dictionary.
   Library::InitCoreLibrary(isolate);
-  Library& core_lib = Library::Handle(Library::CoreLibrary());
+  Library& core_lib = Library::Handle(isolate->object_store()->core_library());
   ASSERT(!core_lib.IsNull());
   Library& core_impl_lib = Library::Handle(Library::CoreImplLibrary());
   ASSERT(!core_impl_lib.IsNull());
 
-  object_store->set_pending_classes(Array::Handle());
+  // Allocate pre-initialized values.
+  Bool& bool_value = Bool::Handle();
+  bool_value = Bool::New(true);
+  object_store->set_true_value(bool_value);
+  bool_value = Bool::New(false);
+  object_store->set_false_value(bool_value);
+
+  object_store->set_pending_classes(Array::Handle(Array::Empty()));
 
   Context& context = Context::Handle(Context::New(0));
   object_store->set_empty_context(context);
 
-  // Now that the symbol table is initialized and that the core dictionary as
-  // well as the core implementation dictionary have been setup, preallocate
-  // remaining classes and register them by name in the dictionaries.
+  // Now that the String class is initialized and the dictionary has been setup,
+  // add the names to preallocated classes and register them in the dictionary.
   const Script& impl_script = Script::Handle(Bootstrap::LoadImplScript());
-  GrowableArray<const Class*> pending_classes;
 
-  cls = Class::New<Smi>();
-  object_store->set_smi_class(cls);
-  RegisterCoreImplClass(cls, "Smi", impl_script, core_impl_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  name = String::NewSymbol("Smi");
+  cls = object_store->smi_class();
+  cls.set_name(name);
+  cls.set_script(impl_script);
+  core_impl_lib.AddClass(cls);
 
-  cls = Class::New<Mint>();
-  object_store->set_mint_class(cls);
-  RegisterCoreImplClass(cls, "Mint", impl_script, core_impl_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  name = String::NewSymbol("OneByteString");
+  cls = object_store->one_byte_string_class();
+  cls.set_name(name);
+  cls.set_script(impl_script);
+  core_impl_lib.AddClass(cls);
 
-  cls = Class::New<Bigint>();
-  object_store->set_bigint_class(cls);
-  RegisterCoreImplClass(cls, "Bigint", impl_script, core_impl_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  name = String::NewSymbol("TwoByteString");
+  cls = object_store->two_byte_string_class();
+  cls.set_name(name);
+  cls.set_script(impl_script);
+  core_impl_lib.AddClass(cls);
 
-  cls = Class::New<Double>();
-  object_store->set_double_class(cls);
-  RegisterCoreImplClass(cls, "Double", impl_script, core_impl_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  name = String::NewSymbol("FourByteString");
+  cls = object_store->four_byte_string_class();
+  cls.set_name(name);
+  cls.set_script(impl_script);
+  core_impl_lib.AddClass(cls);
 
-  cls = Class::New<Bool>();
-  object_store->set_bool_class(cls);
-  RegisterCoreImplClass(cls, "Bool", impl_script, core_impl_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  name = String::NewSymbol("Mint");
+  cls = object_store->mint_class();
+  cls.set_name(name);
+  cls.set_script(impl_script);
+  core_impl_lib.AddClass(cls);
 
-  cls = object_store->array_class();  // Was allocated above.
-  RegisterCoreImplClass(cls, "ObjectArray", impl_script, core_impl_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  name = String::NewSymbol("Bigint");
+  cls = object_store->bigint_class();
+  cls.set_name(name);
+  cls.set_script(impl_script);
+  core_impl_lib.AddClass(cls);
 
-  cls = Class::New<ImmutableArray>();
-  object_store->set_immutable_array_class(cls);
-  cls.set_type_arguments_instance_field_offset(Array::type_arguments_offset());
+  name = String::NewSymbol("Double");
+  cls = object_store->double_class();
+  cls.set_name(name);
+  cls.set_script(impl_script);
+  core_impl_lib.AddClass(cls);
+
+  name = String::NewSymbol("Bool");
+  cls = object_store->bool_class();
+  cls.set_name(name);
+  cls.set_script(impl_script);
+  core_impl_lib.AddClass(cls);
+
+  name = String::NewSymbol("ObjectArray");
+  cls = object_store->array_class();
+  cls.set_name(name);
+  cls.set_script(impl_script);
+  core_impl_lib.AddClass(cls);
+
+  name = String::NewSymbol("ImmutableArray");
+  cls = object_store->immutable_array_class();
   ASSERT(object_store->immutable_array_class() != object_store->array_class());
-  RegisterCoreImplClass(cls, "ImmutableArray", impl_script, core_impl_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  cls.set_name(name);
+  cls.set_script(impl_script);
+  core_impl_lib.AddClass(cls);
 
-  cls = object_store->one_byte_string_class();  // Was allocated above.
-  RegisterCoreImplClass(cls, "OneByteString", impl_script, core_impl_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  name = String::NewSymbol("UnhandledException");
+  cls = object_store->unhandled_exception_class();
+  cls.set_name(name);
+  cls.set_script(impl_script);
+  core_impl_lib.AddClass(cls);
 
-  cls = Class::New<TwoByteString>();
-  object_store->set_two_byte_string_class(cls);
-  RegisterCoreImplClass(cls, "TwoByteString", impl_script, core_impl_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  name = String::NewSymbol("Stacktrace");
+  cls = object_store->stacktrace_class();
+  cls.set_name(name);
+  cls.set_script(impl_script);
+  core_impl_lib.AddClass(cls);
 
-  cls = Class::New<FourByteString>();
-  object_store->set_four_byte_string_class(cls);
-  RegisterCoreImplClass(cls, "FourByteString", impl_script, core_impl_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
-
-  cls = Class::New<UnhandledException>();
-  object_store->set_unhandled_exception_class(cls);
-  RegisterCoreImplClass(cls, "UnhandledException", impl_script, core_impl_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
-
-  cls = Class::New<Stacktrace>();
-  object_store->set_stacktrace_class(cls);
-  RegisterCoreImplClass(cls, "Stacktrace", impl_script, core_impl_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
-  // Super type set below, after Object is allocated.
-
-  cls = Class::New<JSRegExp>();
-  object_store->set_jsregexp_class(cls);
-  RegisterCoreImplClass(cls, "JSSyntaxRegExp", impl_script, core_impl_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  name = String::NewSymbol("JSSyntaxRegExp");
+  cls = object_store->jsregexp_class();
+  cls.set_name(name);
+  cls.set_script(impl_script);
+  core_impl_lib.AddClass(cls);
 
   // 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.
-  // Object class is the only pre-allocated non-interface in the core library.
-  cls = Class::New<Instance>();
-  object_store->set_object_class(cls);
-  cls.set_name(String::Handle(String::NewSymbol("Object")));
+  name = String::NewSymbol("Object");
+  cls = object_store->object_class();
+  cls.set_name(name);
   cls.set_script(script);
   core_lib.AddClass(cls);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
-  type = Type::NewNonParameterizedType(cls);
-  object_store->set_object_type(type);
 
-  // Set the super type of class Stacktrace to Object type so that the
-  // 'toString' method is implemented.
-  cls = object_store->stacktrace_class();
-  cls.set_super_type(type);
-
-  cls = CreateAndRegisterCoreInterface("Function", script, core_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  name = String::NewSymbol("Function");
+  cls = Class::NewInterface(name, script);
+  core_lib.AddClass(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_function_interface(type);
 
-  cls = CreateAndRegisterCoreInterface("num", script, core_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  name = String::NewSymbol("num");
+  cls = Class::NewInterface(name, script);
+  core_lib.AddClass(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_number_interface(type);
 
-  cls = CreateAndRegisterCoreInterface("int", script, core_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  name = String::NewSymbol("int");
+  cls = Class::NewInterface(name, script);
+  core_lib.AddClass(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_int_interface(type);
 
-  cls = CreateAndRegisterCoreInterface("double", script, core_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  name = String::NewSymbol("double");
+  cls = Class::NewInterface(name, script);
+  core_lib.AddClass(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_double_interface(type);
 
-  cls = CreateAndRegisterCoreInterface("String", script, core_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  name = String::NewSymbol("String");
+  cls = Class::NewInterface(name, script);
+  core_lib.AddClass(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_string_interface(type);
 
-  cls = CreateAndRegisterCoreInterface("bool", script, core_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  name = String::NewSymbol("bool");
+  cls = Class::NewInterface(name, script);
+  core_lib.AddClass(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_bool_interface(type);
 
-  cls = CreateAndRegisterCoreInterface("List", script, core_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  name = String::NewSymbol("List");
+  cls = Class::NewInterface(name, script);
+  core_lib.AddClass(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_list_interface(type);
 
   // The classes 'Null' and 'void' are not registered in the class dictionary,
   // because their names are reserved keywords. Their names are not heap
   // allocated, because the classes reside in the VM isolate.
   // The corresponding types are stored in the object store.
   cls = null_class_;
   type = Type::NewNonParameterizedType(cls);
   object_store->set_null_type(type);
 
   cls = void_class_;
   type = Type::NewNonParameterizedType(cls);
   object_store->set_void_type(type);
 
   // The class 'Dynamic' is registered in the class dictionary because its name
   // is a built-in identifier, rather than a reserved keyword. Its name is not
   // heap allocated, because the class resides in the VM isolate.
   // The corresponding type, the "unknown type", is stored in the object store.
   cls = dynamic_class_;
   type = Type::NewNonParameterizedType(cls);
   object_store->set_dynamic_type(type);
   core_lib.AddClass(cls);
 
-  // Add the preallocated classes to the list of classes to be finalized.
-  ClassFinalizer::ExpectClassesToFinalize();
-  ClassFinalizer::AddClassesToFinalize(pending_classes);
-
-  // Allocate pre-initialized values.
-  Bool& bool_value = Bool::Handle();
-  bool_value = Bool::New(true);
-  object_store->set_true_value(bool_value);
-  bool_value = Bool::New(false);
-  object_store->set_false_value(bool_value);
-
-  // Finish the initialization by compiling the bootstrap scripts containing the
-  // base interfaces and the implementation of the internal classes.
-  Bootstrap::Compile(core_lib, script);
-  Bootstrap::Compile(core_impl_lib, impl_script);
+  // Finish the initialization by compiling the bootstrap script containing the
+  // implementation of the internal classes.
+  Bootstrap::Compile(Library::Handle(Library::CoreLibrary()), script);
+  Bootstrap::Compile(Library::Handle(Library::CoreImplLibrary()), impl_script);
 
   Bootstrap::SetupNativeResolver();
 
   // Remove the Object superclass cycle by setting the super type to null (not
   // to the type of null).
   cls = object_store->object_class();
   cls.set_super_type(Type::Handle());
 
   ClassFinalizer::VerifyBootstrapClasses();
 }
@@ skipping 444 matching lines @@
       }
     }
   }
   Class& result = Class::Handle(New<Closure>(name, script));
   result.set_super_type(super_type);
   result.set_signature_function(signature_function);
   result.set_type_parameters(type_parameters);
   result.set_type_parameter_extends(type_parameter_extends);
   result.SetFields(Array::Handle(Array::Empty()));
   result.SetFunctions(Array::Handle(Array::Empty()));
-  // Implements interface "Function".
+  // Implements interface Function.
   const Type& function_interface = Type::Handle(Type::FunctionInterface());
   const Array& interfaces = Array::Handle(Array::New(1, Heap::kOld));
   interfaces.SetAt(0, function_interface);
   result.set_interfaces(interfaces);
   // Unless the signature function already has a signature class, create a
-  // canonical signature class by having the signature function point back to
+  // canonical signature class by having the signature function pointing back to
   // the signature class.
   if (signature_function.signature_class() == Object::null()) {
     signature_function.set_signature_class(result);
   }
-  // If the class finalizer is expecting more pending classes to finalize, it
-  // will add the signature class to the pending list in order to postpone
-  // finalization of the signature type.
-  const Type& signature_type = Type::Handle(result.SignatureType());
-  ASSERT(!signature_type.IsFinalized());
-  String& errmsg = String::Handle();
-  ClassFinalizer::FinalizeAndCanonicalizeType(signature_type, &errmsg);
-  ASSERT(errmsg.IsNull());
   return result.raw();
 }
 
 
 RawClass* Class::GetClass(ObjectKind kind) {
   ObjectStore* object_store = Isolate::Current()->object_store();
   switch (kind) {
     case kUnhandledException:
       ASSERT(object_store->unhandled_exception_class() != Class::null());
       return object_store->unhandled_exception_class();
@@ skipping 247 matching lines @@
 
 bool Class::IsTopLevel() const {
   return String::Handle(Name()).Length() == 0;
 }
 
 
 bool Class::TestType(TypeTestKind test,
                      const TypeArguments& type_arguments,
                      const Class& other,
                      const TypeArguments& other_type_arguments) const {
-  ASSERT(is_finalized());
-  ASSERT(other.is_finalized());
   if (test == kIsAssignableTo) {
     // The spec states that "a type T is assignable to a type S if T is a
     // subtype of S or S is a subtype of T". This is from the perspective of a
     // static checker, which does not know the actual type of the assigned
     // value. However, this type information is available at run time in checked
     // mode. We therefore apply a more restrictive subtype check, which prevents
     // heap pollution. We only keep the assignability check when assigning
     // values of a function type.
     if (IsSignatureClass() && other.IsSignatureClass()) {
       const Function& src_fun = Function::Handle(signature_function());
@@ skipping 454 matching lines @@
       (type_class() == Type::Handle(Type::FunctionInterface()).type_class());
 }
 
 
 bool Type::IsListInterface() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::ListInterface()).type_class());
 }
 
 
-bool Type::IsSignatureType() const {
-  return HasResolvedTypeClass() &&
-      Class::Handle(type_class()).IsSignatureClass();
-}
-
-
 bool Type::IsMoreSpecificThan(const Type& other) const {
   ASSERT(IsFinalized());
   ASSERT(other.IsFinalized());
   // Type parameters cannot be handled by Class::IsMoreSpecificThan().
   if (IsTypeParameter() || other.IsTypeParameter()) {
     return IsTypeParameter() && other.IsTypeParameter() &&
         (Index() == other.Index());
   }
   const Class& cls = Class::Handle(type_class());
   return cls.IsMoreSpecificThan(TypeArguments::Handle(arguments()),
@@ skipping 184 matching lines @@
     intptr_t offset) const {
   ASSERT(IsFinalized());
   ASSERT(!IsInstantiated());
   TypeArguments& type_arguments = TypeArguments::Handle();
   if (!instantiator_type_arguments.IsNull()) {
     type_arguments = arguments();
     type_arguments = type_arguments.InstantiateFrom(instantiator_type_arguments,
                                                     offset);
   }
   const Class& cls = Class::Handle(type_class());
-  ASSERT(cls.is_finalized());
   ParameterizedType& instantiated_type = ParameterizedType::Handle(
       ParameterizedType::New(cls, type_arguments));
   ASSERT(type_arguments.IsNull() ||
          (type_arguments.Length() == cls.NumTypeArguments()));
   instantiated_type.set_is_finalized();
   return instantiated_type.raw();
 }
 
 
 bool ParameterizedType::Equals(const Type& other) const {
@@ skipping 4937 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