Use VM type cast and save handles.

runtime/vm/exceptions.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/exceptions.h"
 
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/flags.h"
 #include "vm/object.h"
@@ skipping 306 matching lines @@
 }
 
 
 void Exceptions::ReThrow(const Instance& exception,
                          const Instance& stacktrace) {
   // Null object is a valid exception object.
   ThrowExceptionHelper(exception, stacktrace);
 }
 
 
-void Exceptions::PropagateError(const Object& obj) {
+void Exceptions::PropagateError(const Error& error) {
   ASSERT(Isolate::Current()->top_exit_frame_info() != 0);
-  Error& error = Error::Handle();
-  error ^= obj.raw();
   if (error.IsUnhandledException()) {
     // If the error object represents an unhandled exception, then
     // rethrow the exception in the normal fashion.
-    UnhandledException& uhe = UnhandledException::Handle();
-    uhe ^= error.raw();
+    const UnhandledException& uhe = UnhandledException::Cast(error);
     const Instance& exc = Instance::Handle(uhe.exception());
     const Instance& stk = Instance::Handle(uhe.stacktrace());
     Exceptions::ReThrow(exc, stk);
   } else {
     // Return to the invocation stub and return this error object.  The
     // C++ code which invoked this dart sequence can check and do the
     // appropriate thing.
     uword handler_pc = 0;
     uword handler_sp = 0;
     uword handler_fp = 0;
     FindErrorHandler(&handler_pc, &handler_sp, &handler_fp);
     JumpToErrorHandler(handler_pc, handler_sp, handler_fp, error);
   }
   UNREACHABLE();
 }
 
 
 void Exceptions::ThrowByType(
     ExceptionType type, const GrowableArray<const Object*>& arguments) {
   const Object& result = Object::Handle(Create(type, arguments));
   if (result.IsError()) {
     // We got an error while constructing the exception object.
     // Propagate the error instead of throwing the exception.
-    Error& error = Error::Handle();
-    error ^= result.raw();
-    PropagateError(error);
+    PropagateError(Error::Cast(result));
   } else {
     ASSERT(result.IsInstance());
-    Instance& exception = Instance::Handle();
-    exception ^= result.raw();
-    Throw(exception);
+    Throw(Instance::Cast(result));
   }
 }
 
 
 RawObject* Exceptions::Create(
     ExceptionType type, const GrowableArray<const Object*>& arguments) {
   Library& library = Library::Handle();
   String& class_name = String::Handle();
   switch (type) {
     case kIndexOutOfRange:
@@ skipping 47 matching lines @@
     case kIsolateSpawn:
       library = Library::IsolateLibrary();
       class_name = String::NewSymbol("IsolateSpawnException");
       break;
   }
 
   return DartLibraryCalls::ExceptionCreate(library, class_name, arguments);
 }
 
 }  // namespace dart