Deal with unhandled exceptions the same way in all Dart api functions.

runtime/vm/dart_api_impl.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 "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/debuginfo.h"
 #include "vm/exceptions.h"
 #include "vm/growable_array.h"
 #include "vm/longjump.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/port.h"
 #include "vm/resolver.h"
 #include "vm/snapshot.h"
 #include "vm/stack_frame.h"
 #include "vm/timer.h"
 #include "vm/verifier.h"
 
 namespace dart {
 
-DART_EXPORT bool Dart_IsValid(const Dart_Handle& handle) {
+DART_EXPORT bool Dart_IsError(const Dart_Handle& handle) {
   ASSERT(Isolate::Current() != NULL);
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
-
-  // Make sure that the object isn't an ApiFailure.
   const Object& obj = Object::Handle(Api::UnwrapHandle(handle));
-  return !obj.IsApiFailure();
+  return obj.IsApiError();
 }
 
 
-DART_EXPORT void _Dart_ReportInvalidHandle(const char* file,
+DART_EXPORT bool Dart_IsUnhandledException(Dart_Handle handle) {
+  Zone zone;  // Setup a VM zone as we are creating some handles.
+  HandleScope scope;  // Setup a VM handle scope.
+  const Object& obj = Object::Handle(Api::UnwrapHandle(handle));
+  if (obj.IsApiError()) {
+    const ApiError& error = ApiError::CheckedHandle(obj.raw());
+    const Object& data = Object::Handle(error.data());
+    return data.IsUnhandledException();
+  }
+  return false;
+}
+
+
+DART_EXPORT Dart_Handle Dart_GetException(Dart_Handle handle) {
+  Zone zone;  // Setup a VM zone as we are creating some handles.
+  HandleScope scope;  // Setup a VM handle scope.
+  const Object& obj = Object::Handle(Api::UnwrapHandle(handle));
+  if (obj.IsApiError()) {
+    ApiError& failure = ApiError::Handle();
+    failure ^= obj.raw();
+    const Object& data = Object::Handle(failure.data());
+    if (data.IsUnhandledException()) {
+      const UnhandledException& unhandled = UnhandledException::Handle(
+          reinterpret_cast<RawUnhandledException*>(data.raw()));
+      const Object& exception = Object::Handle(unhandled.exception());
+      return Api::NewLocalHandle(exception);
+    } else {
+      return Api::Error("This error is not an unhandled exception error.");
+    }
+  } else {
+    return Api::Error("Can only get exceptions from error handles.");
+  }
+}
+
+
+DART_EXPORT Dart_Handle Dart_GetStacktrace(Dart_Handle handle) {
+  Zone zone;  // Setup a VM zone as we are creating some handles.
+  HandleScope scope;  // Setup a VM handle scope.
+  const Object& obj = Object::Handle(Api::UnwrapHandle(handle));
+  if (obj.IsApiError()) {
+    ApiError& failure = ApiError::Handle();
+    failure ^= obj.raw();
+    const Object& data = Object::Handle(failure.data());
+    if (data.IsUnhandledException()) {
+      const UnhandledException& unhandled = UnhandledException::Handle(
+          reinterpret_cast<RawUnhandledException*>(data.raw()));
+      const Object& stacktrace = Object::Handle(unhandled.stacktrace());
+      return Api::NewLocalHandle(stacktrace);
+    } else {
+      return Api::Error("This error is not an unhandled exception error.");
+    }
+  } else {
+    return Api::Error("Can only get stacktraces from error handles.");
+  }
+}
+
+
+DART_EXPORT void _Dart_ReportErrorHandle(const char* file,
                                            int line,
                                            const char* handle,
                                            const char* message) {
-  fprintf(stderr, "%s:%d: invalid handle: '%s':\n    '%s'\n",
+  fprintf(stderr, "%s:%d: error handle: '%s':\n    '%s'\n",
           file, line, handle, message);
   OS::Abort();
 }
 
 
+static const char* MakeUnhandledExceptionCString(
+    const UnhandledException& uhe) {
+  const Instance& exception = Instance::Handle(uhe.exception());
+  Object& strtmp = Object::Handle(DartLibraryCalls::ToString(exception));
+  const char* exc_str =
+      "<Received exception while converting exception to string>";
+  if (!strtmp.IsUnhandledException()) {
+    exc_str = strtmp.ToCString();
+  }
+
+  const Instance& stack = Instance::Handle(uhe.stacktrace());
+  strtmp = DartLibraryCalls::ToString(stack);
+  const char* stack_str =
+      "<Received exception while converting stack trace to string>";
+  if (!strtmp.IsUnhandledException()) {
+    stack_str = strtmp.ToCString();
+  }
+
+  const char* format = "Unhandled exception:\n%s\n%s";
+  int len = (strlen(exc_str) + strlen(stack_str) + strlen(format)
+             - 4    // Two '%s'
+             + 1);  // '\0'
+  char* buffer = reinterpret_cast<char*>(Api::Allocate(len));
+  OS::SNPrint(buffer, len, format, exc_str, stack_str);
+  return buffer;
+}
+
+
 DART_EXPORT const char* Dart_GetError(const Dart_Handle& handle) {
   ASSERT(Isolate::Current() != NULL);
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
   const Object& obj = Object::Handle(Api::UnwrapHandle(handle));
-  if (!obj.IsApiFailure()) {
+  if (!obj.IsApiError()) {
     return "";
   }
-  ApiFailure& failure = ApiFailure::Handle();
+  ApiError& failure = ApiError::Handle();
   failure ^= obj.raw();
-  const String& message = String::Handle(failure.message());
-  const char* msg = message.ToCString();
-  intptr_t len = strlen(msg) + 1;
-  char* msg_copy = reinterpret_cast<char*>(Api::Allocate(len));
-  OS::SNPrint(msg_copy, len, "%s", msg);
-  return msg_copy;
+  const Object& data = Object::Handle(failure.data());
+  if (data.IsString()) {
+    // Simple error message.
+    String& message = String::Handle();
+    message ^= failure.data();
+    const char* msg = message.ToCString();
+    intptr_t len = strlen(msg) + 1;
+    char* msg_copy = reinterpret_cast<char*>(Api::Allocate(len));
+    strncpy(msg_copy, msg, len);
+    return msg_copy;
+

[Ivan Posva, 2011/11/10 18:05:46]

extra empty lines?

[turnidge, 2011/11/10 20:59:13]

The extra empty lines help me scan the code -- otherwise it all turns into a big
blob for me.  If you want still want me to remove them, I will.

+  } else if (data.IsUnhandledException()) {
+    UnhandledException& uhe = UnhandledException::Handle();
+    uhe ^= data.raw();
+    return MakeUnhandledExceptionCString(uhe);
+
+  } else {
+    return "<Internal error in Dart_GetError: malformed error handle>";
+  }
 }
 
 
 DART_EXPORT Dart_Handle Dart_Error(const char* format, ...) {
   va_list args;
   va_start(args, format);
   Dart_Handle error = Api::VError(format, args);
   va_end(args);
   return error;
 }
@@ skipping 57 matching lines @@
   ASSERT(Isolate::Current() != NULL);
   Isolate::SetCurrent(NULL);
 }
 
 
 static void SetupErrorResult(Dart_Handle* handle) {
   // Make a copy of the error message as the original message string
   // may get deallocated when we return back from the Dart API call.
   const String& error = String::Handle(
       Isolate::Current()->object_store()->sticky_error());
-  const Object& obj = Object::Handle(ApiFailure::New(error));
+  const Object& obj = Object::Handle(ApiError::New(error));
   *handle = Api::NewLocalHandle(obj);
 }
 
 
 DART_EXPORT void Dart_SetMessageCallbacks(
     Dart_PostMessageCallback post_message_callback,
     Dart_ClosePortCallback close_port_callback) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ASSERT(post_message_callback != NULL);
@@ skipping 10 matching lines @@
 
   // Read object back from the snapshot.
   Isolate* isolate = Isolate::Current();
   SnapshotReader reader(snapshot, isolate->heap(), isolate->object_store());
   Instance& instance = Instance::Handle();
   instance ^= reader.ReadObject();
   return instance.raw();
 }
 
 
-static void ProcessUnhandledException(const UnhandledException& uhe) {
-  const Instance& exception = Instance::Handle(uhe.exception());
-  Instance& strtmp = Instance::Handle(DartLibraryCalls::ToString(exception));
-  const char* str = strtmp.ToCString();
-  fprintf(stderr, "%s\n", str);
-  const Instance& stack = Instance::Handle(uhe.stacktrace());
-  strtmp = DartLibraryCalls::ToString(stack);
-  str = strtmp.ToCString();
-  fprintf(stderr, "%s\n", str);
-  exit(255);
-}
-
-
-DART_EXPORT void Dart_HandleMessage(Dart_Port dest_port,
-                                    Dart_Port reply_port,
-                                    Dart_Message dart_message) {
+DART_EXPORT Dart_Handle Dart_HandleMessage(Dart_Port dest_port,
+                                           Dart_Port reply_port,
+                                           Dart_Message dart_message) {
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
   const Instance& msg = Instance::Handle(DeserializeMessage(dart_message));
   const String& class_name =
       String::Handle(String::NewSymbol("ReceivePortImpl"));
   const String& function_name =
       String::Handle(String::NewSymbol("handleMessage_"));
   const int kNumArguments = 3;
   const Array& kNoArgumentNames = Array::Handle();
   const Function& function = Function::Handle(
       Resolver::ResolveStatic(Library::Handle(Library::CoreLibrary()),
                               class_name,
                               function_name,
                               kNumArguments,
                               kNoArgumentNames,
                               Resolver::kIsQualified));
   GrowableArray<const Object*> arguments(kNumArguments);
   arguments.Add(&Integer::Handle(Integer::New(dest_port)));
   arguments.Add(&Integer::Handle(Integer::New(reply_port)));
   arguments.Add(&msg);
   const Object& result = Object::Handle(
       DartEntry::InvokeStatic(function, arguments, kNoArgumentNames));
   if (result.IsUnhandledException()) {
-    UnhandledException& uhe = UnhandledException::Handle();
-    uhe ^= result.raw();
-    // TODO(turnidge): Instead of exiting here, just return the
-    // exception so that the embedder can choose how to handle this
-    // case.
-    ProcessUnhandledException(uhe);
+    return Api::ErrorFromException(result);
   }
   ASSERT(result.IsNull());
+  return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_RunLoop() {
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
 
   Isolate* isolate = Isolate::Current();
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
@@ skipping 209 matching lines @@
   HandleScope scope;  // Setup a VM handle scope.
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   Object& result = Object::Handle();
   if (obj.IsString()) {
     result = obj.raw();
   } else if (obj.IsInstance()) {
     Instance& receiver = Instance::Handle();
     receiver ^= obj.raw();
     result = DartLibraryCalls::ToString(receiver);
     if (result.IsUnhandledException()) {
-      return Api::Error("An exception occurred when converting to string");
+      return Api::ErrorFromException(result);
     }
   } else {
     // This is a VM internal object. Call the C++ method of printing.
     result = String::New(obj.ToCString());
   }
   return Api::NewLocalHandle(result);
 }
 
 
 DART_EXPORT Dart_Handle Dart_Null() {
@@ skipping 41 matching lines @@
   HandleScope scope;  // Setup a VM handle scope.
   const Instance& expected = Instance::CheckedHandle(Api::UnwrapHandle(obj1));
   const Instance& actual = Instance::CheckedHandle(Api::UnwrapHandle(obj2));
   const Instance& result =
       Instance::Handle(DartLibraryCalls::Equals(expected, actual));
   if (result.IsBool()) {
     Bool& b = Bool::Handle();
     b ^= result.raw();
     *value = b.value();
     return Api::Success();
+  } else if (result.IsUnhandledException()) {
+    return Api::ErrorFromException(result);
   } else {
-    return Api::Error("An exception occured when calling '=='");
+    return Api::Error("Expected boolean result from ==");
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_IsSame(Dart_Handle obj1, Dart_Handle obj2,
                                     bool* value) {
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
   const Object& expected = Object::Handle(Api::UnwrapHandle(obj1));
   const Object& actual = Object::Handle(Api::UnwrapHandle(obj2));
@@ skipping 449 matching lines @@
           *len = integer.AsInt64Value();
         } else if (retval.IsBigint()) {
           Bigint& bigint = Bigint::Handle();
           bigint ^= retval.raw();
           if (BigintOperations::FitsIntoInt64(bigint)) {
             *len = BigintOperations::ToInt64(bigint);
           } else {
             result = Api::Error("Length of List object is greater than the "
                                 "maximum value that 'len' parameter can hold");
           }
+        } else if (retval.IsUnhandledException()) {
+          result = Api::ErrorFromException(retval);
         } else {
           result = Api::Error("Length of List object is not an integer");
         }
       } else {
         SetupErrorResult(&result);
       }
       isolate->set_long_jump_base(base);
       return result;
     }
   }
@@ skipping 14 matching lines @@
   if (setjmp(*jump.Set()) == 0) {
     Instance& retval = Instance::Handle();
     GrowableArray<const Object*> args(0);
     args.Add(&index);
     const Array& kNoArgumentNames = Array::Handle();
     retval = DartEntry::InvokeDynamic(instance,
                                       function,
                                       args,
                                       kNoArgumentNames);
     if (retval.IsUnhandledException()) {
-      *result = Api::Error("Unexpected exception in '[]'");
+      *result = Api::ErrorFromException(retval);
     } else {
       *result = Api::Success();
     }
     isolate->set_long_jump_base(base);
     return retval.raw();
   }
   SetupErrorResult(result);
   isolate->set_long_jump_base(base);
   return Object::null();
 }
@@ skipping 32 matching lines @@
     String& name = String::Handle(String::New("[]"));
     const Function& function = Function::Handle(
         Resolver::ResolveDynamic(instance, name, 2, 0));
     if (!function.IsNull()) {
       Object& element = Object::Handle();
       Integer& intobj = Integer::Handle();
       Dart_Handle result;
       for (int i = 0; i < length; i++) {
         intobj = Integer::New(offset + i);
         element = GetListAt(isolate, instance, intobj, function, &result);
-        if (!Dart_IsValid(result)) {
+        if (Dart_IsError(result)) {
           return result;  // Error condition.
         }
         intobj ^= element.raw();
         ASSERT(intobj.AsInt64Value() <= 0xff);
         // TODO(hpayer): value should always be smaller then 0xff. Add error
         // handling.
         native_array[i] = static_cast<uint8_t>(intobj.AsInt64Value() & 0xff);
       }
       return Api::Success();
     }
@@ skipping 22 matching lines @@
   if (!instance.IsNull()) {
     String& name = String::Handle(String::New("[]"));
     const Function& function = Function::Handle(
         Resolver::ResolveDynamic(instance, name, 2, 0));
     if (!function.IsNull()) {
       Object& element = Object::Handle();
       Integer& indexobj = Integer::Handle();
       Dart_Handle result;
       indexobj = Integer::New(index);
       element = GetListAt(isolate, instance, indexobj, function, &result);
-      if (!Dart_IsValid(result)) {
+      if (Dart_IsError(result)) {
         return result;  // Error condition.
       }
       return Api::NewLocalHandle(element);
     }
   }
   return Api::Error("Object does not implement the 'List' interface");
 }
 
 
 static void SetListAt(Isolate* isolate,
@@ skipping 11 matching lines @@
     GrowableArray<const Object*> args(1);
     args.Add(&index);
     args.Add(&value);
     Instance& retval = Instance::Handle();
     const Array& kNoArgumentNames = Array::Handle();
     retval = DartEntry::InvokeDynamic(instance,
                                       function,
                                       args,
                                       kNoArgumentNames);
     if (retval.IsUnhandledException()) {
-      *result = Api::Error("Unexpected exception in '[]='");
+      *result = Api::ErrorFromException(retval);
     } else {
       *result = Api::Success();
     }
   } else {
     SetupErrorResult(result);
   }
   isolate->set_long_jump_base(base);
 }
 
 
@@ skipping 26 matching lines @@
     const Function& function = Function::Handle(
         Resolver::ResolveDynamic(instance, name, 3, 0));
     if (!function.IsNull()) {
       Integer& indexobj = Integer::Handle();
       Integer& valueobj = Integer::Handle();
       Dart_Handle result;
       for (int i = 0; i < length; i++) {
         indexobj = Integer::New(offset + i);
         valueobj ^= Integer::New(native_array[i]);
         SetListAt(isolate, instance, indexobj, valueobj, function, &result);
-        if (!Dart_IsValid(result)) {
+        if (Dart_IsError(result)) {
           return result;  // Error condition.
         }
       }
       return Api::Success();
     }
   }
   return Api::Error("Object does not implement the 'List' interface");
 }
 
 
@@ skipping 41 matching lines @@
                          Dart_Handle* result) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     const Array& kNoArgumentNames = Array::Handle();
     const Instance& retval = Instance::Handle(
         DartEntry::InvokeStatic(function, args, kNoArgumentNames));
-    *result = Api::NewLocalHandle(retval);
+    if (retval.IsUnhandledException()) {
+      *result = Api::ErrorFromException(retval);
+    } else {
+      *result = Api::NewLocalHandle(retval);
+    }
   } else {
     SetupErrorResult(result);
   }
   isolate->set_long_jump_base(base);
 }
 
 
 // NOTE: Need to pass 'result' as a parameter here in order to avoid
 // warning: variable 'result' might be clobbered by 'longjmp' or 'vfork'
 // which shows up because of the use of setjmp.
 static void InvokeDynamic(const Instance& receiver,
                           const Function& function,
                           GrowableArray<const Object*>& args,
                           Dart_Handle* result) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     const Array& kNoArgumentNames = Array::Handle();
     const Instance& retval = Instance::Handle(
         DartEntry::InvokeDynamic(receiver, function, args, kNoArgumentNames));
