Use VM type cast and save handles.

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 359 matching lines @@
   if (!type_class.HasTypeArguments()) {
     return true;
   }
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(instance.GetTypeArguments());
   if (type_arguments.IsNull()) {
     return true;
   }
   if (type_arguments.IsInstantiatedTypeArguments()) {
     do {
-      InstantiatedTypeArguments& instantiated_type_arguments =
-          InstantiatedTypeArguments::Handle();
-      instantiated_type_arguments ^= type_arguments.raw();
+      const InstantiatedTypeArguments& instantiated_type_arguments =
+          InstantiatedTypeArguments::Cast(type_arguments);
       const AbstractTypeArguments& uninstantiated =
           AbstractTypeArguments::Handle(
               instantiated_type_arguments.uninstantiated_type_arguments());
       const AbstractTypeArguments& instantiator =
           AbstractTypeArguments::Handle(
               instantiated_type_arguments.instantiator_type_arguments());
       type_arguments = uninstantiated.InstantiateFrom(instantiator);
     } while (type_arguments.IsInstantiatedTypeArguments());
-    TypeArguments& new_type_arguments = TypeArguments::Handle();
-    new_type_arguments ^= type_arguments.raw();
-    new_type_arguments ^= new_type_arguments.Canonicalize();
+    AbstractTypeArguments& new_type_arguments = AbstractTypeArguments::Handle();
+    new_type_arguments = type_arguments.Canonicalize();
     instance.SetTypeArguments(new_type_arguments);
     *type_arguments_replaced = true;
   } else if (!type_arguments.IsCanonical()) {
-    AbstractTypeArguments& new_type_arguments =
-        AbstractTypeArguments::Handle();
-    new_type_arguments ^= type_arguments.Canonicalize();
+    AbstractTypeArguments& new_type_arguments = AbstractTypeArguments::Handle();
+    new_type_arguments = type_arguments.Canonicalize();
     instance.SetTypeArguments(new_type_arguments);
     *type_arguments_replaced = true;
   }
   ASSERT(AbstractTypeArguments::Handle(
       instance.GetTypeArguments()).IsTypeArguments());
   return true;
 }
 
 
 // This updates the type test cache, an array containing 4-value elements
@@ skipping 41 matching lines @@
       if (FLAG_trace_type_checks) {
         PrintTypeCheck("WARNING: Cannot canonicalize instantiator "
             "type arguments",
             instance, type, instantiator_type_arguments, result);
       }
       return;
     }
     if (replaced) {
       type_arguments_replaced = true;
     }
-    instantiator_type_arguments ^= instantiator.GetTypeArguments();
+    instantiator_type_arguments = instantiator.GetTypeArguments();
   }
 
   Class& last_instance_class = Class::Handle();
   AbstractTypeArguments& last_instance_type_arguments =
       AbstractTypeArguments::Handle();
   AbstractTypeArguments& last_instantiator_type_arguments =
       AbstractTypeArguments::Handle();
   Bool& last_result = Bool::Handle();
   intptr_t len = new_cache.NumberOfChecks();
   for (intptr_t i = 0; i < len; ++i) {
@@ skipping 310 matching lines @@
                                         num_named_arguments);
     return function.CurrentCode();
   }
 }
 
 
 // Result of an invoke may be an unhandled exception, in which case we
 // rethrow it.
 static void CheckResultError(const Object& result) {
   if (result.IsError()) {
-    Exceptions::PropagateError(result);
+    Exceptions::PropagateError(Error::Cast(result));
   }
 }
 
 
 // Resolves an instance function and compiles it if necessary.
 //   Arg0: receiver object.
 //   Returns: RawCode object or NULL (method not found or not compileable).
 // This is called by the megamorphic stub when instance call does not need to be
 // patched.
 // Used by megamorphic lookup/no-such-method-handling.
@@ skipping 195 matching lines @@
   const ICData& ic_data = ICData::CheckedHandle(arguments.At(1));
   const String& original_function_name = String::Handle(ic_data.target_name());
   const String& getter_prefix = String::Handle(String::New("get:"));
   Closure& closure = Closure::Handle();
   if (!original_function_name.StartsWith(getter_prefix)) {
     // This is not a getter so can't be the case where we are trying to
     // create an implicit closure of an instance function.
     arguments.SetReturn(closure);
     return;
   }
-  Class& receiver_class = Class::Handle();
-  receiver_class ^= receiver.clazz();
+  const Class& receiver_class = Class::Handle(receiver.clazz());
   ASSERT(!receiver_class.IsNull());
   String& func_name = String::Handle();
   func_name = String::SubString(original_function_name, getter_prefix.Length());
   func_name = String::NewSymbol(func_name);
   const Function& function = Function::Handle(
       LookupDynamicFunction(isolate, receiver_class, func_name));
   if (function.IsNull()) {
     // There is no function of the same name so can't be the case where
     // we are trying to create an implicit closure of an instance function.
     arguments.SetReturn(closure);
@@ skipping 47 matching lines @@
       Object::Handle(DartEntry::InvokeDynamic(receiver,
                                               function,
                                               invoke_arguments,
                                               kNoArgumentNames));
   if (result.IsError()) {
     if (result.IsUnhandledException()) {
       // If the getter throws an exception, treat as no such method.
       arguments.SetReturn(code);
       return;
     } else {
-      Exceptions::PropagateError(result);
+      Exceptions::PropagateError(Error::Cast(result));
     }
   }
   if (!result.IsSmi()) {
     const Class& cls = Class::Handle(result.clazz());
     ASSERT(!cls.IsNull());
     function = cls.signature_function();
     if (!function.IsNull()) {
       arguments.SetReturn(result);
       return;  // Return closure object.
     }
@@ skipping 446 matching lines @@
 
 
 // Adds a pointer to the store buffer.
 // ptr: the address of a field being stored into.
 DEFINE_LEAF_RUNTIME_ENTRY(void, StoreBuffer, uword ptr) {
   Isolate::Current()->store_buffer()->AddPointer(ptr);
 }
 END_LEAF_RUNTIME_ENTRY
 
 }  // namespace dart