Changed the API in DartEntry for invoking dart code from C++ to make it more compatible with the re…

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 1091 matching lines @@
   DARTSCOPE(isolate);
   Library& isolate_lib = Library::Handle(isolate, Library::IsolateLibrary());
   ASSERT(!isolate_lib.IsNull());
   const String& public_class_name =
       String::Handle(isolate, String::New("_ReceivePortImpl"));
   const String& class_name =
       String::Handle(isolate, isolate_lib.PrivateName(public_class_name));
   const String& function_name =
       String::Handle(isolate, Symbols::New("_get_or_create"));
   const int kNumArguments = 1;
-  const Array& kNoArgumentNames = Array::Handle(isolate);
+  const Array& kNoArgNames = Array::Handle(isolate);
   const Function& function = Function::Handle(
       isolate,
       Resolver::ResolveStatic(isolate_lib,
                               class_name,
                               function_name,
                               kNumArguments,
-                              kNoArgumentNames,
+                              kNoArgNames,
                               Resolver::kIsQualified));
-  GrowableArray<const Object*> arguments(kNumArguments);
-  arguments.Add(&Integer::Handle(isolate, Integer::New(port_id)));
-  return Api::NewHandle(
-      isolate, DartEntry::InvokeStatic(function, arguments, kNoArgumentNames));
+  const Array& args = Array::Handle(isolate, Array::New(kNumArguments));
+  args.SetAt(0, Integer::Handle(isolate, Integer::New(port_id)));
+  return Api::NewHandle(isolate, DartEntry::InvokeStatic(function, args));
 }
 
 
 DART_EXPORT Dart_Port Dart_GetMainPortId() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   return isolate->main_port();
 }
 
 // --- Scopes ----
@@ skipping 755 matching lines @@
     return Api::NewError("Object does not implement the List interface");
   }
   String& name = String::Handle(isolate, Symbols::Length());
   name = Field::GetterName(name);
   const Function& function =
       Function::Handle(isolate, Resolver::ResolveDynamic(instance, name, 1, 0));
   if (function.IsNull()) {
     return Api::NewError("List object does not have a 'length' field.");
   }
 
-  GrowableArray<const Object*> args(0);
-  const Array& kNoArgumentNames = Array::Handle(isolate);
-  const Object& retval = Object::Handle(
-      isolate,
-      DartEntry::InvokeDynamic(instance, function, args, kNoArgumentNames));
+  const int kNumArgs = 1;
+  const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
+  args.SetAt(0, instance);  // Set up the receiver as the first argument.
+  const Object& retval =
+    Object::Handle(isolate, DartEntry::InvokeDynamic(function, args));
   if (retval.IsSmi()) {
     *len = Smi::Cast(retval).Value();
     return Api::Success(isolate);
   } else if (retval.IsMint() || retval.IsBigint()) {
     if (retval.IsMint()) {
       int64_t mint_value = Mint::Cast(retval).value();
       if (mint_value >= kIntptrMin && mint_value <= kIntptrMax) {
         *len = static_cast<intptr_t>(mint_value);
       }
     } else {
@@ skipping 40 matching lines @@
     const Instance& instance =
         Instance::Handle(isolate, GetListInstance(isolate, obj));
     if (!instance.IsNull()) {
       const Function& function = Function::Handle(
           isolate,
           Resolver::ResolveDynamic(instance,
                                    Symbols::IndexTokenHandle(),
                                    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));
+        const int kNumArgs = 2;
+        const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
+        const Integer& indexobj = Integer::Handle(isolate, Integer::New(index));
+        args.SetAt(0, instance);
+        args.SetAt(1, indexobj);
+        return Api::NewHandle(isolate, DartEntry::InvokeDynamic(function,
+                                                                args));
       }
     }
     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)); \
@@ skipping 34 matching lines @@
                                    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));
+        const intptr_t kNumArgs = 3;
+        const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
+        args.SetAt(0, instance);
+        args.SetAt(1, index_obj);
+        args.SetAt(2, value_obj);
+        return Api::NewHandle(isolate, DartEntry::InvokeDynamic(function,
+                                                                args));
       }
     }
     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)                                      \