-    *result = Api::NewLocalHandle(retval);
+    if (retval.IsUnhandledException()) {
+      *result = Api::ErrorFromException(retval);
+    } else {
+      *result = Api::NewLocalHandle(retval);
+    }
   } else {
     SetupErrorResult(result);
   }
   isolate->set_long_jump_base(base);
 }
 
 
 // NOTE: Need to pass 'result' as a parameter here in order to avoid
 // warning: variable 'result' might be clobbered by 'longjmp' or 'vfork'
 // which shows up because of the use of setjmp.
 static void InvokeClosure(const Closure& closure,
                           GrowableArray<const Object*>& args,
                           Dart_Handle* result) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     const Array& kNoArgumentNames = Array::Handle();
     const Instance& retval = Instance::Handle(
         DartEntry::InvokeClosure(closure, args, kNoArgumentNames));
-    *result = Api::NewLocalHandle(retval);
+    if (retval.IsUnhandledException()) {
+      *result = Api::ErrorFromException(retval);
+    } else {
+      *result = Api::NewLocalHandle(retval);
+    }
   } else {
     SetupErrorResult(result);
   }
   isolate->set_long_jump_base(base);
 }
 
 
 DART_EXPORT Dart_Handle Dart_InvokeStatic(Dart_Handle library_in,
                                           Dart_Handle class_name_in,
                                           Dart_Handle function_name_in,
@@ skipping 143 matching lines @@
 
 DART_EXPORT void Dart_SetReturnValue(Dart_NativeArguments args,
                                      Dart_Handle retval) {
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   arguments->SetReturn(Object::Handle(Api::UnwrapHandle(retval)));
 }
 
 
-DART_EXPORT bool Dart_ExceptionOccurred(Dart_Handle result) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
-  const Object& retval  = Object::Handle(Api::UnwrapHandle(result));
-  return retval.IsUnhandledException();
-}
-
-
-DART_EXPORT Dart_Handle Dart_GetException(Dart_Handle result) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
-  const Object& retval = Object::Handle(Api::UnwrapHandle(result));
-  if (retval.IsUnhandledException()) {
-    const UnhandledException& unhandled = UnhandledException::Handle(
-        reinterpret_cast<RawUnhandledException*>(retval.raw()));
-    const Object& exception = Object::Handle(unhandled.exception());
-    return Api::NewLocalHandle(exception);
-  }
-  return Api::Error("Object is not an unhandled exception object");
-}
-
-
-DART_EXPORT Dart_Handle Dart_GetStacktrace(Dart_Handle unhandled_excp) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
-  const Object& retval = Object::Handle(Api::UnwrapHandle(unhandled_excp));
-  if (retval.IsUnhandledException()) {
-    const UnhandledException& unhandled = UnhandledException::Handle(
-        reinterpret_cast<RawUnhandledException*>(retval.raw()));
-    const Object& stacktrace = Object::Handle(unhandled.stacktrace());
-    return Api::NewLocalHandle(stacktrace);
-  }
-  return Api::Error("Object is not an unhandled exception object");
-}
-
-
 DART_EXPORT Dart_Handle Dart_ThrowException(Dart_Handle exception) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
   if (isolate->top_exit_frame_info() == 0) {
     // There are no dart frames on the stack so it would be illegal to
     // throw an exception here.
     return Api::Error("No Dart frames on stack, cannot throw exception");
   }
