Check for an error handle passed in, in all dart_api functions that return a handle. Pass the erro…

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 1807 matching lines @@
   }                                                                            \
   return Api::NewError("Invalid index passed in to access list element");      \
 
 
 DART_EXPORT Dart_Handle Dart_ListGetAt(Dart_Handle list, intptr_t index) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
   if (obj.IsArray()) {
     GET_LIST_ELEMENT(isolate, Array, obj, index);
+  } else if (obj.IsGrowableObjectArray()) {
+    GET_LIST_ELEMENT(isolate, GrowableObjectArray, obj, index);
+  } else if (obj.IsError()) {
+    return list;
+  } else {
+    // Check and handle a dart object that implements the List interface.
+    const Instance& instance =
+        Instance::Handle(isolate, GetListInstance(isolate, obj));
+    if (!instance.IsNull()) {
+      String& name = String::Handle(isolate, String::New("[]"));
+      const Function& function =
+          Function::Handle(isolate,
+                           Resolver::ResolveDynamic(instance, name, 2, 0));
+      if (!function.IsNull()) {
+        GrowableArray<const Object*> args(1);
+        Integer& indexobj = Integer::Handle(isolate);
+        indexobj = Integer::New(index);
+        args.Add(&indexobj);
+        const Array& kNoArgumentNames = Array::Handle(isolate);
+        return Api::NewHandle(isolate, DartEntry::InvokeDynamic(
+            instance, function, args, kNoArgumentNames));
+      }
+    }
+    return Api::NewError("Object does not implement the 'List' interface");
   }
-  if (obj.IsGrowableObjectArray()) {
-    GET_LIST_ELEMENT(isolate, GrowableObjectArray, obj, index);
-  }
-  // Now check and handle a dart object that implements the List interface.
-  const Instance& instance =
-      Instance::Handle(isolate, GetListInstance(isolate, obj));
-  if (!instance.IsNull()) {
-    String& name = String::Handle(isolate, String::New("[]"));
-    const Function& function =
-        Function::Handle(isolate,
-                         Resolver::ResolveDynamic(instance, name, 2, 0));
-    if (!function.IsNull()) {
-      GrowableArray<const Object*> args(1);
-      Integer& indexobj = Integer::Handle(isolate);
-      indexobj = Integer::New(index);
-      args.Add(&indexobj);
-      const Array& kNoArgumentNames = Array::Handle(isolate);
-      return Api::NewHandle(
-          isolate,
-          DartEntry::InvokeDynamic(instance, function, args, kNoArgumentNames));
-    }
-  }
-  return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 #define SET_LIST_ELEMENT(isolate, type, obj, index, value)                     \
   const type& array = type::Cast(obj);                                         \
   const Object& value_obj = Object::Handle(isolate, Api::UnwrapHandle(value)); \
