Introduce the Error object class in the vm. It represents all of the

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"
@@ skipping 21 matching lines @@
     return func + 6;
   } else {
     return func;
   }
 }
 
 #define RETURN_TYPE_ERROR(dart_handle, Type)                                  \
   do {                                                                        \
     const Object& tmp = Object::Handle(Api::UnwrapHandle((dart_handle)));     \
     if (tmp.IsNull()) {                                                       \
-      return Api::Error("%s expects argument '%s' to be non-null.",           \
-                        CURRENT_FUNC, #dart_handle);                          \
-    } else if (tmp.IsApiError()) {                                            \
+      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::Error("%s expects argument '%s' to be of type %s.",         \
-                        CURRENT_FUNC, #dart_handle, #Type);                   \
+      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.
 const char* CheckIsolateState(Isolate* isolate, bool generating_snapshot) {
   bool success = true;
   if (!ClassFinalizer::AllClassesFinalized()) {
     success = (generating_snapshot) ?
@@ skipping 17 matching lines @@
     return msg;
   }
 }
 
 
 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(ApiError::New(error));
+  const Object& obj = Object::Handle(LanguageError::New(error));
   *handle = Api::NewLocalHandle(obj);
 }
 
 
 // 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 InvokeStatic(Isolate* isolate,
                          const Function& function,
                          GrowableArray<const Object*>& args,
                          Dart_Handle* result) {
   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));
-    if (retval.IsUnhandledException()) {
-      *result = Api::ErrorFromException(retval);
-    } else {
-      *result = Api::NewLocalHandle(retval);
-    }
+    *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(Isolate* isolate,
                           const Instance& receiver,
                           const Function& function,
                           GrowableArray<const Object*>& args,
                           Dart_Handle* result) {
   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));
-    if (retval.IsUnhandledException()) {
-      *result = Api::ErrorFromException(retval);
-    } else {
-      *result = Api::NewLocalHandle(retval);
-    }
+    *result = Api::NewLocalHandle(retval);
   } else {
     SetupErrorResult(result);
   }
   isolate->set_long_jump_base(base);
 }
 
 
 Dart_Handle Api::NewLocalHandle(const Object& object) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
@@ skipping 62 matching lines @@
 Dart_Handle Api::Success() {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   PersistentHandle* true_handle = state->True();
   return reinterpret_cast<Dart_Handle>(true_handle);
 }
 
 