@@ skipping 176 matching lines @@
   }
   return Api::Error("Unable to find field in the class");
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetStaticField(Dart_Handle cls,
                                             Dart_Handle name) {
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
   Dart_Handle result = LookupStaticField(cls, name, kGetter);
-  if (!::Dart_IsValid(result)) {
+  if (::Dart_IsError(result)) {
     return result;
   }
   Object& retval = Object::Handle();
   const Object& obj = Object::Handle(Api::UnwrapHandle(result));
   if (obj.IsField()) {
     Field& fld = Field::Handle();
     fld ^= obj.raw();
     retval = fld.value();
     return Api::NewLocalHandle(retval);
   } else {
     Function& func = Function::Handle();
     func ^= obj.raw();
     GrowableArray<const Object*> args;
     InvokeStatic(func, args, &result);
-    if (::Dart_IsValid(result)) {
-      if (Dart_ExceptionOccurred(result)) {
-        return Api::Error(
-            "An exception occurred when getting the static field");
-      }
-    }
     return result;
   }
 }
 
 
 // TODO(iposva): The value parameter should be documented as being an instance.
+// TODO(turnidge): Is this skipping the setter?
 DART_EXPORT Dart_Handle Dart_SetStaticField(Dart_Handle cls,
                                             Dart_Handle name,
                                             Dart_Handle value) {
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
   Dart_Handle result = LookupStaticField(cls, name, kSetter);
-  if (!::Dart_IsValid(result)) {
+  if (::Dart_IsError(result)) {
     return result;
   }
   Field& fld = Field::Handle();
   fld ^= Api::UnwrapHandle(result);
   if (fld.is_final()) {
     return Api::Error("Specified field is a static final field in the class");
   }
   const Object& val = Object::Handle(Api::UnwrapHandle(value));
   Instance& instance = Instance::Handle();
   instance ^= val.raw();
   fld.set_value(instance);
   return Api::NewLocalHandle(val);
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetInstanceField(Dart_Handle obj,
                                               Dart_Handle name) {
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
   const Object& param = Object::Handle(Api::UnwrapHandle(obj));
   if (param.IsNull() || !param.IsInstance()) {
     return Api::Error("Invalid object passed in to access instance field");
   }
   Instance& object = Instance::Handle();
   object ^= param.raw();
   Dart_Handle result = LookupInstanceField(object, name, kGetter);
-  if (!::Dart_IsValid(result)) {
+  if (::Dart_IsError(result)) {
     return result;
   }
   Function& func = Function::Handle();
   func ^= Api::UnwrapHandle(result);
   GrowableArray<const Object*> arguments;
   InvokeDynamic(object, func, arguments, &result);
-  if (::Dart_IsValid(result)) {
-    if (Dart_ExceptionOccurred(result)) {
-      return Api::Error(
-          "An exception occurred when accessing the instance field");
-    }
-  }
   return result;
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetInstanceField(Dart_Handle obj,
                                               Dart_Handle name,
                                               Dart_Handle value) {
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
   const Object& param = Object::Handle(Api::UnwrapHandle(obj));
   if (param.IsNull() || !param.IsInstance()) {
     return Api::Error("Invalid object passed in to access instance field");
   }
   Instance& object = Instance::Handle();
   object ^= param.raw();
   Dart_Handle result = LookupInstanceField(object, name, kSetter);
-  if (!::Dart_IsValid(result)) {
+  if (::Dart_IsError(result)) {
     return result;
   }
   Function& func = Function::Handle();
   func ^= Api::UnwrapHandle(result);
   GrowableArray<const Object*> arguments(1);
   const Object& arg = Object::Handle(Api::UnwrapHandle(value));
   arguments.Add(&arg);
   InvokeDynamic(object, func, arguments, &result);
-  if (::Dart_IsValid(result)) {
-    if (Dart_ExceptionOccurred(result)) {
-      return Api::Error(
-          "An exception occurred when setting the instance field");
-    }
-  }
   return result;
 }
 
 
 DART_EXPORT Dart_Handle Dart_CreateNativeWrapperClass(Dart_Handle library,
                                                       Dart_Handle name,
                                                       int field_count) {
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
   const Object& param = Object::Handle(Api::UnwrapHandle(name));
@@ skipping 215 matching lines @@
 
 Dart_Handle Api::VError(const char* format, va_list args) {
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
 
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   char* buffer = reinterpret_cast<char*>(zone.Allocate(len + 1));
   OS::VSNPrint(buffer, (len + 1), format, args);
 
   const String& message = String::Handle(String::New(buffer));
-  const Object& obj = Object::Handle(ApiFailure::New(message));
+  const Object& obj = Object::Handle(ApiError::New(message));
   return Api::NewLocalHandle(obj);
 }
 
 
 Dart_Handle Api::Error(const char* format, ...) {
   va_list args;
   va_start(args, format);
   Dart_Handle error = Api::VError(format, args);
   va_end(args);
   return error;
 }
 
 
+Dart_Handle Api::ErrorFromException(const Object& obj) {
+  Zone zone;  // Setup a VM zone as we are creating some handles.
+  HandleScope scope;  // Setup a VM handle scope.
+
+  ASSERT(obj.IsUnhandledException());
+  if (obj.IsUnhandledException()) {
+    UnhandledException& uhe = UnhandledException::Handle();
+    uhe ^= obj.raw();
+    const Object& error = Object::Handle(ApiError::New(uhe));
+    return Api::NewLocalHandle(error);
+  } else {
+    return Api::Error("Internal error: expected obj.IsUnhandledException().");
+  }
+}
+
+
 Dart_Handle Api::Null() {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   PersistentHandle* null_handle = state->Null();
   return reinterpret_cast<Dart_Handle>(null_handle);
 }
 
 
@@ skipping 33 matching lines @@
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   ASSERT(scope != NULL);
   return scope->zone().Reallocate(ptr, old_size, new_size);
 }
 
 
 }  // namespace dart