Address Regis' comments, replace AbstractType with Type where possible.

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 582 matching lines @@
   // 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(AbstractType::Handle());
+  cls.set_super_type(Type::Handle());
 
   ClassFinalizer::VerifyBootstrapClasses();
 }
 
 
 void Object::InitFromSnapshot(Isolate* isolate) {
   TIMERSCOPE(time_bootstrap);
   ObjectStore* object_store = isolate->object_store();
 
   Class& cls = Class::Handle();
@@ skipping 103 matching lines @@
 RawString* Class::Name() const {
   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));
 }
 
 
-RawAbstractType* Class::SignatureType() const {
+RawType* Class::SignatureType() const {
   // Return the first canonical signature type if already computed.
   const Array& signature_types = Array::Handle(canonical_types());
   if (signature_types.Length() > 0) {
-    AbstractType& signature_type = AbstractType::Handle();
+    Type& signature_type = Type::Handle();
     signature_type ^= signature_types.At(0);
     if (!signature_type.IsNull()) {
       return signature_type.raw();
     }
   }
   ASSERT(IsSignatureClass());
   TypeArguments& signature_type_arguments = TypeArguments::Handle();
   const intptr_t num_type_params = NumTypeParameters();
   // A signature class extends class Instance and is parameterized in the same
   // way as the owner class of its non-static signature function.
@@ skipping 152 matching lines @@
     // 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 AbstractType& sup_type = AbstractType::Handle(super_type());
+  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 AbstractType& value) const {
+void Class::set_super_type(const Type& value) const {
   StorePointer(&raw_ptr()->super_type_, value.raw());
 }
 
 
 bool Class::HasFactoryClass() const {
   const Object& factory_class = Object::Handle(raw_ptr()->factory_class_);
   return !factory_class.IsNull();
 }
 
 
@@ skipping 193 matching lines @@
   // Unless the signature function already has a signature class, create a
   // 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 AbstractType& signature_type =
-      AbstractType::Handle(result.SignatureType());
+  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();
@@ skipping 976 matching lines @@
   Type& other_parameterized_type = Type::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()));
 }
 
 
 RawAbstractType* Type::Canonicalize() const {

[regis, 2011/12/01 19:20:43]

I think this should be RawType*

[srdjan, 2011/12/01 20:04:09]

This is a virtual, implemented also in TypeParameter, i.e., the return type must
be the RawAbstractType

   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.
-  AbstractType& type = AbstractType::Handle();
+  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;
@@ skipping 1068 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 AbstractType& signature_type =
-      AbstractType::Handle(signature_class.SignatureType());
+  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();
 }
@@ skipping 4033 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