Use VM type cast and save handles.

runtime/vm/dart_api_impl.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 "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 24 matching lines @@
 ThreadLocalKey Api::api_native_key_ = Thread::kUnsetThreadLocalKey;
 
 const char* CanonicalFunction(const char* func) {
   if (strncmp(func, "dart::", 6) == 0) {
     return func + 6;
   } else {
     return func;
   }
 }
 
-#define RETURN_TYPE_ERROR(isolate, dart_handle, Type)                   \
-  do {                                                                  \
-    const Object& tmp =                                                 \
-        Object::Handle(isolate, Api::UnwrapHandle((dart_handle)));      \
-    if (tmp.IsNull()) {                                                 \
-      return Api::NewError("%s expects argument '%s' to be non-null.",  \
-                           CURRENT_FUNC, #dart_handle);                 \
-    } else if (tmp.IsError()) {                                         \
-      return dart_handle;                                               \
-    } else {                                                            \
-      return Api::NewError("%s expects argument '%s' to be of type %s.", \
-                           CURRENT_FUNC, #dart_handle, #Type);          \
-    }                                                                   \
+#define RETURN_TYPE_ERROR(isolate, dart_handle, type)                          \
+  do {                                                                         \
+    const Object& tmp =                                                        \
+        Object::Handle(isolate, Api::UnwrapHandle((dart_handle)));             \
+    if (tmp.IsNull()) {                                                        \
+      return Api::NewError("%s expects argument '%s' to be non-null.",         \
+                           CURRENT_FUNC, #dart_handle);                        \
+    } else if (tmp.IsError()) {                                                \
+      return dart_handle;                                                      \
+    } else {                                                                   \
+      return Api::NewError("%s expects argument '%s' to be of type %s.",       \
+                           CURRENT_FUNC, #dart_handle, #type);                 \
+    }                                                                          \
   } while (0)
 
 
 // Return error if isolate is in an inconsistent state.
 // Return NULL when no error condition exists.
 //
 // TODO(turnidge): Make this function return an error handle directly
 // rather than returning an error string.  The current behavior can
 // cause compilation errors to appear to be api errors.
 const char* CheckIsolateState(Isolate* isolate, bool generating_snapshot) {
@@ skipping 49 matching lines @@
          state->IsValidWeakPersistentHandle(object) ||
          state->IsValidPersistentHandle(object) ||
          state->IsValidLocalHandle(object));
   ASSERT(FinalizablePersistentHandle::raw_offset() == 0 &&
          PersistentHandle::raw_offset() == 0 &&
          LocalHandle::raw_offset() == 0);
 #endif
   return *(reinterpret_cast<RawObject**>(object));
 }
 
-#define DEFINE_UNWRAP(Type)                                             \
-  const Type& Api::Unwrap##Type##Handle(Isolate* iso,                   \
-                                        Dart_Handle dart_handle) {      \
-    const Object& tmp = Object::Handle(iso, Api::UnwrapHandle(dart_handle)); \
-    Type& typed_handle = Type::Handle(iso);                             \
-    if (tmp.Is##Type()) {                                               \
-      typed_handle ^= tmp.raw();                                        \
-    }                                                                   \
-    return typed_handle;                                                \
+#define DEFINE_UNWRAP(type)                                                    \
+  const type& Api::Unwrap##type##Handle(Isolate* iso,                          \
+                                        Dart_Handle dart_handle) {             \
+    const Object& obj = Object::Handle(iso, Api::UnwrapHandle(dart_handle));   \
+    if (obj.Is##type()) {                                                      \
+      return type::Cast(obj);                                                  \
+    }                                                                          \
+    return type::Handle(iso);                                                  \
   }
 CLASS_LIST_NO_OBJECT(DEFINE_UNWRAP)
 #undef DEFINE_UNWRAP
 
 
 LocalHandle* Api::UnwrapAsLocalHandle(const ApiState& state,
                                       Dart_Handle object) {
   ASSERT(state.IsValidLocalHandle(object));
   return reinterpret_cast<LocalHandle*>(object);
 }
@@ skipping 139 matching lines @@
 DART_EXPORT bool Dart_IsFatalError(Dart_Handle object) {
   return Api::ClassId(object) == kUnwindError;
 }
 
 
 DART_EXPORT const char* Dart_GetError(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
   if (obj.IsError()) {
-    Error& error = Error::Handle(isolate);
-    error ^= obj.raw();
+    const Error& error = Error::Cast(obj);
     const char* str = error.ToErrorCString();
     intptr_t len = strlen(str) + 1;
     char* str_copy = reinterpret_cast<char*>(Api::Allocate(isolate, len));
     strncpy(str_copy, str, len);
     // Strip a possible trailing '\n'.
     if ((len > 1) && (str_copy[len - 2] == '\n')) {
       str_copy[len - 2] = '\0';
     }
     return str_copy;
   } else {
     return "";
   }
 }
 
 
 DART_EXPORT bool Dart_ErrorHasException(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
   return obj.IsUnhandledException();
 }
 
 
 DART_EXPORT Dart_Handle Dart_ErrorGetException(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
   if (obj.IsUnhandledException()) {
-    UnhandledException& error = UnhandledException::Handle(isolate);
-    error ^= obj.raw();
+    const UnhandledException& error = UnhandledException::Cast(obj);
     return Api::NewHandle(isolate, error.exception());
   } else if (obj.IsError()) {
     return Api::NewError("This error is not an unhandled exception error.");
   } else {
     return Api::NewError("Can only get exceptions from error handles.");
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_ErrorGetStacktrace(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
   if (obj.IsUnhandledException()) {
-    UnhandledException& error = UnhandledException::Handle(isolate);
-    error ^= obj.raw();
+    const UnhandledException& error = UnhandledException::Cast(obj);
     return Api::NewHandle(isolate, error.stacktrace());
   } else if (obj.IsError()) {
     return Api::NewError("This error is not an unhandled exception error.");
   } else {
     return Api::NewError("Can only get stacktraces from error handles.");
   }
 }
 
 
 // Deprecated.
@@ skipping 48 matching lines @@
     RETURN_TYPE_ERROR(isolate, exception, Instance);
   }
   const Instance& stacktrace = Instance::Handle(isolate);
   return Api::NewHandle(isolate, UnhandledException::New(obj, stacktrace));
 }
 
 
 DART_EXPORT Dart_Handle Dart_PropagateError(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
-  const Object& error = Object::Handle(isolate, Api::UnwrapHandle(handle));
-  if (!error.IsError()) {
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
+  if (!obj.IsError()) {
     return Api::NewError(
         "%s expects argument 'handle' to be an error handle.  "
         "Did you forget to check Dart_IsError first?",
         CURRENT_FUNC);
   }
   if (isolate->top_exit_frame_info() == 0) {
     // There are no dart frames on the stack so it would be illegal to
     // propagate an error here.
     return Api::NewError("No Dart frames on stack, cannot propagate error.");
   }
 
   // Unwind all the API scopes till the exit frame before propagating.
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   state->UnwindScopes(isolate->top_exit_frame_info());
-  Exceptions::PropagateError(error);
+  Exceptions::PropagateError(Error::Cast(obj));
   UNREACHABLE();
 
   return Api::NewError("Cannot reach here.  Internal error.");
 }
 
 
 DART_EXPORT void _Dart_ReportErrorHandle(const char* file,
                                          int line,
                                          const char* handle,
                                          const char* message) {
   fprintf(stderr, "%s:%d: error handle: '%s':\n    '%s'\n",
           file, line, handle, message);
   OS::Abort();
 }
 
 
 DART_EXPORT Dart_Handle Dart_ToString(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
   if (obj.IsString()) {
     return Api::NewHandle(isolate, obj.raw());
   } else if (obj.IsInstance()) {
-    Instance& receiver = Instance::Handle(isolate);
-    receiver ^= obj.raw();
+    const Instance& receiver = Instance::Cast(obj);
     return Api::NewHandle(isolate, DartLibraryCalls::ToString(receiver));
   } else {
     // This is a VM internal object. Call the C++ method of printing.
     return Api::NewHandle(isolate, String::New(obj.ToCString()));
   }
 }
 
 
 DART_EXPORT bool Dart_IdentityEquals(Dart_Handle obj1, Dart_Handle obj2) {
   Isolate* isolate = Isolate::Current();
@@ skipping 673 matching lines @@
                                           bool* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Instance& expected =
       Instance::CheckedHandle(isolate, Api::UnwrapHandle(obj1));
   const Instance& actual =
       Instance::CheckedHandle(isolate, Api::UnwrapHandle(obj2));
   const Object& result =
       Object::Handle(isolate, DartLibraryCalls::Equals(expected, actual));
   if (result.IsBool()) {
-    Bool& b = Bool::Handle(isolate);
-    b ^= result.raw();
-    *value = b.value();
+    *value = Bool::Cast(result).value();
     return Api::Success(isolate);
   } else if (result.IsError()) {
     return Api::NewHandle(isolate, result.raw());
   } else {
     return Api::NewError("Expected boolean result from ==");
   }
 }
 
 
 // TODO(iposva): This call actually implements IsInstanceOfClass.
@@ skipping 10 matching lines @@
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
   if (obj.IsError()) {
     return object;
   } else if (!obj.IsNull() && !obj.IsInstance()) {
     return Api::NewError(
         "%s expects argument 'object' to be an instance of Object.",
         CURRENT_FUNC);
   }
-
-  Instance& instance = Instance::Handle(isolate);
-  instance ^= obj.raw();
   // Finalize all classes.
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::NewError(msg);
   }
-  const Type& type = Type::Handle(isolate, Type::NewNonParameterizedType(cls));
-  Error& malformed_type_error = Error::Handle(isolate);
-  *value = instance.IsInstanceOf(
-      type, TypeArguments::Handle(isolate), &malformed_type_error);
-  ASSERT(malformed_type_error.IsNull());  // Type was created here from a class.
+  if (obj.IsInstance()) {
+    const Type& type = Type::Handle(isolate,
+                                    Type::NewNonParameterizedType(cls));
+    Error& malformed_type_error = Error::Handle(isolate);
+    *value = Instance::Cast(obj).IsInstanceOf(type,
+                                              TypeArguments::Handle(isolate),
+                                              &malformed_type_error);
+    ASSERT(malformed_type_error.IsNull());  // Type was created from a class.
+  } else {
+    *value = false;
+  }
   return Api::Success(isolate);
 }
 
 
 // --- Instances ----
 
 
 DART_EXPORT bool Dart_IsInstance(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
@@ skipping 39 matching lines @@
   if (class_id == kSmi || class_id == kMint) {
     *fits = true;
     return Api::Success(isolate);
   }
 
   DARTSCOPE_NOCHECKS(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
-  ASSERT(int_obj.IsBigint());
-#if defined(DEBUG)
-  Bigint& bigint = Bigint::Handle(isolate);
-  bigint ^= int_obj.raw();
-  ASSERT(!BigintOperations::FitsIntoMint(bigint));
-#endif
+  ASSERT(!BigintOperations::FitsIntoMint(Bigint::Cast(int_obj)));
   *fits = false;
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerFitsIntoUint64(Dart_Handle integer,
                                                    bool* fits) {
   // Fast path for Smis.
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   if (Api::IsSmi(integer)) {
     *fits = (Api::SmiValue(integer) >= 0);
     return Api::Success(isolate);
   }
 
   DARTSCOPE_NOCHECKS(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   if (int_obj.IsSmi() || int_obj.IsMint()) {
     *fits = !int_obj.IsNegative();
   } else {
-    ASSERT(int_obj.IsBigint());
-    Bigint& bigint = Bigint::Handle(isolate);
-    bigint ^= int_obj.raw();
-    *fits = BigintOperations::FitsIntoUint64(bigint);
+    *fits = BigintOperations::FitsIntoUint64(Bigint::Cast(int_obj));
   }
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewInteger(int64_t value) {
   // Fast path for Smis.
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   if (Smi::IsValid64(value)) {
@@ skipping 26 matching lines @@
 
   DARTSCOPE_NOCHECKS(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   if (int_obj.IsSmi() || int_obj.IsMint()) {
     *value = int_obj.AsInt64Value();
     return Api::Success(isolate);
   } else {
-    ASSERT(int_obj.IsBigint());
-    Bigint& bigint = Bigint::Handle(isolate);
-    bigint ^= int_obj.raw();
+    const Bigint& bigint = Bigint::Cast(int_obj);
     if (BigintOperations::FitsIntoMint(bigint)) {
       *value = BigintOperations::ToMint(bigint);
       return Api::Success(isolate);
     }
   }
   return Api::NewError("%s: Integer %s cannot be represented as an int64_t.",
                        CURRENT_FUNC, int_obj.ToCString());
 }
 
 
@@ skipping 14 matching lines @@
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   if (int_obj.IsSmi() || int_obj.IsMint()) {
     if (!int_obj.IsNegative()) {
       *value = int_obj.AsInt64Value();
       return Api::Success(isolate);
     }
   } else {
-    ASSERT(int_obj.IsBigint());
-    Bigint& bigint = Bigint::Handle(isolate);
-    bigint ^= int_obj.raw();
+    const Bigint& bigint = Bigint::Cast(int_obj);
     if (BigintOperations::FitsIntoUint64(bigint)) {
       *value = BigintOperations::ToUint64(bigint);
       return Api::Success(isolate);
     }
   }
   return Api::NewError("%s: Integer %s cannot be represented as a uint64_t.",
                        CURRENT_FUNC, int_obj.ToCString());
 }
 
 
 static uword ApiAllocate(intptr_t size) {
   return Api::Allocate(Isolate::Current(), size);
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerToHexCString(Dart_Handle integer,
                                                  const char** value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
-  Bigint& bigint = Bigint::Handle(isolate);
   if (int_obj.IsSmi() || int_obj.IsMint()) {
-    bigint ^= BigintOperations::NewFromInt64(int_obj.AsInt64Value());
+    const Bigint& bigint = Bigint::Handle(isolate,
+        BigintOperations::NewFromInt64(int_obj.AsInt64Value()));
     *value = BigintOperations::ToHexCString(bigint, ApiAllocate);
   } else {
-    ASSERT(int_obj.IsBigint());
-    bigint ^= int_obj.raw();
-    *value = BigintOperations::ToHexCString(bigint, ApiAllocate);
+    *value = BigintOperations::ToHexCString(Bigint::Cast(int_obj), ApiAllocate);
   }
   return Api::Success(isolate);
 }
 
 
 // --- Booleans ----
 
 
 DART_EXPORT Dart_Handle Dart_True() {
   Isolate* isolate = Isolate::Current();
@@ skipping 324 matching lines @@
   *bytes = result;
   return Api::Success(isolate);
 }
 
 
 // --- Lists ---
 
 
 static RawInstance* GetListInstance(Isolate* isolate, const Object& obj) {
   if (obj.IsInstance()) {
-    Instance& instance = Instance::Handle(isolate);
-    instance ^= obj.raw();
+    const Instance& instance = Instance::Cast(obj);
     const Type& type =
         Type::Handle(isolate, isolate->object_store()->list_interface());
     Error& malformed_type_error = Error::Handle(isolate);
     if (instance.IsInstanceOf(type,
                               TypeArguments::Handle(isolate),
                               &malformed_type_error)) {
       ASSERT(malformed_type_error.IsNull());  // Type is a raw List.
       return instance.raw();
     }
   }
@@ skipping 57 matching lines @@
   if (function.IsNull()) {
     return Api::NewError("List object does not have a 'length' field.");
   }
 
   GrowableArray<const Object*> args(0);
   const Array& kNoArgumentNames = Array::Handle(isolate);
   const Object& retval = Object::Handle(
       isolate,
       DartEntry::InvokeDynamic(instance, function, args, kNoArgumentNames));
   if (retval.IsSmi() || retval.IsMint()) {
-    Integer& integer = Integer::Handle(isolate);
-    integer ^= retval.raw();
-    *len = integer.AsInt64Value();
+    *len = Integer::Cast(retval).AsInt64Value();
     return Api::Success(isolate);
   } else if (retval.IsBigint()) {
-    Bigint& bigint = Bigint::Handle(isolate);
-    bigint ^= retval.raw();
+    const Bigint& bigint = Bigint::Cast(retval);
     if (BigintOperations::FitsIntoMint(bigint)) {
       *len = BigintOperations::ToMint(bigint);
       return Api::Success(isolate);
     } else {
       return Api::NewError("Length of List object is greater than the "
                            "maximum value that 'len' parameter can hold");
     }
   } else if (retval.IsError()) {
     return Api::NewHandle(isolate, retval.raw());
   } else {
     return Api::NewError("Length of List object is not an integer");
   }
 }
 
 
 #define GET_LIST_ELEMENT(isolate, type, obj, index)                            \
-  type& array_obj = type::Handle(isolate);                                     \
-  array_obj ^= obj.raw();                                                      \
+  const type& array_obj = type::Cast(obj);                                     \
   if ((index >= 0) && (index < array_obj.Length())) {                          \
     return Api::NewHandle(isolate, array_obj.At(index));                       \
   }                                                                            \
   return Api::NewError("Invalid index passed in to access list element");      \
 
 
 DART_EXPORT Dart_Handle Dart_ListGetAt(Dart_Handle list, intptr_t index) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
@@ skipping 20 matching lines @@
       return Api::NewHandle(
           isolate,
           DartEntry::InvokeDynamic(instance, function, args, kNoArgumentNames));
     }
   }
   return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 #define SET_LIST_ELEMENT(isolate, type, obj, index, value)                     \
-  type& array = type::Handle(isolate);                                         \
-  array ^= obj.raw();                                                          \
+  const type& array = type::Cast(obj);                                         \
   const Object& value_obj = Object::Handle(isolate, Api::UnwrapHandle(value)); \
   if ((index >= 0) && (index < array.Length())) {                              \
     array.SetAt(index, value_obj);                                             \
     return Api::Success(isolate);                                              \
   }                                                                            \
   return Api::NewError("Invalid index passed in to set list element");         \
 
 
 DART_EXPORT Dart_Handle Dart_ListSetAt(Dart_Handle list,
                                        intptr_t index,
@@ skipping 31 matching lines @@
           DartEntry::InvokeDynamic(instance, function, args, kNoArgumentNames));
     }
   }
   return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 // TODO(hpayer): value should always be smaller then 0xff. Add error handling.
 #define GET_LIST_ELEMENT_AS_BYTES(isolate, type, obj, native_array, offset,    \
                                    length)                                     \
-  type& array = type::Handle(isolate);                                         \
-  array ^= obj.raw();                                                          \
+  const type& array = type::Cast(obj);                                         \
   if (Utils::RangeCheck(offset, length, array.Length())) {                     \
     Object& element = Object::Handle(isolate);                                 \
-    Integer& integer  = Integer::Handle(isolate);                              \
     for (int i = 0; i < length; i++) {                                         \
       element = array.At(offset + i);                                          \
       if (!element.IsInteger()) {                                              \
         return Api::NewError("%s expects the argument 'list' to be "           \
                              "a List of int", CURRENT_FUNC);                   \
       }                                                                        \
-      integer ^= element.raw();                                                \
+      const Integer& integer = Integer::Cast(element);                         \
       native_array[i] = static_cast<uint8_t>(integer.AsInt64Value() & 0xff);   \
       ASSERT(integer.AsInt64Value() <= 0xff);                                  \
     }                                                                          \
     return Api::Success(isolate);                                              \
   }                                                                            \
   return Api::NewError("Invalid length passed in to access array elements");   \
 
 
 DART_EXPORT Dart_Handle Dart_ListGetAsBytes(Dart_Handle list,
                                             intptr_t offset,
                                             uint8_t* native_array,
                                             intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
   if (obj.IsUint8Array() || obj.IsExternalUint8Array()) {
-    ByteArray& byte_array = ByteArray::Handle(isolate);
-    byte_array ^= obj.raw();
+    const ByteArray& byte_array = ByteArray::Cast(obj);
     if (Utils::RangeCheck(offset, length, byte_array.Length())) {
       ByteArray::Copy(native_array, byte_array, offset, length);
       return Api::Success(isolate);
     }
     return Api::NewError("Invalid length passed in to access list elements");
   }
   if (obj.IsArray()) {
     GET_LIST_ELEMENT_AS_BYTES(isolate,
                               Array,
                               obj,
@@ skipping 26 matching lines @@
         const Array& kNoArgumentNames = Array::Handle(isolate);
         result = DartEntry::InvokeDynamic(
             instance, function, args, kNoArgumentNames);
         if (result.IsError()) {
           return Api::NewHandle(isolate, result.raw());
         }
         if (!result.IsInteger()) {
           return Api::NewError("%s expects the argument 'list' to be "
                                "a List of int", CURRENT_FUNC);
         }
-        intobj ^= result.raw();
-        ASSERT(intobj.AsInt64Value() <= 0xff);
+        const Integer& integer_result = Integer::Cast(result);
+        ASSERT(integer_result.AsInt64Value() <= 0xff);
         // TODO(hpayer): value should always be smaller then 0xff. Add error
         // handling.
-        native_array[i] = static_cast<uint8_t>(intobj.AsInt64Value() & 0xff);
+        native_array[i] =
+            static_cast<uint8_t>(integer_result.AsInt64Value() & 0xff);
       }
       return Api::Success(isolate);
     }
   }
   return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 #define SET_LIST_ELEMENT_AS_BYTES(isolate, type, obj, native_array, offset,    \
                                   length)                                      \
-  type& array = type::Handle(isolate);                                         \
-  array ^= obj.raw();                                                          \
+  const type& array = type::Cast(obj);                                         \
   Integer& integer = Integer::Handle(isolate);                                 \
   if (Utils::RangeCheck(offset, length, array.Length())) {                     \
     for (int i = 0; i < length; i++) {                                         \
       integer = Integer::New(native_array[i]);                                 \
       array.SetAt(offset + i, integer);                                        \
     }                                                                          \
     return Api::Success(isolate);                                              \
   }                                                                            \
   return Api::NewError("Invalid length passed in to set array elements");      \
 
 
 DART_EXPORT Dart_Handle Dart_ListSetAsBytes(Dart_Handle list,
                                             intptr_t offset,
                                             uint8_t* native_array,
                                             intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
   if (obj.IsUint8Array() || obj.IsExternalUint8Array()) {
-    ByteArray& byte_array = ByteArray::Handle(isolate);
-    byte_array ^= obj.raw();
+    const ByteArray& byte_array = ByteArray::Cast(obj);
     if (Utils::RangeCheck(offset, length, byte_array.Length())) {
       ByteArray::Copy(byte_array, offset, native_array, length);
       return Api::Success(isolate);
     }
     return Api::NewError("Invalid length passed in to set list elements");
   }
   if (obj.IsArray()) {
     if (obj.IsImmutableArray()) {
       return Api::NewError("Cannot modify immutable array");
     }
@@ skipping 294 matching lines @@
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(closure));
   if (obj.IsNull()) {
     return Api::NewError("Null object passed in to invoke closure");
   }
   if (!obj.IsClosure()) {
     return Api::NewError("Invalid closure passed to invoke closure");
   }
   ASSERT(ClassFinalizer::AllClassesFinalized());
 
   // Now try to invoke the closure.
-  Closure& closure_obj = Closure::Handle(isolate);
-  closure_obj ^= obj.raw();
+  const Closure& closure_obj = Closure::Cast(obj);
   GrowableArray<const Object*> dart_arguments(number_of_arguments);
   for (int i = 0; i < number_of_arguments; i++) {
     const Object& arg =
         Object::Handle(isolate, Api::UnwrapHandle(arguments[i]));
     dart_arguments.Add(&arg);
   }
   const Array& kNoArgumentNames = Array::Handle(isolate);
   return Api::NewHandle(
       isolate,
       DartEntry::InvokeClosure(closure_obj, dart_arguments, kNoArgumentNames));
@@ skipping 21 matching lines @@
 
 
 // --- Classes and Interfaces ---
 
 
 DART_EXPORT bool Dart_IsClass(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
   if (obj.IsClass()) {
-    Class& cls = Class::Handle(isolate);
-    cls ^= obj.raw();
-    return !cls.is_interface();
+    return !Class::Cast(obj).is_interface();
   }
   return false;
 }
 
 
 DART_EXPORT bool Dart_IsInterface(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
   if (obj.IsClass()) {
-    Class& cls = Class::Handle(isolate);
-    cls ^= obj.raw();
-    return cls.is_interface();
+    return Class::Cast(obj).is_interface();
   }
   return false;
 }
 
 
 DART_EXPORT Dart_Handle Dart_ClassName(Dart_Handle clazz) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  Class& cls = Class::Handle(isolate);
-  cls ^= Api::UnwrapClassHandle(isolate, clazz).raw();
+  const Class& cls = Class::Handle(
+      isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
   return Api::NewHandle(isolate, cls.Name());
 }
 
 
 DART_EXPORT Dart_Handle Dart_ClassGetLibrary(Dart_Handle clazz) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  Class& cls = Class::Handle(isolate);
-  cls ^= Api::UnwrapClassHandle(isolate, clazz).raw();
+  const Class& cls = Class::Handle(
+      isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
   return Api::NewHandle(isolate, cls.library());
 }
 
 
 DART_EXPORT Dart_Handle Dart_ClassGetDefault(Dart_Handle clazz) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  Class& cls = Class::Handle(isolate);
-  cls ^= Api::UnwrapClassHandle(isolate, clazz).raw();
+  const Class& cls = Class::Handle(
+      isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
 
   // Finalize all classes.
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::NewError(msg);
   }
 
   if (cls.HasFactoryClass() && cls.HasResolvedFactoryClass()) {
     return Api::NewHandle(isolate, cls.FactoryClass());
   }
   return Api::Null(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ClassGetInterfaceCount(Dart_Handle clazz,
                                                     intptr_t* count) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  Class& cls = Class::Handle(isolate);
-  cls ^= Api::UnwrapClassHandle(isolate, clazz).raw();
+  const Class& cls = Class::Handle(
+      isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
 
   const Array& interface_types = Array::Handle(isolate, cls.interfaces());
   if (interface_types.IsNull()) {
     *count = 0;
   } else {
     *count = interface_types.Length();
   }
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ClassGetInterfaceAt(Dart_Handle clazz,
                                                  intptr_t index) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  Class& cls = Class::Handle(isolate);
-  cls ^= Api::UnwrapClassHandle(isolate, clazz).raw();
+  const Class& cls = Class::Handle(
+      isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
 
   // Finalize all classes.
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::NewError(msg);
   }
 
@@ skipping 71 matching lines @@
   DARTSCOPE(isolate);
   Object& result = Object::Handle(isolate);
 
   if (number_of_arguments < 0) {
     return Api::NewError(
         "%s expects argument 'number_of_arguments' to be non-negative.",
         CURRENT_FUNC);
   }
 
   // Get the class to instantiate.
-  Class& cls = Class::Handle(isolate);
-  cls ^= Api::UnwrapClassHandle(isolate, clazz).raw();
+  Class& cls = Class::Handle(
+      isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
   String& base_constructor_name = String::Handle();
   base_constructor_name = cls.Name();
 
   // And get the name of the constructor to invoke.
   String& dot_name = String::Handle(isolate);
   const Object& name_obj =
       Object::Handle(isolate, Api::UnwrapHandle(constructor_name));
   if (name_obj.IsNull()) {
     dot_name = String::NewSymbol(".");
   } else if (name_obj.IsString()) {
     const String& dot = String::Handle(isolate, String::NewSymbol("."));
-    String& name_str = String::Handle(isolate);
-    name_str ^= name_obj.raw();
-    dot_name ^= String::Concat(dot, name_str);
+    dot_name = String::Concat(dot, String::Cast(name_obj));
   } else {
     return Api::NewError(
         "%s expects argument 'constructor_name' to be of type String.",
         CURRENT_FUNC);
   }
 
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::NewError(msg);
   }
@@ skipping 16 matching lines @@
     // looking up the constructor.
     const TypeArguments& no_type_args = TypeArguments::Handle(isolate);
     Error& error = Error::Handle();
     if (factory_class.IsSubtypeOf(no_type_args, cls, no_type_args, &error)) {
       base_constructor_name = factory_class.Name();
     }
     if (!error.IsNull()) {
       return Api::NewHandle(isolate, error.raw());
     }
 
-    cls ^= cls.FactoryClass();
+    cls = cls.FactoryClass();
   }
 
   // Resolve the constructor.
   result = ResolveConstructor(
       "Dart_New", cls, base_constructor_name, dot_name, number_of_arguments);
   if (result.IsError()) {
     return Api::NewHandle(isolate, result.raw());
   }
   ASSERT(result.IsFunction());
   Function& constructor = Function::Handle(isolate);
@@ skipping 109 matching lines @@
         isolate,
         DartEntry::InvokeDynamic(instance, function, args, kNoArgNames));
 
   } else if (obj.IsClass()) {
     // Finalize all classes.
     const char* msg = CheckIsolateState(isolate);
     if (msg != NULL) {
       return Api::NewError(msg);
     }
 
-    Class& cls = Class::Handle(isolate);
-    cls ^= obj.raw();
+    const Class& cls = Class::Cast(obj);
     const Function& function = Function::Handle(
         isolate,
         Resolver::ResolveStatic(cls,
                                 function_name,
                                 number_of_arguments,
                                 Array::Handle(isolate),
                                 Resolver::kIsQualified));
     if (function.IsNull()) {
       const String& cls_name = String::Handle(isolate, cls.Name());
       return Api::NewError("%s: did not find static method '%s.%s'.",
                            CURRENT_FUNC,
                            cls_name.ToCString(),
                            function_name.ToCString());
     }
     return Api::NewHandle(
         isolate,
         DartEntry::InvokeStatic(function, args, kNoArgNames));
 
   } else if (obj.IsLibrary()) {
     // Check whether class finalization is needed.
     bool finalize_classes = true;
-    Library& lib = Library::Handle(isolate);
-    lib ^= obj.raw();
+    const Library& lib = Library::Cast(obj);
 
     // When calling functions in the dart:builtin library do not finalize as it
     // should have been prefinalized.
     Library& builtin =
         Library::Handle(isolate, isolate->object_store()->builtin_library());
     if (builtin.raw() == lib.raw()) {
       finalize_classes = false;
     }
 
     // Finalize all classes if needed.
@@ skipping 53 matching lines @@
 
   Field& field = Field::Handle(isolate);
   Function& getter = Function::Handle(isolate);
   if (obj.IsNull()) {
     return Api::NewError("%s expects argument 'container' to be non-null.",
                          CURRENT_FUNC);
   } else if (obj.IsInstance()) {
     // Every instance field has a getter Function.  Try to find the
     // getter in any superclass and use that function to access the
     // field.
-    Instance& instance = Instance::Handle(isolate);
-    instance ^= obj.raw();
+    const Instance& instance = Instance::Cast(obj);
     Class& cls = Class::Handle(isolate, instance.clazz());
     while (!cls.IsNull()) {
       String& getter_name =
           String::Handle(isolate, Field::GetterName(field_name));
       getter = cls.LookupDynamicFunction(getter_name);
       if (!getter.IsNull()) {
         break;
       }
       cls = cls.SuperClass();
     }
@@ skipping 11 matching lines @@
         DartEntry::InvokeDynamic(instance, getter, args, kNoArgNames));
 
   } else if (obj.IsClass()) {
     // Finalize all classes.
     const char* msg = CheckIsolateState(isolate);
     if (msg != NULL) {
       return Api::NewError(msg);
     }
     // To access a static field we may need to use the Field or the
     // getter Function.
-    Class& cls = Class::Handle(isolate);
-    cls ^= obj.raw();
+    const Class& cls = Class::Cast(obj);
     field = cls.LookupStaticField(field_name);
     if (field.IsNull() || FieldIsUninitialized(isolate, field)) {
       const String& getter_name =
           String::Handle(isolate, Field::GetterName(field_name));
       getter = cls.LookupStaticFunction(getter_name);
     }
 
     if (!getter.IsNull()) {
       // Invoke the getter and return the result.
       GrowableArray<const Object*> args;
       const Array& kNoArgNames = Array::Handle(isolate);
       return Api::NewHandle(
           isolate, DartEntry::InvokeStatic(getter, args, kNoArgNames));
     } else if (!field.IsNull()) {
       return Api::NewHandle(isolate, field.value());
     } else {
       return Api::NewError("%s: did not find static field '%s'.",
                            CURRENT_FUNC, field_name.ToCString());
     }
 
   } else if (obj.IsLibrary()) {
     // TODO(turnidge): Do we need to call CheckIsolateState here?
 
     // To access a top-level we may need to use the Field or the
     // getter Function.  The getter function may either be in the
     // library or in the field's owner class, depending.
-    Library& lib = Library::Handle(isolate);
-    lib ^= obj.raw();
+    const Library& lib = Library::Cast(obj);
     field = lib.LookupFieldAllowPrivate(field_name);
     if (field.IsNull()) {
       // No field found.  Check for a getter in the lib.
       const String& getter_name =
           String::Handle(isolate, Field::GetterName(field_name));
       getter = lib.LookupFunctionAllowPrivate(getter_name);
     } else if (FieldIsUninitialized(isolate, field)) {
       // A field was found.  Check for a getter in the field's owner classs.
       const Class& cls = Class::Handle(isolate, field.owner());
       const String& getter_name =
@@ skipping 44 matching lines @@
   Field& field = Field::Handle(isolate);
   Function& setter = Function::Handle(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(container));
   if (obj.IsNull()) {
     return Api::NewError("%s expects argument 'container' to be non-null.",
                          CURRENT_FUNC);
   } else if (obj.IsInstance()) {
     // Every instance field has a setter Function.  Try to find the
     // setter in any superclass and use that function to access the
     // field.
-    Instance& instance = Instance::Handle(isolate);
-    instance ^= obj.raw();
+    const Instance& instance = Instance::Cast(obj);
     Class& cls = Class::Handle(isolate, instance.clazz());
     while (!cls.IsNull()) {
       field = cls.LookupInstanceField(field_name);
       if (!field.IsNull() && field.is_final()) {
         return Api::NewError("%s: cannot set final field '%s'.",
                              CURRENT_FUNC, field_name.ToCString());
       }
       String& setter_name =
           String::Handle(isolate, Field::SetterName(field_name));
       setter = cls.LookupDynamicFunction(setter_name);
@@ skipping 12 matching lines @@
     GrowableArray<const Object*> args(1);
     args.Add(&value_instance);
     const Array& kNoArgNames = Array::Handle(isolate);
     return Api::NewHandle(
         isolate,
         DartEntry::InvokeDynamic(instance, setter, args, kNoArgNames));
 
   } else if (obj.IsClass()) {
     // To access a static field we may need to use the Field or the
     // setter Function.
-    Class& cls = Class::Handle(isolate);
-    cls ^= obj.raw();
+    const Class& cls = Class::Cast(obj);
     field = cls.LookupStaticField(field_name);
     if (field.IsNull()) {
       String& setter_name =
           String::Handle(isolate, Field::SetterName(field_name));
       setter = cls.LookupStaticFunction(setter_name);
     }
 
     if (!setter.IsNull()) {
       // Invoke the setter and return the result.
       GrowableArray<const Object*> args(1);
@@ skipping 17 matching lines @@
       }
     } else {
       return Api::NewError("%s: did not find static field '%s'.",
                            CURRENT_FUNC, field_name.ToCString());
     }
 
   } else if (obj.IsLibrary()) {
     // To access a top-level we may need to use the Field or the
     // setter Function.  The setter function may either be in the
     // library or in the field's owner class, depending.
-    Library& lib = Library::Handle(isolate);
-    lib ^= obj.raw();
+    const Library& lib = Library::Cast(obj);
     field = lib.LookupFieldAllowPrivate(field_name);
     if (field.IsNull()) {
       const String& setter_name =
           String::Handle(isolate, Field::SetterName(field_name));
       setter ^= lib.LookupFunctionAllowPrivate(setter_name);
     }
 
     if (!setter.IsNull()) {
       // Invoke the setter and return the result.
       GrowableArray<const Object*> args(1);
@@ skipping 571 matching lines @@
     *buffer_size = 0;
   }
 }
 
 
 DART_EXPORT void Dart_InitFlowGraphPrinting(FileWriterFunction function) {
   Dart::set_flow_graph_writer(function);
 }
 
 }  // namespace dart