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

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "vm/assert.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
@@ skipping 227 matching lines @@
     return exception_handlers_class_;
   }
   static RawClass* context_class() { return context_class_; }
   static RawClass* context_scope_class() { return context_scope_class_; }
   static RawClass* api_error_class() { return api_error_class_; }
 
   static int GetSingletonClassIndex(const RawClass* raw_class);
   static RawClass* GetSingletonClass(int index);
   static const char* GetSingletonClassName(int index);
 
+  static RawClass* CreateAndRegisterInterface(const char* cname,
+                                              const Script& script,
+                                              const Library& lib);
+  static void RegisterClass(const Class& cls,
+                            const char* cname,
+                            const Script& script,
+                            const Library& lib);
+
   static void Init(Isolate* isolate);
   static void InitFromSnapshot(Isolate* isolate);
   static void InitOnce();
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawObject));
   }
 
   static const ObjectKind kInstanceKind = kObject;
 
@@ skipping 145 matching lines @@
   RawType* SignatureType() const;
 
   RawLibrary* library() const { return raw_ptr()->library_; }
   void set_library(const Library& value) const;
 
   // The type parameters are specified as an array of Strings.
   RawArray* type_parameters() const { return raw_ptr()->type_parameters_; }
   void set_type_parameters(const Array& value) const;
   intptr_t NumTypeParameters() const;
 
-  // Type parameters may optionally extend a Type (DynamicType if no extends).
+  // Type parameters may optionally extend a Type (Dynamic if no extends).
+  // TODO(regis): Should it be Object instead of Dynamic?
   RawTypeArray* type_parameter_extends() const {
     return raw_ptr()->type_parameter_extends_;
   }
   void set_type_parameter_extends(const TypeArray& value) const;
 
   // Return a TypeParameter if the type_name is a type parameter of this class.
   // Return null otherwise.
   RawTypeParameter* LookupTypeParameter(const String& type_name) const;
 
+  // The type argument vector is flattened and includes the type arguments of
+  // the super class.
+  bool HasTypeArguments() const;
+  intptr_t NumTypeArguments() const;
+
   // If this class is parameterized, each instance has a type_arguments field.
-  intptr_t NumTypeArguments() const;
   static const intptr_t kNoTypeArguments = -1;
   intptr_t type_arguments_instance_field_offset() const {
     ASSERT(is_finalized() || is_prefinalized());
     return raw_ptr()->type_arguments_instance_field_offset_;
   }
   void set_type_arguments_instance_field_offset(intptr_t value) const {
     raw_ptr()->type_arguments_instance_field_offset_ = value;
   }
-  bool HasTypeArguments() const {
-    if (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);
-    }
-  }
 
   // The super type of this class, Object type if not explicitly specified.
   RawType* super_type() const { return raw_ptr()->super_type_; }
   void set_super_type(const Type& value) const;
 
   // Asserts that the class of the super type has been resolved.
   RawClass* SuperClass() const;
 
   // The factory type of this interface, null if not specified.
   RawType* factory_type() const { return raw_ptr()->factory_type_; }
@@ skipping 2551 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_