Support named and optional positional arguments in reflective invocation.

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/class_finalizer.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
 #include "vm/debugger.h"
@@ skipping 134 matching lines @@
                                Symbols::NoSuchMethod(),
                                args_desc));
   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()) {
-    ClassFinalizer::ResolveRedirectingFactory(klass, ultimate_constructor);
-    Type& type = Type::Handle(ultimate_constructor.RedirectionType());
-    ultimate_constructor = ultimate_constructor.RedirectionTarget();
-    ASSERT(!ultimate_constructor.IsNull());
-    ultimate_klass = type.type_class();
-  }
-  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 334 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