@@ skipping 54 matching lines @@
     if (!instance.IsNull()) {
       const Function& function = Function::Handle(
           isolate,
           Resolver::ResolveDynamic(instance,
                                    Symbols::IndexTokenHandle(),
                                    2,
                                    0));
       if (!function.IsNull()) {
         Object& result = Object::Handle(isolate);
         Integer& intobj = Integer::Handle(isolate);
+        const int kNumArgs = 2;
+        const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
+        args.SetAt(0, instance);  // Set up the receiver as the first argument.
         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);
+          args.SetAt(1, intobj);
+          result = DartEntry::InvokeDynamic(function, args);
           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
@@ skipping 64 matching lines @@
     if (!instance.IsNull()) {
       const Function& function = Function::Handle(
           isolate,
           Resolver::ResolveDynamic(instance,
                                    Symbols::AssignIndexTokenHandle(),
                                    3,
                                    0));
       if (!function.IsNull()) {
         Integer& indexobj = Integer::Handle(isolate);
         Integer& valueobj = Integer::Handle(isolate);
+        const int kNumArgs = 3;
+        const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
+        args.SetAt(0, instance);  // Set up the receiver as the first argument.
         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);
+          args.SetAt(1, indexobj);
+          args.SetAt(2, valueobj);
           const Object& result = Object::Handle(
-              isolate,
-              DartEntry::InvokeDynamic(
-                  instance, function, args, kNoArgumentNames));
+              isolate, DartEntry::InvokeDynamic(function, args));
           if (result.IsError()) {
             return Api::NewHandle(isolate, result.raw());
           }
         }
         return Api::Success(isolate);
       }
     }
     return Api::NewError("Object does not implement the 'List' interface");
   }
 }
@@ skipping 282 matching lines @@
   if (closure_obj.IsNull() || !closure_obj.IsCallable(NULL, NULL)) {
     RETURN_TYPE_ERROR(isolate, closure, Instance);
   }
   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.
