Use VM type cast and save handles.

runtime/vm/class_finalizer.cc

 // Copyright (c) 2012, 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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 478 matching lines @@
     // that the type parameter appeared in a static scope. Leaving the type as
     // unresolved is the correct thing to do.
 
     // Lookup the type class.
     const UnresolvedClass& unresolved_class =
         UnresolvedClass::Handle(type.unresolved_class());
     const Class& type_class =
         Class::Handle(ResolveClass(cls, unresolved_class));
 
     // Replace unresolved class with resolved type class.
-    ASSERT(type.IsType());
-    Type& parameterized_type = Type::Handle();
-    parameterized_type ^= type.raw();
+    const Type& parameterized_type = Type::Cast(type);
     if (!type_class.IsNull()) {
       parameterized_type.set_type_class(Object::Handle(type_class.raw()));
     } else {
       // The type class could not be resolved. The type is malformed.
       FinalizeMalformedType(Error::Handle(),  // No previous error.
                             cls, parameterized_type, finalization,
                             "cannot resolve class name '%s' from '%s'",
                             String::Handle(unresolved_class.Name()).ToCString(),
                             String::Handle(cls.Name()).ToCString());
       return;
@@ skipping 105 matching lines @@
     return type.raw();
   }
   ASSERT(type.IsResolved());
   ASSERT((finalization == kFinalize) || (finalization == kFinalizeWellFormed));
 
   if (FLAG_trace_type_finalization) {
     OS::Print("Finalize type '%s'\n", String::Handle(type.Name()).ToCString());
   }
 
   if (type.IsTypeParameter()) {
-    TypeParameter& type_parameter = TypeParameter::Handle();
-    type_parameter ^= type.raw();
+    const TypeParameter& type_parameter = TypeParameter::Cast(type);
     const Class& parameterized_class =
         Class::Handle(type_parameter.parameterized_class());
     ASSERT(!parameterized_class.IsNull());
     // The index must reflect the position of this type parameter in the type
     // arguments vector of its parameterized class. The offset to add is the
     // number of type arguments in the super type, which is equal to the
     // difference in number of type arguments and type parameters of the
     // parameterized class.
     const intptr_t offset = parameterized_class.NumTypeArguments() -
                             parameterized_class.NumTypeParameters();
     type_parameter.set_index(type_parameter.index() + offset);
     type_parameter.set_is_finalized();
     // We do not canonicalize type parameters.
     return type_parameter.raw();
   }
 
   // At this point, we can only have a parameterized_type.
-  Type& parameterized_type = Type::Handle();
-  parameterized_type ^= type.raw();
+  const Type& parameterized_type = Type::Cast(type);
 
   if (parameterized_type.IsBeingFinalized()) {
     // Self reference detected. The type is malformed.
     FinalizeMalformedType(
         Error::Handle(),  // No previous error.
         cls, parameterized_type, finalization,
         "type '%s' illegally refers to itself",
         String::Handle(parameterized_type.Name()).ToCString());
     return parameterized_type.raw();
   }
@@ skipping 843 matching lines @@
 void ClassFinalizer::ReportError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
   va_end(args);
   ReportError(error);
 }
 
 }  // namespace dart