+  if (!value_obj.IsNull() && !value_obj.IsInstance()) {                        \
+    RETURN_TYPE_ERROR(isolate, value, Instance);                               \
+  }                                                                            \
   if ((index >= 0) && (index < array.Length())) {                              \
     array.SetAt(index, value_obj);                                             \
     return Api::Success(isolate);                                              \
   }                                                                            \
   return Api::NewError("Invalid index passed in to set list element");         \
 
 
 DART_EXPORT Dart_Handle Dart_ListSetAt(Dart_Handle list,
                                        intptr_t index,
                                        Dart_Handle value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
   if (obj.IsArray()) {
     if (obj.IsImmutableArray()) {
       return Api::NewError("Cannot modify immutable array");
     }
     SET_LIST_ELEMENT(isolate, Array, obj, index, value);
+  } else if (obj.IsGrowableObjectArray()) {
+    SET_LIST_ELEMENT(isolate, GrowableObjectArray, obj, index, value);
+  } else if (obj.IsError()) {
+    return list;
+  } else {
+    // Check and handle a dart object that implements the List interface.
+    const Instance& instance =
+        Instance::Handle(isolate, GetListInstance(isolate, obj));
+    if (!instance.IsNull()) {
+      String& name = String::Handle(isolate, String::New("[]="));
+      const Function& function =
+          Function::Handle(isolate,
+                           Resolver::ResolveDynamic(instance, name, 3, 0));
+      if (!function.IsNull()) {
+        const Integer& index_obj =
+            Integer::Handle(isolate, Integer::New(index));
+        const Object& value_obj =
+            Object::Handle(isolate, Api::UnwrapHandle(value));
+        if (!value_obj.IsNull() && !value_obj.IsInstance()) {
+          RETURN_TYPE_ERROR(isolate, value, Instance);
+        }
+        GrowableArray<const Object*> args(2);
+        args.Add(&index_obj);
+        args.Add(&value_obj);
+        const Array& kNoArgumentNames = Array::Handle(isolate);
+        return Api::NewHandle(isolate, DartEntry::InvokeDynamic(
+            instance, function, args, kNoArgumentNames));
+      }
+    }
+    return Api::NewError("Object does not implement the 'List' interface");
   }
-  if (obj.IsGrowableObjectArray()) {
-    SET_LIST_ELEMENT(isolate, GrowableObjectArray, obj, index, value);
-  }
-  // Now check and handle a dart object that implements the List interface.
-  const Instance& instance =
-      Instance::Handle(isolate, GetListInstance(isolate, obj));
-  if (!instance.IsNull()) {
-    String& name = String::Handle(isolate, String::New("[]="));
-    const Function& function =
-        Function::Handle(isolate,
-                         Resolver::ResolveDynamic(instance, name, 3, 0));
-    if (!function.IsNull()) {
-      const Integer& index_obj = Integer::Handle(isolate, Integer::New(index));
-      const Object& value_obj =
-          Object::Handle(isolate, Api::UnwrapHandle(value));
-      GrowableArray<const Object*> args(2);
-      args.Add(&index_obj);
-      args.Add(&value_obj);
-      const Array& kNoArgumentNames = Array::Handle(isolate);
-      return Api::NewHandle(
-          isolate,
-          DartEntry::InvokeDynamic(instance, function, args, kNoArgumentNames));
-    }
-  }
-  return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 // TODO(hpayer): value should always be smaller then 0xff. Add error handling.
 #define GET_LIST_ELEMENT_AS_BYTES(isolate, type, obj, native_array, offset,    \
                                    length)                                     \
   const type& array = type::Cast(obj);                                         \
   if (Utils::RangeCheck(offset, length, array.Length())) {                     \
     Object& element = Object::Handle(isolate);                                 \
     for (int i = 0; i < length; i++) {                                         \
@@ skipping 18 matching lines @@
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
   if (obj.IsUint8Array() || obj.IsExternalUint8Array()) {
     const ByteArray& byte_array = ByteArray::Cast(obj);
     if (Utils::RangeCheck(offset, length, byte_array.Length())) {
       ByteArray::Copy(native_array, byte_array, offset, length);
       return Api::Success(isolate);
     }
     return Api::NewError("Invalid length passed in to access list elements");
-  }
-  if (obj.IsArray()) {
+  } else if (obj.IsArray()) {
     GET_LIST_ELEMENT_AS_BYTES(isolate,
                               Array,
                               obj,
                               native_array,
                               offset,
-                              length);  }
-  if (obj.IsGrowableObjectArray()) {
+                              length);
+  } else if (obj.IsGrowableObjectArray()) {
     GET_LIST_ELEMENT_AS_BYTES(isolate,
                               GrowableObjectArray,
                               obj,
                               native_array,
                               offset,
                               length);
+  } else if (obj.IsError()) {
+    return list;
+  } else {
+    // Check and handle a dart object that implements the List interface.
+    const Instance& instance =
+        Instance::Handle(isolate, GetListInstance(isolate, obj));
+    if (!instance.IsNull()) {
+      String& name = String::Handle(isolate, String::New("[]"));
+      const Function& function =
+          Function::Handle(isolate,
+                           Resolver::ResolveDynamic(instance, name, 2, 0));
+      if (!function.IsNull()) {
+        Object& result = Object::Handle(isolate);
+        Integer& intobj = Integer::Handle(isolate);
+        for (int i = 0; i < length; i++) {
+          intobj = Integer::New(offset + i);
+          GrowableArray<const Object*> args(1);
+          args.Add(&intobj);
+          const Array& kNoArgumentNames = Array::Handle(isolate);
+          result = DartEntry::InvokeDynamic(
+              instance, function, args, kNoArgumentNames);
+          if (result.IsError()) {
+            return Api::NewHandle(isolate, result.raw());
+          }
+          if (!result.IsInteger()) {
+            return Api::NewError("%s expects the argument 'list' to be "
+                                 "a List of int", CURRENT_FUNC);
+          }
+          const Integer& integer_result = Integer::Cast(result);
+          ASSERT(integer_result.AsInt64Value() <= 0xff);
+          // TODO(hpayer): value should always be smaller then 0xff. Add error
+          // handling.
+          native_array[i] =
+              static_cast<uint8_t>(integer_result.AsInt64Value() & 0xff);
+        }
+        return Api::Success(isolate);
+      }
+    }
+    return Api::NewError("Object does not implement the 'List' interface");
   }
-  // Now check and handle a dart object that implements the List interface.
-  const Instance& instance =
-      Instance::Handle(isolate, GetListInstance(isolate, obj));
-  if (!instance.IsNull()) {
-    String& name = String::Handle(isolate, String::New("[]"));
-    const Function& function =
-        Function::Handle(isolate,
-                         Resolver::ResolveDynamic(instance, name, 2, 0));
-    if (!function.IsNull()) {
-      Object& result = Object::Handle(isolate);
-      Integer& intobj = Integer::Handle(isolate);
-      for (int i = 0; i < length; i++) {
-        intobj = Integer::New(offset + i);
-        GrowableArray<const Object*> args(1);
-        args.Add(&intobj);
-        const Array& kNoArgumentNames = Array::Handle(isolate);
-        result = DartEntry::InvokeDynamic(
-            instance, function, args, kNoArgumentNames);
-        if (result.IsError()) {
-          return Api::NewHandle(isolate, result.raw());
-        }
-        if (!result.IsInteger()) {
-          return Api::NewError("%s expects the argument 'list' to be "
-                               "a List of int", CURRENT_FUNC);
-        }
-        const Integer& integer_result = Integer::Cast(result);
-        ASSERT(integer_result.AsInt64Value() <= 0xff);
-        // TODO(hpayer): value should always be smaller then 0xff. Add error
-        // handling.
-        native_array[i] =
-            static_cast<uint8_t>(integer_result.AsInt64Value() & 0xff);
-      }
-      return Api::Success(isolate);
-    }
-  }
-  return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 #define SET_LIST_ELEMENT_AS_BYTES(isolate, type, obj, native_array, offset,    \
                                   length)                                      \
   const type& array = type::Cast(obj);                                         \
   Integer& integer = Integer::Handle(isolate);                                 \
   if (Utils::RangeCheck(offset, length, array.Length())) {                     \
     for (int i = 0; i < length; i++) {                                         \
       integer = Integer::New(native_array[i]);                                 \
@@ skipping 11 matching lines @@
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
   if (obj.IsUint8Array() || obj.IsExternalUint8Array()) {
     const ByteArray& byte_array = ByteArray::Cast(obj);
     if (Utils::RangeCheck(offset, length, byte_array.Length())) {
       ByteArray::Copy(byte_array, offset, native_array, length);
       return Api::Success(isolate);
     }
     return Api::NewError("Invalid length passed in to set list elements");
-  }
-  if (obj.IsArray()) {
+  } else if (obj.IsArray()) {
     if (obj.IsImmutableArray()) {
       return Api::NewError("Cannot modify immutable array");
     }
     SET_LIST_ELEMENT_AS_BYTES(isolate,
                               Array,
                               obj,
                               native_array,
                               offset,
                               length);
-  }
-  if (obj.IsGrowableObjectArray()) {
+  } else if (obj.IsGrowableObjectArray()) {
     SET_LIST_ELEMENT_AS_BYTES(isolate,
                               GrowableObjectArray,
                               obj,
                               native_array,
                               offset,
                               length);
+  } else if (obj.IsError()) {
+    return list;
+  } else {
+  // Check and handle a dart object that implements the List interface.
+    const Instance& instance =
+        Instance::Handle(isolate, GetListInstance(isolate, obj));
+    if (!instance.IsNull()) {
+      String& name = String::Handle(isolate, String::New("[]="));
+      const Function& function =
+          Function::Handle(isolate,
+                           Resolver::ResolveDynamic(instance, name, 3, 0));
+      if (!function.IsNull()) {
+        Integer& indexobj = Integer::Handle(isolate);
+        Integer& valueobj = Integer::Handle(isolate);
+        for (int i = 0; i < length; i++) {
+          indexobj = Integer::New(offset + i);
+          valueobj = Integer::New(native_array[i]);
+          GrowableArray<const Object*> args(2);
+          args.Add(&indexobj);
+          args.Add(&valueobj);
+          const Array& kNoArgumentNames = Array::Handle(isolate);
+          const Object& result = Object::Handle(
+              isolate,
+              DartEntry::InvokeDynamic(
+                  instance, function, args, kNoArgumentNames));
+          if (result.IsError()) {
+            return Api::NewHandle(isolate, result.raw());
+          }
+        }
+        return Api::Success(isolate);
+      }
+    }
+    return Api::NewError("Object does not implement the 'List' interface");
   }
-  // Now check and handle a dart object that implements the List interface.
-  const Instance& instance =
-      Instance::Handle(isolate, GetListInstance(isolate, obj));
-  if (!instance.IsNull()) {
-    String& name = String::Handle(isolate, String::New("[]="));
-    const Function& function =
-        Function::Handle(isolate,
-                         Resolver::ResolveDynamic(instance, name, 3, 0));
-    if (!function.IsNull()) {
-      Integer& indexobj = Integer::Handle(isolate);
-      Integer& valueobj = Integer::Handle(isolate);
-      for (int i = 0; i < length; i++) {
-        indexobj = Integer::New(offset + i);
-        valueobj = Integer::New(native_array[i]);
-        GrowableArray<const Object*> args(2);
-        args.Add(&indexobj);
-        args.Add(&valueobj);
-        const Array& kNoArgumentNames = Array::Handle(isolate);
-        const Object& result = Object::Handle(
-            isolate,
-            DartEntry::InvokeDynamic(
-                instance, function, args, kNoArgumentNames));
-        if (result.IsError()) {
-          return Api::NewHandle(isolate, result.raw());
-        }
-      }
-      return Api::Success(isolate);
-    }
-  }
-  return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 // --- Byte Arrays ---
 
 
 DART_EXPORT bool Dart_IsByteArray(Dart_Handle object) {
   return RawObject::IsByteArrayClassId(Api::ClassId(object));
 }
 
@@ skipping 223 matching lines @@
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
   return obj.IsClosure();
 }
 
 
 DART_EXPORT Dart_Handle Dart_ClosureFunction(Dart_Handle closure) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(closure));