-  GrowableArray<const Object*> dart_arguments(number_of_arguments);
+  // Set up arguments to include the closure as the first argument.
+  const Array& args = Array::Handle(isolate,
+                                    Array::New(number_of_arguments + 1));
+  Object& obj = Object::Handle(isolate);
+  args.SetAt(0, closure_obj);
   for (int i = 0; i < number_of_arguments; i++) {
-    const Object& arg =
-        Object::Handle(isolate, Api::UnwrapHandle(arguments[i]));
-    if (!arg.IsNull() && !arg.IsInstance()) {
+    obj = Api::UnwrapHandle(arguments[i]);
+    if (!obj.IsNull() && !obj.IsInstance()) {
       RETURN_TYPE_ERROR(isolate, arguments[i], Instance);
     }
-    dart_arguments.Add(&arg);
+    args.SetAt(i + 1, obj);
   }
-  const Array& kNoArgumentNames = Array::Handle(isolate);
-  return Api::NewHandle(
-      isolate,
-      DartEntry::InvokeClosure(closure_obj, dart_arguments, kNoArgumentNames));
+  // Now try to invoke the closure.
+  return Api::NewHandle(isolate, DartEntry::InvokeClosure(closure_obj, args));
 }
 
 
 // --- Classes ---
 
 
 DART_EXPORT bool Dart_IsClass(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
@@ skipping 853 matching lines @@
   Function& constructor = Function::Handle(isolate);
   constructor ^= result.raw();
 
   Instance& new_object = Instance::Handle(isolate);
   if (constructor.IsConstructor()) {
     // Create the new object.
     new_object = Instance::New(cls);
   }
 
   // Create the argument list.
+  intptr_t arg_index = 0;
   int extra_args = (constructor.IsConstructor() ? 2 : 1);
-  GrowableArray<const Object*> args(number_of_arguments + extra_args);
+  const Array& args =
+      Array::Handle(isolate, Array::New(number_of_arguments + extra_args));
   if (constructor.IsConstructor()) {
     // Constructors get the uninitialized object and a constructor phase.
-    args.Add(&new_object);
-    args.Add(&Smi::Handle(isolate, Smi::New(Function::kCtorPhaseAll)));
+    args.SetAt(arg_index++, new_object);
+    args.SetAt(arg_index++,
+               Smi::Handle(isolate, Smi::New(Function::kCtorPhaseAll)));
   } else {
     // Factories get type arguments.
-    args.Add(&TypeArguments::Handle(isolate));
+    args.SetAt(arg_index++, TypeArguments::Handle(isolate));
   }
+  Object& argument = Object::Handle(isolate);
   for (int i = 0; i < number_of_arguments; i++) {
-    const Object& arg =
-        Object::Handle(isolate, Api::UnwrapHandle(arguments[i]));
-    if (!arg.IsNull() && !arg.IsInstance()) {
-      if (arg.IsError()) {
-        return Api::NewHandle(isolate, arg.raw());
+    argument = Api::UnwrapHandle(arguments[i]);
+    if (!argument.IsNull() && !argument.IsInstance()) {
+      if (argument.IsError()) {
+        return Api::NewHandle(isolate, argument.raw());
       } else {
         return Api::NewError(
             "%s expects arguments[%d] to be an Instance handle.",
             CURRENT_FUNC, i);
       }
     }
-    args.Add(&arg);
+    args.SetAt(arg_index++, argument);
   }
 
   // Invoke the constructor and return the new object.
-  const Array& kNoArgNames = Array::Handle(isolate);
-  result = DartEntry::InvokeStatic(constructor, args, kNoArgNames);
+  result = DartEntry::InvokeStatic(constructor, args);
   if (result.IsError()) {
     return Api::NewHandle(isolate, result.raw());
   }
   if (constructor.IsConstructor()) {
     ASSERT(result.IsNull());
   } else {
     ASSERT(result.IsNull() || result.IsInstance());
     new_object ^= result.raw();
   }
   return Api::NewHandle(isolate, new_object.raw());
 }
 
 
 DART_EXPORT Dart_Handle Dart_Invoke(Dart_Handle target,
                                     Dart_Handle name,
                                     int number_of_arguments,
                                     Dart_Handle* arguments) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
 
   const String& function_name = Api::UnwrapStringHandle(isolate, name);
   if (function_name.IsNull()) {
     RETURN_TYPE_ERROR(isolate, name, String);
   }
   if (number_of_arguments < 0) {
     return Api::NewError(
         "%s expects argument 'number_of_arguments' to be non-negative.",
         CURRENT_FUNC);
   }
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(target));
+  if (obj.IsError()) {
+    return target;
+  }
 
   // Check for malformed arguments in the arguments list.
-  GrowableArray<const Object*> args(number_of_arguments);
+  intptr_t num_receiver = (obj.IsNull() || obj.IsInstance()) ? 1 : 0;
+  const Array& args =
+      Array::Handle(isolate, Array::New(number_of_arguments + num_receiver));
+  Object& arg = Object::Handle(isolate);
   for (int i = 0; i < number_of_arguments; i++) {
-    const Object& arg =
-        Object::Handle(isolate, Api::UnwrapHandle(arguments[i]));
+    arg = Api::UnwrapHandle(arguments[i]);
     if (!arg.IsNull() && !arg.IsInstance()) {
       if (arg.IsError()) {
         return Api::NewHandle(isolate, arg.raw());
       } else {
         return Api::NewError(
             "%s expects arguments[%d] to be an Instance handle.",
             CURRENT_FUNC, i);
       }
     }
-    args.Add(&arg);
-  }
-
-  const Array& kNoArgNames = Array::Handle(isolate);
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(target));
-  if (obj.IsError()) {
-    return target;
+    args.SetAt((i + num_receiver), arg);
   }
 
   if (obj.IsNull() || obj.IsInstance()) {
     Instance& instance = Instance::Handle(isolate);
     instance ^= obj.raw();
     const Function& function = Function::Handle(
         isolate,
         Resolver::ResolveDynamic(instance,
                                  function_name,
                                  (number_of_arguments + 1),
                                  Resolver::kIsQualified));
     // TODO(5415268): Invoke noSuchMethod instead of failing.
     if (function.IsNull()) {
       const Type& type = Type::Handle(isolate, instance.GetType());
       const String& cls_name = String::Handle(isolate, type.ClassName());
       return Api::NewError("%s: did not find instance method '%s.%s'.",
                            CURRENT_FUNC,
                            cls_name.ToCString(),
                            function_name.ToCString());
     }
-    return Api::NewHandle(
-        isolate,
-        DartEntry::InvokeDynamic(instance, function, args, kNoArgNames));
+    args.SetAt(0, instance);
+    return Api::NewHandle(isolate, DartEntry::InvokeDynamic(function, args));
 
   } else if (obj.IsClass()) {
     // Finalize all classes.
     const char* msg = CheckIsolateState(isolate);
     if (msg != NULL) {
       return Api::NewError("%s", msg);
     }
 
     const Class& cls = Class::Cast(obj);
     const Function& function = Function::Handle(
         isolate,
         Resolver::ResolveStatic(cls,
                                 function_name,
                                 number_of_arguments,
                                 Array::Handle(isolate),
                                 Resolver::kIsQualified));
     if (function.IsNull()) {
       const String& cls_name = String::Handle(isolate, cls.Name());
       return Api::NewError("%s: did not find static method '%s.%s'.",
                            CURRENT_FUNC,
                            cls_name.ToCString(),
                            function_name.ToCString());
     }
-    return Api::NewHandle(
-        isolate,
-        DartEntry::InvokeStatic(function, args, kNoArgNames));
+    return Api::NewHandle(isolate, DartEntry::InvokeStatic(function, args));
 
   } else if (obj.IsLibrary()) {
     // Check whether class finalization is needed.
     bool finalize_classes = true;
     const Library& lib = Library::Cast(obj);
 
     // When calling functions in the dart:builtin library do not finalize as it
     // should have been prefinalized.
     Library& builtin =
         Library::Handle(isolate, isolate->object_store()->builtin_library());
@@ skipping 20 matching lines @@
     // do it here.
     String& error_message = String::Handle();
     if (!function.AreValidArgumentCounts(number_of_arguments,
                                          0,
                                          &error_message)) {
       return Api::NewError("%s: wrong argument count for function '%s': %s.",
                            CURRENT_FUNC,
                            function_name.ToCString(),
                            error_message.ToCString());
     }
-    return Api::NewHandle(
-        isolate, DartEntry::InvokeStatic(function, args, kNoArgNames));
+    return Api::NewHandle(isolate, DartEntry::InvokeStatic(function, args));
 
   } else {
     return Api::NewError(
         "%s expects argument 'target' to be an object, class, or library.",
         CURRENT_FUNC);
   }
 }
 
 
 static bool FieldIsUninitialized(Isolate* isolate, const Field& fld) {
@@ skipping 39 matching lines @@
       }
       cls = cls.SuperClass();
     }
 
     if (getter.IsNull()) {
       return Api::NewError("%s: did not find instance field '%s'.",
                            CURRENT_FUNC, field_name.ToCString());
     }
 
     // Invoke the getter and return the result.
