Second attempt at finalizing all classes in the VM (fix issue 364).

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<ApiError>();
   api_error_class_ = cls.raw();
 
   ASSERT(class_class() != null_);
 }
 
 
+RawClass* Object::CreateAndRegisterInterface(const char* cname,
+                                             const Script& script,
+                                             const Library& lib) {
+  const String& name = String::Handle(String::NewSymbol(cname));
+  const Class& cls = Class::Handle(Class::NewInterface(name, script));
+  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));
+  cls.set_name(name);
+  cls.set_script(script);
+  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(isolate->object_store()->core_library());
+  Library& core_lib = Library::Handle(Library::CoreLibrary());
   ASSERT(!core_lib.IsNull());
   Library& core_impl_lib = Library::Handle(Library::CoreImplLibrary());
   ASSERT(!core_impl_lib.IsNull());
 
-  // 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 String class is initialized and the dictionary has been setup,
-  // add the names to preallocated classes and register them in the dictionary.
+  // 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.
   const Script& impl_script = Script::Handle(Bootstrap::LoadImplScript());
+  GrowableArray<const Class*> pending_classes;
 
-  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<Smi>();
+  object_store->set_smi_class(cls);
+  RegisterClass(cls, "Smi", 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<Mint>();
+  object_store->set_mint_class(cls);
+  RegisterClass(cls, "Mint", 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<Bigint>();
+  object_store->set_bigint_class(cls);
+  RegisterClass(cls, "Bigint", 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<Double>();
+  object_store->set_double_class(cls);
+  RegisterClass(cls, "Double", 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 = Class::New<Bool>();
+  object_store->set_bool_class(cls);
+  RegisterClass(cls, "Bool", 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 = object_store->array_class();  // Was allocated above.
+  RegisterClass(cls, "ObjectArray", impl_script, core_impl_lib);
+  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
 
-  name = String::NewSymbol("Double");
-  cls = object_store->double_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());
+  ASSERT(object_store->immutable_array_class() != object_store->array_class());
+  RegisterClass(cls, "ImmutableArray", impl_script, core_impl_lib);
+  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
 
-  name = String::NewSymbol("Bool");
-  cls = object_store->bool_class();
-  cls.set_name(name);
-  cls.set_script(impl_script);
-  core_impl_lib.AddClass(cls);
+  cls = object_store->one_byte_string_class();  // Was allocated above.
+  RegisterClass(cls, "OneByteString", impl_script, core_impl_lib);
+  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
 
-  name = String::NewSymbol("ObjectArray");
-  cls = object_store->array_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);
+  RegisterClass(cls, "TwoByteString", impl_script, core_impl_lib);
+  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
 
-  name = String::NewSymbol("ImmutableArray");
-  cls = object_store->immutable_array_class();
-  ASSERT(object_store->immutable_array_class() != object_store->array_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);
+  RegisterClass(cls, "FourByteString", 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<UnhandledException>();
+  object_store->set_unhandled_exception_class(cls);
+  RegisterClass(cls, "UnhandledException", 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<Stacktrace>();
+  object_store->set_stacktrace_class(cls);
+  RegisterClass(cls, "Stacktrace", impl_script, core_impl_lib);
+  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+  // Super type set below, after Object is allocated.
 
-  name = String::NewSymbol("JSSyntaxRegExp");
-  cls = object_store->jsregexp_class();
-  cls.set_name(name);
-  cls.set_script(impl_script);
-  core_impl_lib.AddClass(cls);
+  cls = Class::New<JSRegExp>();
+  object_store->set_jsregexp_class(cls);
+  RegisterClass(cls, "JSSyntaxRegExp", impl_script, core_impl_lib);
+  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
 
   // Initialize the base interfaces used by the core VM classes.
   const Script& script = Script::Handle(Bootstrap::LoadScript());
 
-  name = String::NewSymbol("Object");
-  cls = object_store->object_class();
-  cls.set_name(name);
+  // 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")));
   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);
 
-  name = String::NewSymbol("Function");
-  cls = Class::NewInterface(name, script);
-  core_lib.AddClass(cls);
+  // 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 = CreateAndRegisterInterface("Function", script, core_lib);
+  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
   type = Type::NewNonParameterizedType(cls);
   object_store->set_function_interface(type);
 
-  name = String::NewSymbol("num");
-  cls = Class::NewInterface(name, script);
-  core_lib.AddClass(cls);
+  cls = CreateAndRegisterInterface("num", script, core_lib);
+  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
   type = Type::NewNonParameterizedType(cls);
   object_store->set_number_interface(type);
 
-  name = String::NewSymbol("int");
-  cls = Class::NewInterface(name, script);
-  core_lib.AddClass(cls);
+  cls = CreateAndRegisterInterface("int", script, core_lib);
+  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
   type = Type::NewNonParameterizedType(cls);
   object_store->set_int_interface(type);
 
-  name = String::NewSymbol("double");
-  cls = Class::NewInterface(name, script);
-  core_lib.AddClass(cls);
+  cls = CreateAndRegisterInterface("double", script, core_lib);
+  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
   type = Type::NewNonParameterizedType(cls);
   object_store->set_double_interface(type);
 
-  name = String::NewSymbol("String");
-  cls = Class::NewInterface(name, script);
-  core_lib.AddClass(cls);
+  cls = CreateAndRegisterInterface("String", script, core_lib);
+  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
   type = Type::NewNonParameterizedType(cls);
   object_store->set_string_interface(type);
 
-  name = String::NewSymbol("bool");
-  cls = Class::NewInterface(name, script);
-  core_lib.AddClass(cls);
+  cls = CreateAndRegisterInterface("bool", script, core_lib);
+  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
   type = Type::NewNonParameterizedType(cls);
   object_store->set_bool_interface(type);
 
-  name = String::NewSymbol("List");
-  cls = Class::NewInterface(name, script);
-  core_lib.AddClass(cls);
+  cls = CreateAndRegisterInterface("List", script, core_lib);
+  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
   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);
 
-  // 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);
+  // Add the preallocated classes to the list of classes to be finalized.
+  ClassFinalizer::AddPendingClasses(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);
 
   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 99 matching lines @@
   if (raw_ptr()->name_ != String::null()) {
     return raw_ptr()->name_;
   }
   ASSERT(class_class() != null_);  // Or GetSingletonClassIndex will not work.
   intptr_t index = GetSingletonClassIndex(raw());
   return String::NewSymbol(GetSingletonClassName(index));
 }
 
 
 RawType* Class::SignatureType() const {
-  // Return the only canonical signature type if already computed.
+  // Return the first canonical signature type if already computed.
   const Array& signature_types = Array::Handle(canonical_types());
   if (signature_types.Length() > 0) {
     Type& signature_type = Type::Handle();
     signature_type ^= signature_types.At(0);
     if (!signature_type.IsNull()) {
-      // A signature class has a unique canonical signature type.
-      ASSERT((signature_types.Length() == 1) ||
-             signature_types.At(1) == Object::null());
       return signature_type.raw();
     }
   }
   ASSERT(IsSignatureClass());
   TypeArguments& signature_type_arguments = TypeArguments::Handle();
   const intptr_t num_type_params = NumTypeParameters();
-  // If the signature class extends a parameterized class, the type arguments of
-  // the super class will be prepended to the type argument vector during type
-  // finalization. We only need to provide the type parameters of the signature
-  // class here.
+  // A signature class extends class Instance and is parameterized in the same
+  // way as the owner class of its non-static signature function.
+  // It is not type parameterized if its signature function is static.
+  // See Class::NewSignatureClass() for the setup of its type parameters.
+  // During type finalization, the type arguments of the super class of the
+  // owner class of its signature function will be prepended to the type
+  // argument vector. Therefore, we only need to set the type arguments
+  // matching the type parameters here.
   if (num_type_params > 0) {
     const Array& type_params = Array::Handle(type_parameters());
     signature_type_arguments = TypeArguments::NewTypeArray(num_type_params);
     String& type_param_name = String::Handle();
     Type& type_param = Type::Handle();
     for (int i = 0; i < num_type_params; i++) {
       type_param_name ^= type_params.At(i);
       type_param = Type::NewTypeParameter(i, type_param_name);
       signature_type_arguments.SetTypeAt(i, type_param);
     }
@@ skipping 106 matching lines @@
     return 0;
   } else {
     return type_params.Length();
   }
 }
 
 
 intptr_t Class::NumTypeArguments() const {
   // To work properly, this call requires the super class of this class to be
   // resolved, which is checked by the SuperClass() call.
+  Class& cls = Class::Handle(raw());
+  if (IsSignatureClass()) {
+    const Function& signature_fun = Function::Handle(signature_function());
+    if (!signature_fun.is_static() &&
+        !signature_fun.HasInstantiatedSignature()) {
+      cls = signature_fun.owner();
+    }
+  }
   intptr_t num_type_args = NumTypeParameters();
-  const Class& superclass = Class::Handle(SuperClass());
+  const Class& superclass = Class::Handle(cls.SuperClass());
   // Object is its own super class during bootstrap.
   if (!superclass.IsNull() && (superclass.raw() != raw())) {
     num_type_args += superclass.NumTypeArguments();
   }
   return num_type_args;
 }
 
 
+bool Class::HasTypeArguments() const {
+  if (!IsSignatureClass() && (is_finalized() || is_prefinalized())) {
+    // More efficient than calling NumTypeArguments().
+    return type_arguments_instance_field_offset() != kNoTypeArguments;
+  } else {
+    // No need to check NumTypeArguments() if class has type parameters.
+    return (NumTypeParameters() > 0) || (NumTypeArguments() > 0);
+  }
+}
+
+
 RawClass* Class::SuperClass() const {
   const Type& sup_type = Type::Handle(super_type());
   if (sup_type.IsNull()) {
     return Class::null();
   }
   return sup_type.type_class();
 }
 
 
 void Class::set_super_type(const Type& value) const {
@@ skipping 145 matching lines @@
   Class& result = Class::Handle(New<Instance>(name, script));
   result.set_is_interface();
   return result.raw();
 }
 
 
 RawClass* Class::NewSignatureClass(const String& name,
                                    const Function& signature_function,
                                    const Script& script) {
   ASSERT(!signature_function.IsNull());
-  Type& super_type = Type::Handle(Type::ObjectType());
   const Class& owner_class = Class::Handle(signature_function.owner());
   ASSERT(!owner_class.IsNull());
   Array& type_parameters = Array::Handle();
   TypeArray& type_parameter_extends = TypeArray::Handle();
+  // A signature class extends class Instance and is parameterized in the same
+  // way as the owner class of its non-static signature function.
+  // It is not type parameterized if its signature function is static.
   if (!signature_function.is_static()) {
     if ((owner_class.NumTypeParameters() > 0) &&
         !signature_function.HasInstantiatedSignature()) {
-      // Share the function owner super class as the super class of the
-      // signature class, so that the type argument vector of the closure at
-      // run time  matches the type argument vector of the closure instantiator.
       type_parameters = owner_class.type_parameters();
       type_parameter_extends = owner_class.type_parameter_extends();
-      if (!owner_class.is_interface()) {
-        super_type = owner_class.super_type();
-      }
     }
   }
   Class& result = Class::Handle(New<Closure>(name, script));
+  const Type& super_type = Type::Handle(Type::ObjectType());
+  ASSERT(!super_type.IsNull());
   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 pointing back to
+  // canonical signature class by having the signature function point back to
   // the signature class.
   if (signature_function.signature_class() == Object::null()) {
     signature_function.set_signature_class(result);
   }
+  result.set_is_finalized();
+  // Instances of a signature class can only be closures.
+  ASSERT(result.instance_size() == Closure::InstanceSize());
+  // Cache the signature type as the first canonicalized type in result.
+  const Type& signature_type = Type::Handle(result.SignatureType());
+  ASSERT(!signature_type.IsFinalized());
+  const Array& new_canonical_types = Array::Handle(Array::New(1, Heap::kOld));
+  new_canonical_types.SetAt(0, signature_type);
+  result.set_canonical_types(new_canonical_types);
   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() || !ClassFinalizer::AllClassesFinalized());
+  ASSERT(other.is_finalized() || !ClassFinalizer::AllClassesFinalized());
   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 335 matching lines @@
   const intptr_t num_args = args.IsNull() ? 0 : args.Length();
   String& class_name = String::Handle();
   intptr_t first_type_param_index;
   intptr_t num_type_params;  // Number of type parameters to print.
   if (HasResolvedTypeClass()) {
     const Class& cls = Class::Handle(type_class());
     class_name = cls.Name();
     num_type_params = cls.NumTypeParameters();  // Do not print the full vector.
     if (num_type_params > num_args) {
       first_type_param_index = 0;
-      if (IsBeingFinalized()) {
+      if (!IsFinalized() || IsBeingFinalized()) {
         // Most probably an illformed type. Do not fill up with "Dynamic".
         num_type_params = num_args;
       } else {
         ASSERT(num_args == 0);  // Type is raw.
         // We fill up with "Dynamic".
       }
     } else {
       first_type_param_index = num_args - num_type_params;
     }
     if (cls.IsSignatureClass()) {
       // We may be reporting an error about an illformed function type. In that
       // case, avoid instantiating the signature, since it may lead to cycles.
-      if (IsBeingFinalized()) {
+      if (!IsFinalized() || IsBeingFinalized()) {
         return class_name.raw();
       }
       const Function& signature_function = Function::Handle(
           cls.signature_function());
       return signature_function.InstantiatedSignatureFrom(
           args, first_type_param_index);
     }
   } else {
     const UnresolvedClass& cls = UnresolvedClass::Handle(unresolved_class());
     class_name = cls.Name();
@@ skipping 282 matching lines @@
   const TypeArguments& args = TypeArguments::Handle(arguments());
   return args.IsNull() || args.IsInstantiated();
 }
 
 
 RawType* ParameterizedType::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     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);
-  }
+  TypeArguments& type_arguments = TypeArguments::Handle(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 {
   ASSERT(IsFinalized() && other.IsFinalized());
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsParameterizedType()) {
     return false;
   }
   ParameterizedType& other_parameterized_type = ParameterizedType::Handle();
   other_parameterized_type ^= other.raw();
   if (type_class() != other_parameterized_type.type_class()) {
     return false;
   }
   return TypeArguments::AreEqual(TypeArguments::Handle(arguments()),
                                  TypeArguments::Handle(other.arguments()));
 }
 
 
 RawType* ParameterizedType::Canonicalize() const {
+  ASSERT(IsFinalized());
   const Class& cls = Class::Handle(type_class());
   Array& canonical_types = Array::Handle(cls.canonical_types());
   if (canonical_types.IsNull()) {
     // Types defined in the VM isolate are canonicalized via the object store.
     // TODO(regis): Should we add null_class_, void_class_, dynamic_class_ to
     // the object store, remove all types from the object store, and replace
     // the test above by an assert?
     return this->raw();
   }
   const intptr_t canonical_types_len = canonical_types.Length();
   // Linear search to see whether this type is already present in the
   // list of canonicalized types.
   Type& type = Type::Handle();
   intptr_t index = 0;
   while (index < canonical_types_len) {
     type ^= canonical_types.At(index);
     if (type.IsNull()) {
       break;
     }
+    if (!type.IsFinalized()) {
+      ASSERT((index == 0) && cls.IsSignatureClass());
+      index++;
+      continue;
+    }
     if (this->Equals(type)) {
       return type.raw();
     }
     index++;
   }
   // The type needs to be added to the list. Grow the list if it is full.
   if (index == canonical_types_len) {
     const intptr_t kLengthIncrement = 2;  // Raw and parameterized.
     const intptr_t new_length = canonical_types.Length() + kLengthIncrement;
     const Array& new_canonical_types =
@@ skipping 363 matching lines @@
     }
   }
   return true;
 }
 
 
 RawTypeArguments* TypeArray::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
   ASSERT(!IsInstantiated());
-  if (instantiator_type_arguments.IsNull()) {
-    return TypeArguments::null();
-  }
   if ((offset == 0) &&
       !instantiator_type_arguments.IsNull() &&
       IsUninstantiatedIdentity() &&
       (instantiator_type_arguments.Length() == Length())) {
     return instantiator_type_arguments.raw();
   }
   const intptr_t num_types = Length();
   TypeArray& instantiated_array = TypeArray::Handle(TypeArray::New(num_types));
   Type& type = Type::Handle();
   for (intptr_t i = 0; i < num_types; i++) {
@@ skipping 669 matching lines @@
       library.LookupLocalClass(signature));
   if (signature_class.IsNull()) {
     const Script& script = Script::Handle(owner_class.script());
     signature_class = Class::NewSignatureClass(signature,
                                                closure_function,
                                                script);
     library.AddClass(signature_class);
   } else {
     closure_function.set_signature_class(signature_class);
   }
+  const Type& signature_type = Type::Handle(signature_class.SignatureType());
+  if (!signature_type.IsFinalized()) {
+    String& errmsg = String::Handle();
+    ClassFinalizer::FinalizeAndCanonicalizeType(signature_type, &errmsg);
+    ASSERT(errmsg.IsNull());
+  }
   ASSERT(closure_function.signature_class() == signature_class.raw());
   set_implicit_closure_function(closure_function);
   ASSERT(closure_function.IsImplicitClosureFunction());
   return closure_function.raw();
 }
 
 
 template<typename T>
 static RawArray* NewArray(const GrowableArray<T*>& objs) {
   Array& a = Array::Handle(Array::New(objs.length(), Heap::kOld));
@@ skipping 1706 matching lines @@
 
 RawType* Instance::GetType() const {
   if (IsNull()) {
     return Type::NullType();
   }
   const Class& cls = Class::Handle(clazz());
   TypeArguments& type_arguments = TypeArguments::Handle();
   if (cls.HasTypeArguments()) {
     type_arguments = GetTypeArguments();
   }
-  return Type::NewParameterizedType(cls, type_arguments);
+  const ParameterizedType& type = ParameterizedType::Handle(
+      ParameterizedType::New(cls, type_arguments));
+  type.set_is_finalized();
+  return type.raw();
 }
 
 
 RawTypeArguments* Instance::GetTypeArguments() const {
   const Class& cls = Class::Handle(clazz());
   intptr_t field_offset = cls.type_arguments_instance_field_offset();
   ASSERT(field_offset != Class::kNoTypeArguments);
   TypeArguments& type_arguments = TypeArguments::Handle();
   type_arguments ^= *FieldAddrAtOffset(field_offset);
   return type_arguments.raw();
@@ skipping 2104 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