Hook up simulator (if needed) when calling Dart code.

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, 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 1113 matching lines @@
       isolate,
       Resolver::ResolveStatic(isolate_lib,
                               class_name,
                               function_name,
                               kNumArguments,
                               Object::empty_array(),
                               Resolver::kIsQualified));
   ASSERT(!function.IsNull());
   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));
+  return Api::NewHandle(isolate, DartEntry::InvokeFunction(function, args));
 }
 
 
 DART_EXPORT Dart_Port Dart_GetMainPortId() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   return isolate->main_port();
 }
 
 // --- Scopes ----
@@ skipping 772 matching lines @@
   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.");
   }
 
   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));
+    Object::Handle(isolate, DartEntry::InvokeFunction(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 44 matching lines @@
     if (!instance.IsNull()) {
       const Function& function = Function::Handle(
           isolate,
           Resolver::ResolveDynamic(instance, Symbols::IndexToken(), 2, 0));
       if (!function.IsNull()) {
         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::NewHandle(isolate, DartEntry::InvokeFunction(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 40 matching lines @@
         const Object& value_obj =
             Object::Handle(isolate, Api::UnwrapHandle(value));
         if (!value_obj.IsNull() && !value_obj.IsInstance()) {
           RETURN_TYPE_ERROR(isolate, value, Instance);
         }
         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::NewHandle(isolate, DartEntry::InvokeFunction(function,
+                                                                 args));
       }
     }
     return Api::NewError("Object does not implement the 'List' interface");
   }
 }
 
 
 static RawObject* ResolveConstructor(const char* current_func,
                                      const Class& cls,
                                      const String& class_name,
@@ skipping 37 matching lines @@
                              CURRENT_FUNC, class_name.ToCString()));
     return ApiError::New(message);
   }
   Instance& exception = Instance::Handle(isolate);
   exception = Instance::New(cls);
   const Array& args = Array::Handle(isolate, Array::New(3));
   args.SetAt(0, exception);
   args.SetAt(1,
              Smi::Handle(isolate, Smi::New(Function::kCtorPhaseAll)));
   args.SetAt(2, String::Handle(String::New(exception_message)));
-  result = DartEntry::InvokeStatic(constructor, args);
+  result = DartEntry::InvokeFunction(constructor, args);
   if (result.IsError()) return result.raw();
   ASSERT(result.IsNull());
 
   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.
     const String& message = String::Handle(
             String::New("No Dart frames on stack, cannot throw exception"));
     return ApiError::New(message);
   }
@@ skipping 80 matching lines @@
           Resolver::ResolveDynamic(instance, Symbols::IndexToken(), 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);
           args.SetAt(1, intobj);
-          result = DartEntry::InvokeDynamic(function, args);
+          result = DartEntry::InvokeFunction(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 74 matching lines @@
         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]);
           args.SetAt(1, indexobj);
           args.SetAt(2, valueobj);
           const Object& result = Object::Handle(
-              isolate, DartEntry::InvokeDynamic(function, args));
+              isolate, DartEntry::InvokeFunction(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 337 matching lines @@
   Object& obj = Object::Handle(isolate);
   args.SetAt(0, closure_obj);
   for (int i = 0; i < number_of_arguments; i++) {
     obj = Api::UnwrapHandle(arguments[i]);
     if (!obj.IsNull() && !obj.IsInstance()) {
       RETURN_TYPE_ERROR(isolate, arguments[i], Instance);
     }
     args.SetAt(i + 1, obj);
   }
   // Now try to invoke the closure.
-  return Api::NewHandle(isolate, DartEntry::InvokeClosure(closure_obj, args));
+  return Api::NewHandle(isolate, DartEntry::InvokeClosure(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 885 matching lines @@
       } else {
         return Api::NewError(
             "%s expects arguments[%d] to be an Instance handle.",
             CURRENT_FUNC, i);
       }
     }
     args.SetAt(arg_index++, argument);
   }
 
   // Invoke the constructor and return the new object.
-  result = DartEntry::InvokeStatic(constructor, args);
+  result = DartEntry::InvokeFunction(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());
@@ skipping 53 matching lines @@
     // 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());
     }
     args.SetAt(0, instance);
-    return Api::NewHandle(isolate, DartEntry::InvokeDynamic(function, args));
+    return Api::NewHandle(isolate, DartEntry::InvokeFunction(function, args));
 
   } else if (obj.IsClass()) {
     // Finalize all classes.
     Dart_Handle state = Api::CheckIsolateState(isolate);
     if (::Dart_IsError(state)) {
       return state;
     }
 
     const Class& cls = Class::Cast(obj);
     const Function& function = Function::Handle(
         isolate,
         Resolver::ResolveStatic(cls,
                                 function_name,
                                 number_of_arguments,
                                 Object::empty_array(),
                                 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));
+    return Api::NewHandle(isolate, DartEntry::InvokeFunction(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));
+    return Api::NewHandle(isolate, DartEntry::InvokeFunction(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 43 matching lines @@
 
     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.
     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));
+    return Api::NewHandle(isolate, DartEntry::InvokeFunction(getter, args));
 
   } else if (obj.IsClass()) {
     // Finalize all classes.
     Dart_Handle state = Api::CheckIsolateState(isolate);
     if (::Dart_IsError(state)) {
       return state;
     }
     // 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.LookupStaticFunctionAllowPrivate(getter_name);
     }
 
     if (!getter.IsNull()) {
       // Invoke the getter and return the result.
       return Api::NewHandle(
-          isolate, DartEntry::InvokeStatic(getter, Object::empty_array()));
+          isolate, DartEntry::InvokeFunction(getter, Object::empty_array()));
     } 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 11 matching lines @@
       // 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.LookupStaticFunctionAllowPrivate(getter_name);
     }
 
     if (!getter.IsNull()) {
       // Invoke the getter and return the result.
       return Api::NewHandle(
-          isolate, DartEntry::InvokeStatic(getter, Object::empty_array()));
+          isolate, DartEntry::InvokeFunction(getter, Object::empty_array()));
     } 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 54 matching lines @@
     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.
     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));
+    return Api::NewHandle(isolate, DartEntry::InvokeFunction(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.LookupStaticFunctionAllowPrivate(setter_name);
     }
 
     if (!setter.IsNull()) {
       // Invoke the setter and return the result.
       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));
+          Object::Handle(isolate, DartEntry::InvokeFunction(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 16 matching lines @@
           String::Handle(isolate, Field::SetterName(field_name));
       setter ^= lib.LookupFunctionAllowPrivate(setter_name);
     }
 
     if (!setter.IsNull()) {
       // Invoke the setter and return the result.
       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));
+          Object::Handle(isolate, DartEntry::InvokeFunction(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 713 matching lines @@
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success(isolate);
 }
 
 }  // namespace dart