-Dart_Handle Api::Error(const char* format, ...) {
+Dart_Handle Api::NewError(const char* format, ...) {
   DARTSCOPE_NOCHECKS(Isolate::Current());
 
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
   char* buffer = reinterpret_cast<char*>(zone.Allocate(len + 1));
   va_list args2;
   va_start(args2, format);
   OS::VSNPrint(buffer, (len + 1), format, args2);
   va_end(args2);
 
   const String& message = String::Handle(String::New(buffer));
   const Object& obj = Object::Handle(ApiError::New(message));
   return Api::NewLocalHandle(obj);
 }
 
 
-Dart_Handle Api::ErrorFromException(const Object& obj) {
-  DARTSCOPE_NOCHECKS(Isolate::Current());
-
-  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 38 matching lines @@
   return scope->zone().Reallocate(ptr, old_size, new_size);
 }
 
 
 // --- Handles ---
 
 
 DART_EXPORT bool Dart_IsError(Dart_Handle handle) {
   DARTSCOPE(Isolate::Current());
   const Object& obj = Object::Handle(Api::UnwrapHandle(handle));
-  return obj.IsApiError();
+  return obj.IsError();
 }
 
 
 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()) {
+      "<Received error while converting exception to string>";
+  if (!strtmp.IsError()) {
     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()) {
+      "<Received error while converting stack trace to string>";
+  if (!strtmp.IsError()) {
     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(Dart_Handle handle) {
   DARTSCOPE(Isolate::Current());
 
   const Object& obj = Object::Handle(Api::UnwrapHandle(handle));
-  if (!obj.IsApiError()) {
+  if (!obj.IsError()) {
     return "";
   }
-  ApiError& failure = ApiError::Handle();
-  failure ^= obj.raw();
-  const Object& data = Object::Handle(failure.data());
-  if (data.IsString()) {
-    // Simple error message.
-    String& message = String::Handle();
-    message ^= failure.data();
+  if (obj.IsApiError()) {
+    ApiError& error = ApiError::Handle();
+    error ^= obj.raw();
+    const String& message = String::Handle(error.message());
     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;
-
-  } else if (data.IsUnhandledException()) {
-    UnhandledException& uhe = UnhandledException::Handle();
-    uhe ^= data.raw();
-    return MakeUnhandledExceptionCString(uhe);
-
+  } else if (obj.IsLanguageError()) {
+    LanguageError& error = LanguageError::Handle();
+    error ^= obj.raw();
+    const String& message = String::Handle(error.message());
+    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;
+  } else if (obj.IsUnhandledException()) {
+    UnhandledException& error = UnhandledException::Handle();
+    error ^= obj.raw();
+    return MakeUnhandledExceptionCString(error);
+  } else if (obj.IsUnwindError()) {
+    UNIMPLEMENTED();
+    return "<unimplemented>;";
   } else {
-    return "<Internal error in Dart_GetError: malformed error handle>";
+    return "<Internal error in Dart_GetError: unexpected error type>";
   }
 }
 
 
 DART_EXPORT bool Dart_ErrorHasException(Dart_Handle handle) {
   DARTSCOPE(Isolate::Current());
   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;
+  return obj.IsUnhandledException();
 }
 
 
 DART_EXPORT Dart_Handle Dart_ErrorGetException(Dart_Handle handle) {
   DARTSCOPE(Isolate::Current());
   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());
-    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.");
-    }
+  if (obj.IsUnhandledException()) {
+    UnhandledException& error = UnhandledException::Handle();
+    error ^= obj.raw();
+    const Object& exception = Object::Handle(error.exception());
+    return Api::NewLocalHandle(exception);
+  } else if (obj.IsError()) {
+    return Api::NewError("This error is not an unhandled exception error.");
   } else {
-    return Api::Error("Can only get exceptions from error handles.");
+    return Api::NewError("Can only get exceptions from error handles.");
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_ErrorGetStacktrace(Dart_Handle handle) {
   DARTSCOPE(Isolate::Current());
   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.");
-    }
+  if (obj.IsUnhandledException()) {
+    UnhandledException& error = UnhandledException::Handle();
+    error ^= obj.raw();
+    const Object& stacktrace = Object::Handle(error.stacktrace());
+    return Api::NewLocalHandle(stacktrace);
+  } else if (obj.IsError()) {
+    return Api::NewError("This error is not an unhandled exception error.");
   } else {
-    return Api::Error("Can only get stacktraces from error handles.");
+    return Api::NewError("Can only get stacktraces from error handles.");
   }
 }
 
 
-// TODO(turnidge): This clones Api::Error.  I need to use va_copy to
+// TODO(turnidge): This clones Api::NewError.  I need to use va_copy to
 // fix this but not sure if it available on all of our builds.
 DART_EXPORT Dart_Handle Dart_Error(const char* format, ...) {
   DARTSCOPE(Isolate::Current());
 
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
   char* buffer = reinterpret_cast<char*>(zone.Allocate(len + 1));
@@ skipping 21 matching lines @@
 DART_EXPORT Dart_Handle Dart_ToString(Dart_Handle object) {
   DARTSCOPE(Isolate::Current());
   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::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_IsSame(Dart_Handle obj1, Dart_Handle obj2,
                                     bool* value) {
@@ skipping 145 matching lines @@
   return reinterpret_cast<uint8_t*>(new_ptr);
 }
 
 
 DART_EXPORT Dart_Handle Dart_CreateSnapshot(uint8_t** buffer,
                                             intptr_t* size) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   TIMERSCOPE(time_creating_snapshot);
   if (buffer == NULL) {
-    return Api::Error("%s expects argument 'buffer' to be non-null.",
-                      CURRENT_FUNC);
+    return Api::NewError("%s expects argument 'buffer' to be non-null.",
+                         CURRENT_FUNC);
   }
   if (size == NULL) {
-    return Api::Error("%s expects argument 'size' to be non-null.",
-                      CURRENT_FUNC);
+    return Api::NewError("%s expects argument 'size' to be non-null.",
+                         CURRENT_FUNC);
   }
   const char* msg = CheckIsolateState(isolate,
                                       ClassFinalizer::kGeneratingSnapshot);
   if (msg != NULL) {
-    return Api::Error(msg);
+    return Api::NewError(msg);
   }
   // Since this is only a snapshot the root library should not be set.
   isolate->object_store()->set_root_library(Library::Handle());
   SnapshotWriter writer(Snapshot::kFull, buffer, ApiAllocator);
   writer.WriteFullSnapshot();
   *size = writer.BytesWritten();
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_CreateScriptSnapshot(uint8_t** buffer,
                                                   intptr_t* size) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   TIMERSCOPE(time_creating_snapshot);
   if (buffer == NULL) {
-    return Api::Error("%s expects argument 'buffer' to be non-null.",
-                      CURRENT_FUNC);
+    return Api::NewError("%s expects argument 'buffer' to be non-null.",
+                         CURRENT_FUNC);
   }
   if (size == NULL) {
-    return Api::Error("%s expects argument 'size' to be non-null.",
-                      CURRENT_FUNC);
+    return Api::NewError("%s expects argument 'size' to be non-null.",
+                         CURRENT_FUNC);
   }
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
-    return Api::Error(msg);
+    return Api::NewError(msg);
   }
   Library& library = Library::Handle(isolate->object_store()->root_library());
   if (library.IsNull()) {
-    return Api::Error("%s expects the isolate to have a script loaded in it.",
+    return
+        Api::NewError("%s expects the isolate to have a script loaded in it.",
                       CURRENT_FUNC);
   }
   ScriptSnapshotWriter writer(buffer, ApiAllocator);
   writer.WriteScriptSnapshot(library);
   *size = writer.BytesWritten();
   return Api::Success();
 }
 
 
 DART_EXPORT void Dart_InterruptIsolate(Dart_Isolate isolate) {
@@ skipping 23 matching lines @@
 DART_EXPORT Dart_Handle Dart_RunLoop() {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
 
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   Dart_Handle result;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     const Object& obj = Object::Handle(isolate->StandardRunLoop());
-    if (obj.IsUnhandledException()) {
-      result = Api::ErrorFromException(obj);
+    if (obj.IsError()) {
+      result = Api::NewLocalHandle(obj);
     } else {
       ASSERT(obj.IsNull());
       result = Api::Success();
     }
   } else {
     SetupErrorResult(&result);
   }
   isolate->set_long_jump_base(base);
   return result;
 }
@@ skipping 15 matching lines @@
 DART_EXPORT Dart_Handle Dart_HandleMessage(Dart_Port dest_port_id,
                                            Dart_Port reply_port_id,
                                            Dart_Message dart_message) {
   DARTSCOPE(Isolate::Current());
   const Instance& msg = Instance::Handle(DeserializeMessage(dart_message));
   // TODO(turnidge): Should this call be wrapped in a longjmp?
   const Object& result =
       Object::Handle(DartLibraryCalls::HandleMessage(dest_port_id,
                                                      reply_port_id,
                                                      msg));
-  if (result.IsUnhandledException()) {
-    return Api::ErrorFromException(result);
+  if (result.IsError()) {
+    return Api::NewLocalHandle(result);
   }
   ASSERT(result.IsNull());
   return Api::Success();
 }
 
 
 DART_EXPORT bool Dart_HasLivePorts() {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate);
   return isolate->live_ports() > 0;
@@ skipping 133 matching lines @@
   DARTSCOPE(Isolate::Current());
   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 if (result.IsError()) {
+    return Api::NewLocalHandle(result);
   } else {
-    return Api::Error("Expected boolean result from ==");
+    return Api::NewError("Expected boolean result from ==");
   }
 }
 
 
 // TODO(iposva): This call actually implements IsInstanceOfClass.
 // Do we also need a real Dart_IsInstanceOf, which should take an instance
 // rather than an object and a type rather than a class?
 DART_EXPORT Dart_Handle Dart_ObjectIsType(Dart_Handle object,
                                           Dart_Handle clazz,
                                           bool* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Class& cls = Class::CheckedHandle(Api::UnwrapHandle(clazz));
   if (cls.IsNull()) {
-    return Api::Error("instanceof check against null class");
+    return Api::NewError("instanceof check against null class");
   }
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   Instance& instance = Instance::Handle();
   instance ^= obj.raw();
   // Finalize all classes.
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
-    return Api::Error(msg);
+    return Api::NewError(msg);
   }
   const Type& type = Type::Handle(Type::NewNonParameterizedType(cls));
   *value = instance.IsInstanceOf(type, TypeArguments::Handle());
   return Api::Success();
 }
 
 
 // --- Numbers ----
 
 
@@ skipping 83 matching lines @@
     return Api::Success();
   } else {
     ASSERT(int_obj.IsBigint());
     Bigint& bigint = Bigint::Handle();
     bigint ^= int_obj.raw();
     if (BigintOperations::FitsIntoInt64(bigint)) {
       *value = BigintOperations::ToInt64(bigint);
       return Api::Success();
     }
   }
-  return Api::Error("%s: Integer %s cannot be represented as an int64_t.",
-                    CURRENT_FUNC, int_obj.ToCString());
+  return Api::NewError("%s: Integer %s cannot be represented as an int64_t.",
+                       CURRENT_FUNC, int_obj.ToCString());
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerToUint64(Dart_Handle integer,
                                              uint64_t* value) {
   DARTSCOPE(Isolate::Current());
   const Integer& int_obj = Api::UnwrapIntegerHandle(integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(integer, Integer);
   }
   if (int_obj.IsSmi() || int_obj.IsMint()) {
     if (!int_obj.IsNegative()) {
       *value = int_obj.AsInt64Value();
       return Api::Success();
     }
   } else {
     ASSERT(int_obj.IsBigint());
     Bigint& bigint = Bigint::Handle();
     bigint ^= int_obj.raw();
     if (BigintOperations::FitsIntoUint64(bigint)) {
       *value = BigintOperations::ToUint64(bigint);
       return Api::Success();
     }
   }
-  return Api::Error("%s: Integer %s cannot be represented as a uint64_t.",
-                    CURRENT_FUNC, int_obj.ToCString());
+  return Api::NewError("%s: Integer %s cannot be represented as a uint64_t.",
+                       CURRENT_FUNC, int_obj.ToCString());
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerToHexCString(Dart_Handle integer,
                                                  const char** value) {
   DARTSCOPE(Isolate::Current());
   const Integer& int_obj = Api::UnwrapIntegerHandle(integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(integer, Integer);
   }
@@ skipping 106 matching lines @@
 
 DART_EXPORT Dart_Handle Dart_StringLength(Dart_Handle str, intptr_t* len) {
   DARTSCOPE(Isolate::Current());
   const Object& obj = Object::Handle(Api::UnwrapHandle(str));
   if (obj.IsString()) {
     String& string_obj = String::Handle();
     string_obj ^= obj.raw();
     *len = string_obj.Length();
     return Api::Success();
   }
-  return Api::Error("Object is not a String");
+  return Api::NewError("Object is not a String");
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewString(const char* str) {
   DARTSCOPE(Isolate::Current());
   const String& obj = String::Handle(String::New(str));
   return Api::NewLocalHandle(obj);
 }
 
 
@@ skipping 32 matching lines @@
 
 
 DART_EXPORT Dart_Handle Dart_ExternalStringGetPeer(Dart_Handle object,
                                                    void** peer) {
   DARTSCOPE(Isolate::Current());
   const String& str = Api::UnwrapStringHandle(object);
   if (str.IsNull()) {
     RETURN_TYPE_ERROR(object, String);
   }
   if (!str.IsExternal()) {
-    return Api::Error("%s expects argument 'object' to be an external String.",
+    return
+        Api::NewError("%s expects argument 'object' to be an external String.",
                       CURRENT_FUNC);
   }
   if (peer == NULL) {
-    return Api::Error("%s expects argument 'peer' to be non-null.",
-                      CURRENT_FUNC);
+    return Api::NewError("%s expects argument 'peer' to be non-null.",
+                         CURRENT_FUNC);
   }
   *peer = str.GetPeer();
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewExternalString8(const uint8_t* codepoints,
                                                 intptr_t length,
                                                 void* peer,
                                                 Dart_PeerFinalizer callback) {
@@ skipping 37 matching lines @@
     if (string_obj.CharSize() == String::kOneByteChar) {
       intptr_t str_len = string_obj.Length();
       intptr_t copy_len = (str_len > *length) ? *length : str_len;
       for (intptr_t i = 0; i < copy_len; i++) {
         codepoints[i] = static_cast<uint8_t>(string_obj.CharAt(i));
       }
       *length= copy_len;
       return Api::Success();
     }
   }
-  return Api::Error(obj.IsString()
-                    ? "Object is not a String8"
-                    : "Object is not a String");
+  return Api::NewError(obj.IsString()
+                       ? "Object is not a String8"
+                       : "Object is not a String");
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringGet16(Dart_Handle str,
                                          uint16_t* codepoints,
                                          intptr_t* length) {
   DARTSCOPE(Isolate::Current());
   const Object& obj = Object::Handle(Api::UnwrapHandle(str));
   if (obj.IsString()) {
     String& string_obj = String::Handle();
     string_obj ^= obj.raw();
     if (string_obj.CharSize() <= String::kTwoByteChar) {
       intptr_t str_len = string_obj.Length();
       intptr_t copy_len = (str_len > *length) ? *length : str_len;
       for (intptr_t i = 0; i < copy_len; i++) {
         codepoints[i] = static_cast<uint16_t>(string_obj.CharAt(i));
       }
       *length = copy_len;
       return Api::Success();
     }
   }
-  return Api::Error(obj.IsString()
-                    ? "Object is not a String16"
-                    : "Object is not a String");
+  return Api::NewError(obj.IsString()
+                       ? "Object is not a String16"
+                       : "Object is not a String");
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringGet32(Dart_Handle str,
                                          uint32_t* codepoints,
                                          intptr_t* length) {
   DARTSCOPE(Isolate::Current());
   const Object& obj = Object::Handle(Api::UnwrapHandle(str));
   if (obj.IsString()) {
     String& string_obj = String::Handle();
     string_obj ^= obj.raw();
     intptr_t str_len = string_obj.Length();
     intptr_t copy_len = (str_len > *length) ? *length : str_len;
     for (intptr_t i = 0; i < copy_len; i++) {
       codepoints[i] = static_cast<uint32_t>(string_obj.CharAt(i));
     }
     *length = copy_len;
     return Api::Success();
   }
-  return Api::Error("Object is not a String");
+  return Api::NewError("Object is not a String");
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringToCString(Dart_Handle object,
                                              const char** result) {
   DARTSCOPE(Isolate::Current());
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   if (obj.IsString()) {
     const char* string_value = obj.ToCString();
     intptr_t string_length = strlen(string_value);
     char* res = reinterpret_cast<char*>(Api::Allocate(string_length + 1));
     if (res == NULL) {
-      return Api::Error("Unable to allocate memory");
+      return Api::NewError("Unable to allocate memory");
     }
     strncpy(res, string_value, string_length + 1);
     ASSERT(res[string_length] == '\0');
     *result = res;
     return Api::Success();
   }
-  return Api::Error("Object is not a String");
+  return Api::NewError("Object is not a String");
 }
 
 
 // --- Lists ---
 
 
 static RawInstance* GetListInstance(Isolate* isolate, const Object& obj) {
   if (obj.IsInstance()) {
     Instance& instance = Instance::Handle();
     instance ^= obj.raw();
@@ skipping 58 matching lines @@
         if (retval.IsSmi() || retval.IsMint()) {
           Integer& integer = Integer::Handle();
           integer ^= retval.raw();
           *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");
+            result =
+                Api::NewError("Length of List object is greater than the "
+                              "maximum value that 'len' parameter can hold");
           }
-        } else if (retval.IsUnhandledException()) {
-          result = Api::ErrorFromException(retval);
+        } else if (retval.IsError()) {
+          result = Api::NewLocalHandle(retval);
         } else {
-          result = Api::Error("Length of List object is not an integer");
+          result = Api::NewError("Length of List object is not an integer");
         }
       } else {
         SetupErrorResult(&result);
       }
       isolate->set_long_jump_base(base);
       return result;
     }
   }
-  return Api::Error("Object does not implement the list inteface");
+  return Api::NewError("Object does not implement the list inteface");
 }
 
 
 static RawObject* GetListAt(Isolate* isolate,
                             const Instance& instance,
                             const Integer& index,
                             const Function& function,
                             Dart_Handle* result) {
   ASSERT(isolate != NULL);
   ASSERT(result != NULL);
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   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::ErrorFromException(retval);
+    if (retval.IsError()) {
+      *result = Api::NewLocalHandle(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();
 }
 
 
 DART_EXPORT Dart_Handle Dart_ListGetAt(Dart_Handle list, intptr_t index) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(list));
   if (obj.IsArray()) {
     Array& array_obj = Array::Handle();
     array_obj ^= obj.raw();
     if ((index >= 0) && (index < array_obj.Length())) {
       const Object& element = Object::Handle(array_obj.At(index));
       return Api::NewLocalHandle(element);
     }
-    return Api::Error("Invalid index passed in to access array element");
+    return Api::NewError("Invalid index passed in to access array element");
   }
   // TODO(5526318): Make access to GrowableObjectArray more efficient.
   // Now check and handle a dart object that implements the List interface.
   const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
   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_IsError(result)) {
         return result;  // Error condition.
       }
       return Api::NewLocalHandle(element);
     }
   }
-  return Api::Error("Object does not implement the 'List' interface");
+  return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 static void SetListAt(Isolate* isolate,
                       const Instance& instance,
                       const Integer& index,
                       const Object& value,
                       const Function& function,
                       Dart_Handle* result) {
   ASSERT(isolate != NULL);
   ASSERT(result != NULL);
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     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::ErrorFromException(retval);
+    if (retval.IsError()) {
+      *result = Api::NewLocalHandle(retval);
     } else {
       *result = Api::Success();
     }
   } else {
     SetupErrorResult(result);
   }
   isolate->set_long_jump_base(base);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ListSetAt(Dart_Handle list,
                                        intptr_t index,
                                        Dart_Handle value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(list));
   if (obj.IsArray()) {
     if (obj.IsImmutableArray()) {
-      return Api::Error("Cannot modify immutable array");
+      return Api::NewError("Cannot modify immutable array");
     }
     Array& array_obj = Array::Handle();
     array_obj ^= obj.raw();
     const Object& value_obj = Object::Handle(Api::UnwrapHandle(value));
     if ((index >= 0) && (index < array_obj.Length())) {
       array_obj.SetAt(index, value_obj);
       return Api::Success();
     }
-    return Api::Error("Invalid index passed in to set array element");
+    return Api::NewError("Invalid index passed in to set array element");
   }
   // TODO(5526318): Make access to GrowableObjectArray more efficient.
   // Now check and handle a dart object that implements the List interface.
   const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
   if (!instance.IsNull()) {
     String& name = String::Handle(String::New("[]="));
     const Function& function = Function::Handle(
         Resolver::ResolveDynamic(instance, name, 3, 0));
     if (!function.IsNull()) {
       Dart_Handle result;
       const Integer& index_obj = Integer::Handle(Integer::New(index));
       const Object& value_obj = Object::Handle(Api::UnwrapHandle(value));
       SetListAt(isolate, instance, index_obj, value_obj, function, &result);
       return result;
     }
   }
-  return Api::Error("Object does not implement the 'List' interface");
+  return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 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(Api::UnwrapHandle(list));
   if (obj.IsArray()) {
     Array& array_obj = Array::Handle();
     array_obj ^= obj.raw();
     if ((offset + length) <= array_obj.Length()) {
       Object& element = Object::Handle();
       Integer& integer  = Integer::Handle();
       for (int i = 0; i < length; i++) {
         element = array_obj.At(offset + i);
         if (!element.IsInteger()) {
-          return Api::Error("%s expects the argument 'list' to be "
+          return Api::NewError("%s expects the argument 'list' to be "
                             "a List of int", CURRENT_FUNC);
         }
         integer ^= element.raw();
         native_array[i] = static_cast<uint8_t>(integer.AsInt64Value() & 0xff);
         ASSERT(integer.AsInt64Value() <= 0xff);
         // TODO(hpayer): value should always be smaller then 0xff. Add error
         // handling.
       }
       return Api::Success();
     }
-    return Api::Error("Invalid length passed in to access array elements");
+    return Api::NewError("Invalid length passed in to access array elements");
   }
   // TODO(5526318): Make access to GrowableObjectArray more efficient.
   // Now check and handle a dart object that implements the List interface.
   const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
   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& 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_IsError(result)) {
           return result;  // Error condition.
         }
         if (!element.IsInteger()) {
-          return Api::Error("%s expects the argument 'list' to be "
+          return Api::NewError("%s expects the argument 'list' to be "
                             "a List of int", CURRENT_FUNC);
         }
         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();
     }
   }
-  return Api::Error("Object does not implement the 'List' interface");
+  return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 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(Api::UnwrapHandle(list));
   if (obj.IsArray()) {
     if (obj.IsImmutableArray()) {
-      return Api::Error("Cannot modify immutable array");
+      return Api::NewError("Cannot modify immutable array");
     }
     Array& array_obj = Array::Handle();
     array_obj ^= obj.raw();
     Integer& integer = Integer::Handle();
     if ((offset + length) <= array_obj.Length()) {
       for (int i = 0; i < length; i++) {
         integer = Integer::New(native_array[i]);
         array_obj.SetAt(offset + i, integer);
       }
       return Api::Success();
     }
-    return Api::Error("Invalid length passed in to set array elements");
+    return Api::NewError("Invalid length passed in to set array elements");
   }
   // TODO(5526318): Make access to GrowableObjectArray more efficient.
   // Now check and handle a dart object that implements the List interface.
   const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
   if (!instance.IsNull()) {
     String& name = String::Handle(String::New("[]="));
     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_IsError(result)) {
           return result;  // Error condition.
         }
       }
       return Api::Success();
     }
   }
-  return Api::Error("Object does not implement the 'List' interface");
+  return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 // --- Closures ---
 
 
 DART_EXPORT bool Dart_IsClosure(Dart_Handle object) {
   DARTSCOPE(Isolate::Current());
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   return obj.IsClosure();
 }
 
 
 // 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(Isolate* isolate,
                           const Closure& closure,
                           GrowableArray<const Object*>& args,
                           Dart_Handle* result) {
   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));