-  if (obj.IsNull()) {
-    return Api::NewError("Null object passed to Dart_ClosureFunction");
-  }
-  if (!obj.IsClosure()) {
-    return Api::NewError("Invalid closure passed to Dart_ClosureFunction");
+  const Closure& closure_obj = Api::UnwrapClosureHandle(isolate, closure);
+  if (closure_obj.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, closure, Closure);
   }
   ASSERT(ClassFinalizer::AllClassesFinalized());
 
-  const Closure& closure_obj = Closure::Cast(obj);
   RawFunction* rf = closure_obj.function();
   return Api::NewHandle(isolate, rf);
 }
 
 
 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(isolate, Api::UnwrapHandle(closure));
-  if (obj.IsNull()) {
-    return Api::NewError("Null object passed in to invoke closure");
+  const Closure& closure_obj = Api::UnwrapClosureHandle(isolate, closure);
+  if (closure_obj.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, closure, Closure);
   }
-  if (!obj.IsClosure()) {
-    return Api::NewError("Invalid closure passed to invoke closure");
+  if (number_of_arguments < 0) {
+    return Api::NewError(
+        "%s expects argument 'number_of_arguments' to be non-negative.",
+        CURRENT_FUNC);
   }
   ASSERT(ClassFinalizer::AllClassesFinalized());
 
   // Now try to invoke the closure.
-  const Closure& closure_obj = Closure::Cast(obj);
   GrowableArray<const Object*> dart_arguments(number_of_arguments);
   for (int i = 0; i < number_of_arguments; i++) {
     const Object& arg =
         Object::Handle(isolate, Api::UnwrapHandle(arguments[i]));
+    if (!arg.IsNull() && !arg.IsInstance()) {
+      RETURN_TYPE_ERROR(isolate, arguments[i], Instance);
+    }
     dart_arguments.Add(&arg);
   }
   const Array& kNoArgumentNames = Array::Handle(isolate);
   return Api::NewHandle(
       isolate,
       DartEntry::InvokeClosure(closure_obj, dart_arguments, kNoArgumentNames));
 }
 
 
 DART_EXPORT int64_t Dart_ClosureSmrck(Dart_Handle object) {
@@ skipping 37 matching lines @@
   if (obj.IsClass()) {
     return Class::Cast(obj).is_interface();
   }
   return false;
 }
 
 
 DART_EXPORT Dart_Handle Dart_ClassName(Dart_Handle clazz) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Class& cls = Class::Handle(
-      isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
+  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
   return Api::NewHandle(isolate, cls.UserVisibleName());
 }
 
 
 DART_EXPORT Dart_Handle Dart_ClassGetLibrary(Dart_Handle clazz) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Class& cls = Class::Handle(
-      isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
+  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
 
 #if defined(DEBUG)
   const Library& lib = Library::Handle(cls.library());
   if (lib.IsNull()) {
     ASSERT(cls.IsDynamicClass() || cls.IsVoidClass());
   }
 #endif
 
   return Api::NewHandle(isolate, cls.library());
 }
 
 
 DART_EXPORT Dart_Handle Dart_ClassGetDefault(Dart_Handle clazz) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Class& cls = Class::Handle(
-      isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
+  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
 
   // Finalize all classes.
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::NewError(msg);
   }
 
   if (cls.HasFactoryClass() && cls.HasResolvedFactoryClass()) {
     return Api::NewHandle(isolate, cls.FactoryClass());
   }
   return Api::Null(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ClassGetInterfaceCount(Dart_Handle clazz,
                                                     intptr_t* count) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Class& cls = Class::Handle(
-      isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
+  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
 
   const Array& interface_types = Array::Handle(isolate, cls.interfaces());
   if (interface_types.IsNull()) {
     *count = 0;
   } else {
     *count = interface_types.Length();
   }
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ClassGetInterfaceAt(Dart_Handle clazz,
                                                  intptr_t index) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Class& cls = Class::Handle(
-      isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
+  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
 
   // Finalize all classes.
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::NewError(msg);
   }
 
@@ skipping 504 matching lines @@
   DARTSCOPE(isolate);
   Object& result = Object::Handle(isolate);
 
   if (number_of_arguments < 0) {
     return Api::NewError(
         "%s expects argument 'number_of_arguments' to be non-negative.",
         CURRENT_FUNC);
   }
 
   // Get the class to instantiate.
-  Class& cls = Class::Handle(
-      isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
+  Class& cls =
+      Class::Handle(isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
   String& base_constructor_name = String::Handle();
   base_constructor_name = cls.Name();
 
   // And get the name of the constructor to invoke.
   String& dot_name = String::Handle(isolate);
   const Object& name_obj =
       Object::Handle(isolate, Api::UnwrapHandle(constructor_name));
   if (name_obj.IsNull()) {
     dot_name = Symbols::Dot();
   } else if (name_obj.IsString()) {
     const String& dot = String::Handle(isolate, Symbols::Dot());
     dot_name = String::Concat(dot, String::Cast(name_obj));
   } else {
-    return Api::NewError(
-        "%s expects argument 'constructor_name' to be of type String.",
-        CURRENT_FUNC);
+    RETURN_TYPE_ERROR(isolate, constructor_name, String);
   }
-
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::NewError(msg);
   }
 
   // Check for interfaces with default implementations.
   if (cls.is_interface()) {
     // Make sure that the constructor is found in the interface.
     result = ResolveConstructor(
         "Dart_New", cls, base_constructor_name, dot_name, number_of_arguments);
@@ skipping 328 matching lines @@
       const Array& kNoArgNames = Array::Handle(isolate);
       return Api::NewHandle(
           isolate, DartEntry::InvokeStatic(getter, args, kNoArgNames));
     } else if (!field.IsNull()) {
       return Api::NewHandle(isolate, field.value());
     } else {
       return Api::NewError("%s: did not find top-level variable '%s'.",
                            CURRENT_FUNC, field_name.ToCString());
     }
 
+  } else if (obj.IsError()) {
+      return container;
   } else {
     return Api::NewError(
         "%s expects argument 'container' to be an object, class, or library.",
         CURRENT_FUNC);
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetField(Dart_Handle container,
                                       Dart_Handle name,
@@ skipping 121 matching lines @@
                              CURRENT_FUNC, field_name.ToCString());
       } else {
         field.set_value(value_instance);
         return Api::Success(isolate);
       }
     } else {
       return Api::NewError("%s: did not find top-level variable '%s'.",
                            CURRENT_FUNC, field_name.ToCString());
     }
 
+  } else if (obj.IsError()) {
+      return container;
   } else {
     return Api::NewError(
         "%s expects argument 'container' to be an object, class, or library.",
         CURRENT_FUNC);
   }
 }
 
 
 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(isolate, Api::UnwrapHandle(name));