-    GrowableArray<const Object*> args;
-    const Array& kNoArgNames = Array::Handle(isolate);
-    return Api::NewHandle(
-        isolate,
-        DartEntry::InvokeDynamic(instance, getter, args, kNoArgNames));
+    const int kNumArgs = 1;
+    const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
+    args.SetAt(0, instance);
+    return Api::NewHandle(isolate, DartEntry::InvokeDynamic(getter, args));
 
   } else if (obj.IsClass()) {
     // Finalize all classes.
     const char* msg = CheckIsolateState(isolate);
     if (msg != NULL) {
       return Api::NewError("%s", msg);
     }
     // To access a static field we may need to use the Field or the
     // getter Function.
     const Class& cls = Class::Cast(obj);
     field = cls.LookupStaticField(field_name);
     if (field.IsNull() || FieldIsUninitialized(isolate, field)) {
       const String& getter_name =
           String::Handle(isolate, Field::GetterName(field_name));
       getter = cls.LookupStaticFunction(getter_name);
     }
 
     if (!getter.IsNull()) {
       // Invoke the getter and return the result.
-      GrowableArray<const Object*> args;
-      const Array& kNoArgNames = Array::Handle(isolate);
-      return Api::NewHandle(
-          isolate, DartEntry::InvokeStatic(getter, args, kNoArgNames));
+      const Array& args = Array::Handle(isolate, Object::empty_array());
+      return Api::NewHandle(isolate, DartEntry::InvokeStatic(getter, args));
     } else if (!field.IsNull()) {
       return Api::NewHandle(isolate, field.value());
     } else {
       return Api::NewError("%s: did not find static field '%s'.",
                            CURRENT_FUNC, field_name.ToCString());
     }
 
   } else if (obj.IsLibrary()) {
     // TODO(turnidge): Do we need to call CheckIsolateState here?
 
@@ skipping 10 matching lines @@
     } else if (FieldIsUninitialized(isolate, field)) {
       // A field was found.  Check for a getter in the field's owner classs.
       const Class& cls = Class::Handle(isolate, field.owner());
       const String& getter_name =
           String::Handle(isolate, Field::GetterName(field_name));
       getter = cls.LookupStaticFunction(getter_name);
     }
 
     if (!getter.IsNull()) {
       // Invoke the getter and return the result.
-      GrowableArray<const Object*> args;
-      const Array& kNoArgNames = Array::Handle(isolate);
-      return Api::NewHandle(
-          isolate, DartEntry::InvokeStatic(getter, args, kNoArgNames));
+      const Array& args = Array::Handle(isolate, Object::empty_array());
+      return Api::NewHandle(isolate, DartEntry::InvokeStatic(getter, args));
     } 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 {
@@ skipping 49 matching lines @@
       }
       cls = cls.SuperClass();
     }
 
     if (setter.IsNull()) {
       return Api::NewError("%s: did not find instance field '%s'.",
                            CURRENT_FUNC, field_name.ToCString());
     }
 
     // Invoke the setter and return the result.
