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

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 390 matching lines @@
   }
   static intptr_t signature_function_offset() {
     return OFFSET_OF(RawClass, signature_function_);
   }
 
   // Return the signature type of this signature class.
   // For example, if this class represents a signature of the form
   // '<T, R>(T, [b: B, c: C]) => R', then its signature type is a parameterized
   // type with this class as the type class and type parameters 'T' and 'R'
   // as its type argument vector.
-  RawAbstractType* SignatureType() const;
+  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 (Dynamic if no extends).
@@ skipping 16 matching lines @@
   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;
   }
 
   // The super type of this class, Object type if not explicitly specified.
-  RawAbstractType* super_type() const { return raw_ptr()->super_type_; }
-  void set_super_type(const AbstractType& value) const;
+  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;
 
   // Return true if this interface has a factory class.
   bool HasFactoryClass() const;
 
   // Return true if the factory class of this interface is resolved.
   bool HasResolvedFactoryClass() const;
 
   // Return the resolved factory class of this interface.
   RawClass* FactoryClass() const;
 
   // Return the unresolved factory class of this interface.
   RawUnresolvedClass* UnresolvedFactoryClass() const;
 
   // Set the resolved or unresolved factory class of this interface.
   void set_factory_class(const Object& value) const;
 
   // Interfaces is an array of Types.
+  // TODO(srdjan): Return TypeArguments instead of Array?
   RawArray* interfaces() const { return raw_ptr()->interfaces_; }
   void set_interfaces(const Array& value) const;
 
   RawArray* functions_cache() const { return raw_ptr()->functions_cache_; }
   void set_functions_cache(const Array& value) const;
 
   static intptr_t functions_cache_offset() {
     return OFFSET_OF(RawClass, functions_cache_);
   }
 
@@ skipping 2755 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_