-  if (param.IsNull() || !param.IsString() || field_count <= 0) {
+  const String& cls_name = Api::UnwrapStringHandle(isolate, name);
+  if (cls_name.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, name, String);
+  }
+  const Library& lib = Api::UnwrapLibraryHandle(isolate, library);
+  if (lib.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, library, Library);
+  }
+  if (field_count <= 0) {
     return Api::NewError(
-        "Invalid arguments passed to Dart_CreateNativeWrapperClass");
+        "Negative field_count passed to Dart_CreateNativeWrapperClass");
   }
-  String& cls_name = String::Handle(isolate);
-  cls_name ^= param.raw();
-  cls_name = Symbols::New(cls_name);
-  Library& lib = Library::Handle(isolate);
-  lib ^= Api::UnwrapHandle(library);
-  if (lib.IsNull()) {
-    return Api::NewError(
-        "Invalid arguments passed to Dart_CreateNativeWrapperClass");
-  }
+
+  String& cls_symbol = String::Handle(isolate, Symbols::New(cls_name));
   const Class& cls = Class::Handle(
-      isolate, Class::NewNativeWrapper(lib, cls_name, field_count));
+      isolate, Class::NewNativeWrapper(lib, cls_symbol, field_count));
   if (cls.IsNull()) {
     return Api::NewError(
         "Unable to create native wrapper class : already exists");
   }
   return Api::NewHandle(isolate, cls.raw());
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeInstanceFieldCount(Dart_Handle obj,
                                                          int* count) {
@@ skipping 46 matching lines @@
   return Api::Success(isolate);
 }
 
 
 // --- Exceptions ----
 
 
 DART_EXPORT Dart_Handle Dart_ThrowException(Dart_Handle exception) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