-    if (retval.IsUnhandledException()) {
-      *result = Api::ErrorFromException(retval);
-    } else {
-      *result = Api::NewLocalHandle(retval);
-    }
+    *result = Api::NewLocalHandle(retval);
   } else {
     SetupErrorResult(result);
   }
   isolate->set_long_jump_base(base);
 }
 
 
 DART_EXPORT Dart_Handle Dart_InvokeClosure(Dart_Handle closure,
                                            int number_of_arguments,
                                            Dart_Handle* arguments) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(closure));
   if (obj.IsNull()) {
-    return Api::Error("Null object passed in to invoke closure");
+    return Api::NewError("Null object passed in to invoke closure");
   }
   if (!obj.IsClosure()) {
-    return Api::Error("Invalid closure passed to invoke closure");
+    return Api::NewError("Invalid closure passed to invoke closure");
   }
   ASSERT(ClassFinalizer::AllClassesFinalized());
 
   // Now try to invoke the closure.
   Closure& closure_obj = Closure::Handle();
   closure_obj ^= obj.raw();
   Dart_Handle retval;
   GrowableArray<const Object*> dart_arguments(number_of_arguments);
   for (int i = 0; i < number_of_arguments; i++) {
     const Object& arg = Object::Handle(Api::UnwrapHandle(arguments[i]));
@@ skipping 26 matching lines @@
 DART_EXPORT Dart_Handle Dart_InvokeStatic(Dart_Handle library_in,
                                           Dart_Handle class_name_in,
                                           Dart_Handle function_name_in,
                                           int number_of_arguments,
                                           Dart_Handle* arguments) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   // Finalize all classes.
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
-    return Api::Error(msg);
+    return Api::NewError(msg);
   }
 
   // Now try to resolve and invoke the static function.
   const Library& library =
       Library::CheckedHandle(Api::UnwrapHandle(library_in));
   if (library.IsNull()) {
-    return Api::Error("No library specified");
+    return Api::NewError("No library specified");
   }
   const String& class_name =
       String::CheckedHandle(Api::UnwrapHandle(class_name_in));
   const String& function_name =
       String::CheckedHandle(Api::UnwrapHandle(function_name_in));
   const Function& function = Function::Handle(
       Resolver::ResolveStatic(library,
                               class_name,
                               function_name,
                               number_of_arguments,
                               Array::Handle(),  // Named arguments are not yet
                                                 // supported in the API.
                               Resolver::kIsQualified));
   if (function.IsNull()) {
     char* msg;
     if (class_name.IsNull()) {
       const char* format = "Unable to find entrypoint: %s()";
       intptr_t length = OS::SNPrint(NULL, 0, format, function_name.ToCString());
       msg = reinterpret_cast<char*>(Api::Allocate(length + 1));
       OS::SNPrint(msg, (length + 1), format, function_name.ToCString());
     } else {
       const char* format = "Unable to find entrypoint: static %s.%s()";
       intptr_t length = OS::SNPrint(NULL, 0, format,
                                     class_name.ToCString(),
                                     function_name.ToCString());
       msg = reinterpret_cast<char*>(Api::Allocate(length + 1));
       OS::SNPrint(msg, (length + 1), format,
                   class_name.ToCString(), function_name.ToCString());
     }
-    return Api::Error(msg);
+    return Api::NewError(msg);
   }
   Dart_Handle retval;
   GrowableArray<const Object*> dart_arguments(number_of_arguments);
   for (int i = 0; i < number_of_arguments; i++) {
     const Object& arg = Object::Handle(Api::UnwrapHandle(arguments[i]));
     dart_arguments.Add(&arg);
   }
   InvokeStatic(isolate, function, dart_arguments, &retval);
   return retval;
 }
 
 
 DART_EXPORT Dart_Handle Dart_InvokeDynamic(Dart_Handle object,
                                            Dart_Handle function_name,
                                            int number_of_arguments,
                                            Dart_Handle* arguments) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   // Let the resolver figure out the correct target for null receiver.
   // E.g., (null).toString() should execute correctly.
   if (!obj.IsNull() && !obj.IsInstance()) {
-    return Api::Error(
+    return Api::NewError(
         "Invalid receiver (not instance) passed to invoke dynamic");
   }
   if (function_name == NULL) {
-    return Api::Error("Invalid function name specified");
+    return Api::NewError("Invalid function name specified");
   }
   ASSERT(ClassFinalizer::AllClassesFinalized());
 
   // Now try to resolve and invoke the dynamic function on this object.
   Instance& receiver = Instance::Handle();
   receiver ^= obj.raw();
   const String& name = String::CheckedHandle(Api::UnwrapHandle(function_name));
   const Function& function = Function::Handle(
       Resolver::ResolveDynamic(receiver,
                                name,
                                (number_of_arguments + 1),
                                0));  // Named args not yet supported in API.
   if (function.IsNull()) {
     // TODO(5415268): Invoke noSuchMethod instead of failing.
     OS::PrintErr("Unable to find instance function: %s\n", name.ToCString());
-    return Api::Error("Unable to find instance function");
+    return Api::NewError("Unable to find instance function");
   }
   Dart_Handle retval;
   GrowableArray<const Object*> dart_arguments(number_of_arguments);
   for (int i = 0; i < number_of_arguments; i++) {
     const Object& arg = Object::Handle(Api::UnwrapHandle(arguments[i]));
     dart_arguments.Add(&arg);
   }
   InvokeDynamic(isolate, receiver, function, dart_arguments, &retval);
   return retval;
 }
