Implement the invoke methods (invoke, getField, setField, newInstance, apply) as internal natives.

runtime/vm/dart_entry.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 "vm/dart_entry.h"
 
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
 #include "vm/debugger.h"
 #include "vm/object_store.h"
@@ skipping 134 matching lines @@
                                kNumArguments,
                                kNumNamedArguments));
   ASSERT(!function.IsNull());
   const Array& args = Array::Handle(Array::New(kNumArguments));
   args.SetAt(0, receiver);
   args.SetAt(1, invocation_mirror);
   return InvokeFunction(function, args);
 }
 
 
+RawObject* DartEntry::InvokeConstructor(const Class& klass,
+                                        const Function& constructor,
+                                        const Array& arguments) {
+  Class& ultimate_klass = Class::Handle(klass.raw());
+  Function& ultimate_constructor = Function::Handle(constructor.raw());
+
+  Instance& new_object = Instance::Handle();
+  if (ultimate_constructor.IsRedirectingFactory()) {
+    Type& type = Type::Handle(ultimate_constructor.RedirectionType());
+    ultimate_klass = type.type_class();
+    ultimate_constructor = ultimate_constructor.RedirectionTarget();
+  }
+  if (ultimate_constructor.IsConstructor()) {
+    // "Constructors" are really instance initializers. They are passed a newly
+    // allocated object as an extra argument.
+    new_object = Instance::New(ultimate_klass);
+  }
+
+  // Create the argument list.
+  intptr_t number_of_arguments = arguments.Length();
+  intptr_t arg_index = 0;
+  int extra_args = (ultimate_constructor.IsConstructor() ? 2 : 1);
+  const Array& args =
+      Array::Handle(Array::New(number_of_arguments + extra_args));
+  if (ultimate_constructor.IsConstructor()) {
+    // Constructors get the uninitialized object and a constructor phase.
+    args.SetAt(arg_index++, new_object);
+    args.SetAt(arg_index++,
+               Smi::Handle(Smi::New(Function::kCtorPhaseAll)));
+  } else {
+    // Factories get type arguments.
+    args.SetAt(arg_index++, TypeArguments::Handle());
+  }
+  Object& argument = Object::Handle();
+  for (int i = 0; i < number_of_arguments; i++) {
+    argument = (arguments.At(i));
+    args.SetAt(arg_index++, argument);
+  }
+
+  // Invoke the constructor and return the new object.
+  const Object& result =
+      Object::Handle(DartEntry::InvokeFunction(ultimate_constructor, args));
+  if (result.IsError()) {
+    return result.raw();
+  }
+  if (ultimate_constructor.IsConstructor()) {
+    return new_object.raw();
+  } else {
+    return result.raw();
+  }
+}
+
+
 ArgumentsDescriptor::ArgumentsDescriptor(const Array& array)
     : array_(array) {
 }
 
 
 intptr_t ArgumentsDescriptor::Count() const {
   return Smi::CheckedHandle(array_.At(kCountIndex)).Value();
 }
 
 
@@ skipping 326 matching lines @@
           String::Handle(Field::GetterName(Symbols::_id()))));
   const Function& func = Function::Handle(cls.LookupDynamicFunction(func_name));
   ASSERT(!func.IsNull());
   const Array& args = Array::Handle(Array::New(1));
   args.SetAt(0, port);
   return DartEntry::InvokeFunction(func, args);
 }
 
 
 }  // namespace dart