-    GrowableArray<const Object*> args(1);
-    args.Add(&value_instance);
-    const Array& kNoArgNames = Array::Handle(isolate);
-    return Api::NewHandle(
-        isolate,
-        DartEntry::InvokeDynamic(instance, setter, args, kNoArgNames));
+    const int kNumArgs = 2;
+    const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
+    args.SetAt(0, instance);
+    args.SetAt(1, value_instance);
+    return Api::NewHandle(isolate, DartEntry::InvokeDynamic(setter, args));
 
   } else if (obj.IsClass()) {
     // To access a static field we may need to use the Field or the
     // setter Function.
     const Class& cls = Class::Cast(obj);
     field = cls.LookupStaticField(field_name);
     if (field.IsNull()) {
       String& setter_name =
           String::Handle(isolate, Field::SetterName(field_name));
       setter = cls.LookupStaticFunction(setter_name);
     }
 
     if (!setter.IsNull()) {
       // Invoke the setter and return the result.
-      GrowableArray<const Object*> args(1);
-      args.Add(&value_instance);
-      const Array& kNoArgNames = Array::Handle(isolate);
-      const Object& result = Object::Handle(
-          isolate,
-          DartEntry::InvokeStatic(setter, args, kNoArgNames));
+      const int kNumArgs = 1;
+      const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
+      args.SetAt(0, value_instance);
+      const Object& result =
+          Object::Handle(isolate, DartEntry::InvokeStatic(setter, args));
       if (result.IsError()) {
         return Api::NewHandle(isolate, result.raw());
       } else {
         return Api::Success(isolate);
       }
     } else if (!field.IsNull()) {
       if (field.is_final()) {
         return Api::NewError("%s: cannot set final field '%s'.",
                              CURRENT_FUNC, field_name.ToCString());
       } else {
@@ skipping 12 matching lines @@
     const Library& lib = Library::Cast(obj);
     field = lib.LookupFieldAllowPrivate(field_name);
     if (field.IsNull()) {
       const String& setter_name =
           String::Handle(isolate, Field::SetterName(field_name));
       setter ^= lib.LookupFunctionAllowPrivate(setter_name);
     }
 
     if (!setter.IsNull()) {
       // Invoke the setter and return the result.
-      GrowableArray<const Object*> args(1);
-      args.Add(&value_instance);
-      const Array& kNoArgNames = Array::Handle(isolate);
-      const Object& result = Object::Handle(
-          isolate, DartEntry::InvokeStatic(setter, args, kNoArgNames));
+      const int kNumArgs = 1;
+      const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
+      args.SetAt(0, value_instance);
+      const Object& result =
+          Object::Handle(isolate, DartEntry::InvokeStatic(setter, args));
       if (result.IsError()) {
         return Api::NewHandle(isolate, result.raw());
       } else {
         return Api::Success(isolate);
       }
     } else if (!field.IsNull()) {
       if (field.is_final()) {
         return Api::NewError("%s: cannot set final top-level variable '%s'.",
                              CURRENT_FUNC, field_name.ToCString());
       } else {
@@ skipping 676 matching lines @@
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success(isolate);
 }
 
 }  // namespace dart