@@ skipping 16 matching lines @@
   return value.raw() == Object::sentinel();
 }
 
 
 static Dart_Handle LookupStaticField(Dart_Handle clazz,
                                      Dart_Handle field_name,
                                      bool is_getter) {
   const Object& param1 = Object::Handle(Api::UnwrapHandle(clazz));
   const Object& param2 = Object::Handle(Api::UnwrapHandle(field_name));
   if (param1.IsNull() || !param1.IsClass()) {
-    return Api::Error("Invalid class specified");
+    return Api::NewError("Invalid class specified");
   }
   if (param2.IsNull() || !param2.IsString()) {
-    return Api::Error("Invalid field name specified");
+    return Api::NewError("Invalid field name specified");
   }
   Class& cls = Class::Handle();
   cls ^= param1.raw();
   String& fld_name = String::Handle();
   fld_name ^= param2.raw();
   const Field& fld = Field::Handle(cls.LookupStaticField(fld_name));
   if (is_getter && UseGetterForStaticField(fld)) {
     const String& func_name = String::Handle(Field::GetterName(fld_name));
     const Function& function =
         Function::Handle(cls.LookupStaticFunction(func_name));
     if (!function.IsNull()) {
       return Api::NewLocalHandle(function);
     }
-    return Api::Error("Specified field is not found in the class");
+    return Api::NewError("Specified field is not found in the class");
   }
   if (fld.IsNull()) {
-    return Api::Error("Specified field is not found in the class");
+    return Api::NewError("Specified field is not found in the class");
   }
   return Api::NewLocalHandle(fld);
 }
 
 
 static Dart_Handle LookupInstanceField(const Object& object,
                                        Dart_Handle name,
                                        bool is_getter) {
   const Object& param = Object::Handle(Api::UnwrapHandle(name));
   if (param.IsNull() || !param.IsString()) {
-    return Api::Error("Invalid field name specified");
+    return Api::NewError("Invalid field name specified");
   }
   String& field_name = String::Handle();
   field_name ^= param.raw();
   String& func_name = String::Handle();
   Field& fld = Field::Handle();
   Class& cls = Class::Handle(object.clazz());
   while (!cls.IsNull()) {
     fld = cls.LookupInstanceField(field_name);
     if (!fld.IsNull()) {
       if (!is_getter && fld.is_final()) {
-        return Api::Error("Cannot set value of final fields");
+        return Api::NewError("Cannot set value of final fields");
       }
       func_name = (is_getter
                    ? Field::GetterName(field_name)
                    : Field::SetterName(field_name));
       const Function& function = Function::Handle(
           cls.LookupDynamicFunction(func_name));
       if (function.IsNull()) {
-        return Api::Error("Unable to find accessor function in the class");
+        return Api::NewError("Unable to find accessor function in the class");
       }
       return Api::NewLocalHandle(function);
     }
     cls = cls.SuperClass();
   }
-  return Api::Error("Unable to find field in the class");
+  return Api::NewError("Unable to find field in the class");
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetStaticField(Dart_Handle cls,
                                             Dart_Handle name) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   Dart_Handle result = LookupStaticField(cls, name, kGetter);
   if (::Dart_IsError(result)) {
     return result;
@@ skipping 21 matching lines @@
                                             Dart_Handle name,
                                             Dart_Handle value) {
   DARTSCOPE(Isolate::Current());
   Dart_Handle result = LookupStaticField(cls, name, kSetter);
   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");
+    return Api::NewError(
+        "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) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& param = Object::Handle(Api::UnwrapHandle(obj));
   if (param.IsNull() || !param.IsInstance()) {
-    return Api::Error("Invalid object passed in to access instance field");
+    return Api::NewError("Invalid object passed in to access instance field");
   }
   Instance& object = Instance::Handle();
   object ^= param.raw();
   Dart_Handle result = LookupInstanceField(object, name, kGetter);
   if (::Dart_IsError(result)) {
     return result;
   }
   Function& func = Function::Handle();
   func ^= Api::UnwrapHandle(result);
   GrowableArray<const Object*> arguments;
   InvokeDynamic(isolate, object, func, arguments, &result);
   return result;
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetInstanceField(Dart_Handle obj,
                                               Dart_Handle name,
                                               Dart_Handle value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& param = Object::Handle(Api::UnwrapHandle(obj));
   if (param.IsNull() || !param.IsInstance()) {
-    return Api::Error("Invalid object passed in to access instance field");
+    return Api::NewError("Invalid object passed in to access instance field");
   }
   Instance& object = Instance::Handle();
   object ^= param.raw();
   Dart_Handle result = LookupInstanceField(object, name, kSetter);
   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(isolate, object, func, arguments, &result);
   return result;
 }
 
 
 DART_EXPORT Dart_Handle Dart_CreateNativeWrapperClass(Dart_Handle library,
                                                       Dart_Handle name,
                                                       int field_count) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& param = Object::Handle(Api::UnwrapHandle(name));
   if (param.IsNull() || !param.IsString() || field_count <= 0) {
-    return Api::Error(
+    return Api::NewError(
         "Invalid arguments passed to Dart_CreateNativeWrapperClass");
   }
   String& cls_name = String::Handle();
   cls_name ^= param.raw();
   cls_name = String::NewSymbol(cls_name);
   Library& lib = Library::Handle();
   lib ^= Api::UnwrapHandle(library);
   if (lib.IsNull()) {
-    return Api::Error(
+    return Api::NewError(
         "Invalid arguments passed to Dart_CreateNativeWrapperClass");
   }
   const Class& cls = Class::Handle(Class::NewNativeWrapper(&lib,
                                                            cls_name,
                                                            field_count));
   if (cls.IsNull()) {
-    return Api::Error(
+    return Api::NewError(
         "Unable to create native wrapper class : already exists");
   }
   return Api::NewLocalHandle(cls);
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeInstanceField(Dart_Handle obj,
                                                     int index,
                                                     intptr_t* value) {
   DARTSCOPE(Isolate::Current());
   const Object& param = Object::Handle(Api::UnwrapHandle(obj));
   if (param.IsNull() || !param.IsInstance()) {
-    return Api::Error(
+    return Api::NewError(
         "Invalid object passed in to access native instance field");
   }
   Instance& object = Instance::Handle();
   object ^= param.raw();
   if (!object.IsValidNativeIndex(index)) {
-    return Api::Error(
+    return Api::NewError(
         "Invalid index passed in to access native instance field");
   }
   *value = object.GetNativeField(index);
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetNativeInstanceField(Dart_Handle obj,
                                                     int index,
                                                     intptr_t value) {
   DARTSCOPE(Isolate::Current());
   const Object& param = Object::Handle(Api::UnwrapHandle(obj));
   if (param.IsNull() || !param.IsInstance()) {
-    return Api::Error("Invalid object passed in to set native instance field");
+    return Api::NewError(
+        "Invalid object passed in to set native instance field");
   }
   Instance& object = Instance::Handle();
   object ^= param.raw();
   if (!object.IsValidNativeIndex(index)) {
-    return Api::Error("Invalid index passed in to set native instance field");
+    return Api::NewError(
+        "Invalid index passed in to set native instance field");
   }
   object.SetNativeField(index, value);
   return Api::Success();
 }
 
 
 // --- Exceptions ----
 
 
 DART_EXPORT Dart_Handle Dart_ThrowException(Dart_Handle exception) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   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");
+    return Api::NewError("No Dart frames on stack, cannot throw exception");
   }
   const Instance& excp = Instance::CheckedHandle(Api::UnwrapHandle(exception));
   // Unwind all the API scopes till the exit frame before throwing an
   // exception.
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   state->UnwindScopes(isolate->top_exit_frame_info());
   Exceptions::Throw(excp);
-  return Api::Error("Exception was not thrown, internal error");
+  return Api::NewError("Exception was not thrown, internal error");
 }
 
 
 DART_EXPORT Dart_Handle Dart_ReThrowException(Dart_Handle exception,
                                               Dart_Handle stacktrace) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   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");
+    return Api::NewError("No Dart frames on stack, cannot throw exception");
   }
   DARTSCOPE(isolate);
   const Instance& excp = Instance::CheckedHandle(Api::UnwrapHandle(exception));
   const Instance& stk = Instance::CheckedHandle(Api::UnwrapHandle(stacktrace));
   // Unwind all the API scopes till the exit frame before throwing an
   // exception.
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   state->UnwindScopes(isolate->top_exit_frame_info());
   Exceptions::ReThrow(excp, stk);
-  return Api::Error("Exception was not re thrown, internal error");
+  return Api::NewError("Exception was not re thrown, internal error");
 }
 
 
 // --- Native functions ---
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeArgument(Dart_NativeArguments args,
                                                int index) {
   DARTSCOPE(Isolate::Current());
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
@@ skipping 65 matching lines @@
   if (url_str.IsNull()) {
     RETURN_TYPE_ERROR(url, String);
   }
   const String& source_str = Api::UnwrapStringHandle(source);
   if (source_str.IsNull()) {
     RETURN_TYPE_ERROR(source, String);
   }
   Library& library = Library::Handle(isolate->object_store()->root_library());
   if (!library.IsNull()) {
     const String& library_url = String::Handle(library.url());
-    return Api::Error("%s: A script has already been loaded from '%s'.",
-                      CURRENT_FUNC, library_url.ToCString());
+    return Api::NewError("%s: A script has already been loaded from '%s'.",
+                         CURRENT_FUNC, library_url.ToCString());
   }
   isolate->set_library_tag_handler(handler);
   library = Library::New(url_str);
   library.Register();
   isolate->object_store()->set_root_library(library);
   Dart_Handle result;
   CompileSource(isolate,
                 library,
                 url_str,
                 source_str,
                 RawScript::kScript,
                 &result);
   return result;
 }
 
 
 DART_EXPORT Dart_Handle Dart_LoadScriptFromSnapshot(const uint8_t* buffer) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   TIMERSCOPE(time_script_loading);
   if (buffer == NULL) {
-    return Api::Error("%s expects argument 'buffer' to be non-null.",
-                      CURRENT_FUNC);
+    return Api::NewError("%s expects argument 'buffer' to be non-null.",
+                         CURRENT_FUNC);
   }
   const Snapshot* snapshot = Snapshot::SetupFromBuffer(buffer);
   if (!snapshot->IsScriptSnapshot()) {
-    return Api::Error("%s expects parameter 'buffer' to be a script type"
-                      " snapshot", CURRENT_FUNC);
+    return Api::NewError("%s expects parameter 'buffer' to be a script type"
+                         " snapshot", CURRENT_FUNC);
   }
   Library& library = Library::Handle(isolate->object_store()->root_library());
   if (!library.IsNull()) {
     const String& library_url = String::Handle(library.url());
-    return Api::Error("%s: A script has already been loaded from '%s'.",
-                      CURRENT_FUNC, library_url.ToCString());
+    return Api::NewError("%s: A script has already been loaded from '%s'.",
+                         CURRENT_FUNC, library_url.ToCString());
   }
   SnapshotReader reader(snapshot, isolate);
   const Object& tmp = Object::Handle(reader.ReadObject());
   if (!tmp.IsLibrary()) {
-    return Api::Error("%s: Unable to deserialize snapshot correctly.",
-                      CURRENT_FUNC);
+    return Api::NewError("%s: Unable to deserialize snapshot correctly.",
+                         CURRENT_FUNC);
   }
   library ^= tmp.raw();
   library.Register();
   isolate->object_store()->set_root_library(library);
   return Api::NewLocalHandle(library);
 }
 
 
 static void CompileAll(Isolate* isolate, Dart_Handle* result) {
   *result = Api::Success();
   ASSERT(isolate != NULL);
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     Library::CompileAll();
   } else {
     SetupErrorResult(result);
   }
   isolate->set_long_jump_base(base);
 }
 
 
 DART_EXPORT Dart_Handle Dart_CompileAll() {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   Dart_Handle result;
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
-    return Api::Error(msg);
+    return Api::NewError(msg);
   }
   CompileAll(isolate, &result);
   return result;
 }
 
 
 DART_EXPORT bool Dart_IsLibrary(Dart_Handle object) {
   DARTSCOPE(Isolate::Current());
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   return obj.IsLibrary();
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetClass(Dart_Handle library, Dart_Handle name) {
   DARTSCOPE(Isolate::Current());
   const Object& param = Object::Handle(Api::UnwrapHandle(name));
   if (param.IsNull() || !param.IsString()) {
-    return Api::Error("Invalid class name specified");
+    return Api::NewError("Invalid class name specified");
   }
   const Library& lib = Library::CheckedHandle(Api::UnwrapHandle(library));
   if (lib.IsNull()) {
-    return Api::Error("Invalid parameter, Unknown library specified");
+    return Api::NewError("Invalid parameter, Unknown library specified");
   }
   String& cls_name = String::Handle();
   cls_name ^= param.raw();
   const Class& cls = Class::Handle(lib.LookupClass(cls_name));
   if (cls.IsNull()) {
     const String& lib_name = String::Handle(lib.name());
-    return Api::Error("Class '%s' not found in library '%s'.",
-                      cls_name.ToCString(), lib_name.ToCString());
+    return Api::NewError("Class '%s' not found in library '%s'.",
+                         cls_name.ToCString(), lib_name.ToCString());
   }
   return Api::NewLocalHandle(cls);
 }
 
 
 DART_EXPORT Dart_Handle Dart_LibraryUrl(Dart_Handle library) {
   DARTSCOPE(Isolate::Current());
   const Library& lib = Api::UnwrapLibraryHandle(library);
   if (lib.IsNull()) {
     RETURN_TYPE_ERROR(library, Library);
   }
   const String& url = String::Handle(lib.url());
   ASSERT(!url.IsNull());
   return Api::NewLocalHandle(url);
 }
 
 
 DART_EXPORT Dart_Handle Dart_LookupLibrary(Dart_Handle url) {
   DARTSCOPE(Isolate::Current());
   const String& url_str = Api::UnwrapStringHandle(url);
   if (url_str.IsNull()) {
     RETURN_TYPE_ERROR(url, String);
   }
   const Library& library = Library::Handle(Library::LookupLibrary(url_str));
   if (library.IsNull()) {
-    return Api::Error("%s: library '%s' not found.",
-                      CURRENT_FUNC, url_str.ToCString());
+    return Api::NewError("%s: library '%s' not found.",
+                         CURRENT_FUNC, url_str.ToCString());
   } else {
     return Api::NewLocalHandle(library);
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_LoadLibrary(Dart_Handle url, Dart_Handle source) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& url_str = Api::UnwrapStringHandle(url);
   if (url_str.IsNull()) {
     RETURN_TYPE_ERROR(url, String);
   }
   const String& source_str = Api::UnwrapStringHandle(source);
   if (source_str.IsNull()) {
     RETURN_TYPE_ERROR(source, String);
   }
   Library& library = Library::Handle(Library::LookupLibrary(url_str));
   if (library.IsNull()) {
     library = Library::New(url_str);
     library.Register();
   } else if (!library.LoadNotStarted()) {
     // The source for this library has either been loaded or is in the
     // process of loading.  Return an error.
-    return Api::Error("%s: library '%s' has already been loaded.",
-                      CURRENT_FUNC, url_str.ToCString());
+    return Api::NewError("%s: library '%s' has already been loaded.",
+                         CURRENT_FUNC, url_str.ToCString());
   }
   Dart_Handle result;
   CompileSource(isolate,
                 library,
                 url_str,
                 source_str,
                 RawScript::kLibrary,
                 &result);
   return result;
 }
@@ skipping 76 matching lines @@
     }
     delete debug_region;
   } else {
     *buffer = NULL;
     *buffer_size = 0;
   }
 }
 
 
 }  // namespace dart