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

runtime/vm/class_finalizer.cc

Index: runtime/vm/class_finalizer.cc
===================================================================
--- runtime/vm/class_finalizer.cc	(revision 1988)
+++ runtime/vm/class_finalizer.cc	(working copy)
@@ -292,12 +292,12 @@
   if (cls.is_finalized()) {
     return;
   }
-  AbstractType& super_type = AbstractType::Handle(cls.super_type());
+  Type& super_type = Type::Handle(cls.super_type());
   if (super_type.IsNull()) {
     return;
   }
   // Resolve failures lead to a longjmp.
-  super_type = ResolveType(cls, super_type);
+  super_type ^= ResolveType(cls, super_type);
   if (super_type.IsTypeParameter()) {

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

Since super_type is now a Type, this test always fails.
This test can be safely removed, because we do not resolve types to
TypeParameter in the class finalizer anymore. See the TODO at function
ResolveType().

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

Removed code.
I think it is better if I implement the TODO for ResolveType, and remove the
result.

     String& class_name = String::Handle(cls.Name());
     String& type_parameter_name = String::Handle(super_type.Name());
@@ -505,9 +505,9 @@
 void ClassFinalizer::FinalizeTypeArguments(const Class& cls,
                                            const TypeArguments& arguments) {
   ASSERT(arguments.Length() >= cls.NumTypeArguments());
-  AbstractType& super_type = AbstractType::Handle(cls.super_type());
+  Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
-    super_type = FinalizeType(super_type);
+    super_type ^= FinalizeType(super_type);
     cls.set_super_type(super_type);
     const Class& super_class = Class::Handle(super_type.type_class());
     const TypeArguments& super_type_args =
@@ -568,7 +568,7 @@
       }
     }
   }
-  AbstractType& super_type = AbstractType::Handle(cls.super_type());
+  const Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     ASSERT(super_type.IsFinalized());
     const Class& super_class = Class::Handle(super_type.type_class());
@@ -1004,12 +1004,12 @@
   }
   GrowableArray<const Class*> visited;
   ResolveInterfaces(cls, &visited);
-  AbstractType& super_type = AbstractType::Handle(cls.super_type());
+  Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
     // Finalize super class and super type.
     FinalizeClass(super_class, generating_snapshot);
-    super_type = FinalizeType(super_type);
+    super_type ^= FinalizeType(super_type);
     cls.set_super_type(super_type);
   }
   if (cls.is_interface()) {