+  const Instance& excp = Api::UnwrapInstanceHandle(isolate, exception);
+  if (excp.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, exception, Instance);
+  }
   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::NewError("No Dart frames on stack, cannot throw exception");
   }
-  const Instance& excp =
-      Instance::CheckedHandle(isolate, 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::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);
+  DARTSCOPE(isolate);
+  const Instance& excp = Api::UnwrapInstanceHandle(isolate, exception);
+  if (excp.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, exception, Instance);
+  }
+  const Instance& stk = Api::UnwrapInstanceHandle(isolate, stacktrace);
+  if (stk.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, stacktrace, Instance);
+  }
   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::NewError("No Dart frames on stack, cannot throw exception");
   }
-  DARTSCOPE(isolate);
-  const Instance& excp =
-      Instance::CheckedHandle(isolate, Api::UnwrapHandle(exception));
-  const Instance& stk =
-      Instance::CheckedHandle(isolate, 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::NewError("Exception was not re thrown, internal error");
 }
 
 
@@ skipping 465 matching lines @@
 DART_EXPORT void Dart_InitPerfEventsSupport(Dart_FileWriterFunction function) {
   Dart::set_perf_events_writer(function);
 }
 
 
 DART_EXPORT void Dart_InitFlowGraphPrinting(Dart_FileWriterFunction function) {
   Dart::set_flow_graph_writer(function);
 }
 
 }  // namespace dart