Pass type argument vector to generic functions (if --reify-generic-functions is

runtime/lib/mirrors.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 "lib/mirrors.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 1325 matching lines @@
   GET_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(1));
   GET_NON_NULL_NATIVE_ARGUMENT(String, function_name,
                                arguments->NativeArgAt(2));
   GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(3));
   GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4));
 
   Class& klass = Class::Handle(reflectee.clazz());
   Function& function = Function::Handle(
       zone, Resolver::ResolveDynamicAnyArgs(zone, klass, function_name));
 
-  const Array& args_descriptor =
-      Array::Handle(zone, ArgumentsDescriptor::New(args.Length(), arg_names));
+  // TODO(regis): Support invocation of generic functions with type arguments.
+  const int kTypeArgsLen = 0;
+  const Array& args_descriptor = Array::Handle(
+      zone, ArgumentsDescriptor::New(kTypeArgsLen, args.Length(), arg_names));
 
   if (function.IsNull()) {
     // Didn't find a method: try to find a getter and invoke call on its result.
     const String& getter_name =
         String::Handle(zone, Field::GetterName(function_name));
     function = Resolver::ResolveDynamicAnyArgs(zone, klass, getter_name);
     if (!function.IsNull()) {
       ASSERT(function.kind() != RawFunction::kMethodExtractor);
       // Invoke the getter.
       const int kNumArgs = 1;
       const Array& getter_args = Array::Handle(zone, Array::New(kNumArgs));
       getter_args.SetAt(0, reflectee);
-      const Array& getter_args_descriptor =
-          Array::Handle(zone, ArgumentsDescriptor::New(getter_args.Length()));
+      const Array& getter_args_descriptor = Array::Handle(
+          zone, ArgumentsDescriptor::New(kTypeArgsLen, getter_args.Length()));
       const Instance& getter_result = Instance::Handle(
           zone, InvokeDynamicFunction(reflectee, function, getter_name,
                                       getter_args, getter_args_descriptor));
       // Replace the closure as the receiver in the arguments list.
       args.SetAt(0, getter_result);
       // Call the closure.
       const Object& call_result =
           Object::Handle(zone, DartEntry::InvokeClosure(args, args_descriptor));
       if (call_result.IsError()) {
         Exceptions::PropagateError(Error::Cast(call_result));
@@ skipping 25 matching lines @@
   // Check for method extraction when method extractors are not created.
   if (function.IsNull() && !FLAG_lazy_dispatchers) {
     function = Resolver::ResolveDynamicAnyArgs(zone, klass, getter_name);
     if (!function.IsNull()) {
       const Function& closure_function =
           Function::Handle(zone, function.ImplicitClosureFunction());
       return closure_function.ImplicitInstanceClosure(reflectee);
     }
   }
 
+  const int kTypeArgsLen = 0;
   const int kNumArgs = 1;
   const Array& args = Array::Handle(zone, Array::New(kNumArgs));
   args.SetAt(0, reflectee);
-  const Array& args_descriptor =
-      Array::Handle(zone, ArgumentsDescriptor::New(args.Length()));
+  const Array& args_descriptor = Array::Handle(
+      zone, ArgumentsDescriptor::New(kTypeArgsLen, args.Length()));
 
   // InvokeDynamic invokes NoSuchMethod if the provided function is null.
   return InvokeDynamicFunction(reflectee, function, internal_getter_name, args,
                                args_descriptor);
 }
 
 
 DEFINE_NATIVE_ENTRY(InstanceMirror_invokeSetter, 4) {
   // Argument 0 is the mirror, which is unused by the native. It exists
   // because this native is an instance method in order to be polymorphic
   // with its cousins.
   GET_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(1));
   GET_NON_NULL_NATIVE_ARGUMENT(String, setter_name, arguments->NativeArgAt(2));
   GET_NATIVE_ARGUMENT(Instance, value, arguments->NativeArgAt(3));
 
   const Class& klass = Class::Handle(zone, reflectee.clazz());
   const String& internal_setter_name =
       String::Handle(zone, Field::SetterName(setter_name));
   const Function& setter = Function::Handle(
       zone, Resolver::ResolveDynamicAnyArgs(zone, klass, internal_setter_name));
 
+  const int kTypeArgsLen = 0;
   const int kNumArgs = 2;
   const Array& args = Array::Handle(zone, Array::New(kNumArgs));
   args.SetAt(0, reflectee);
   args.SetAt(1, value);
-  const Array& args_descriptor =
-      Array::Handle(zone, ArgumentsDescriptor::New(args.Length()));
+  const Array& args_descriptor = Array::Handle(
+      zone, ArgumentsDescriptor::New(kTypeArgsLen, args.Length()));
 
   return InvokeDynamicFunction(reflectee, setter, internal_setter_name, args,
                                args_descriptor);
 }
 
 
 DEFINE_NATIVE_ENTRY(InstanceMirror_computeType, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, instance, arguments->NativeArgAt(0));
   const AbstractType& type = AbstractType::Handle(instance.GetType(Heap::kNew));
   // The static type of null is specified to be the bottom type, however, the
@@ skipping 41 matching lines @@
   // Argument 0 is the mirror, which is unused by the native. It exists
   // because this native is an instance method in order to be polymorphic
   // with its cousins.
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
   const Class& klass = Class::Handle(ref.GetClassReferent());
   GET_NON_NULL_NATIVE_ARGUMENT(String, function_name,
                                arguments->NativeArgAt(2));
   GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(3));
   GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4));
 
+  // TODO(regis): Support invocation of generic functions with type arguments.
+  const int kTypeArgsLen = 0;
   const Error& error = Error::Handle(zone, klass.EnsureIsFinalized(thread));
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
     UNREACHABLE();
   }
 
   Function& function =
       Function::Handle(klass.LookupStaticFunction(function_name));
 
   if (function.IsNull()) {
     // Didn't find a method: try to find a getter and invoke call on its result.
     const String& getter_name =
         String::Handle(Field::GetterName(function_name));
     function = klass.LookupStaticFunction(getter_name);
     if (!function.IsNull()) {
       // Invoke the getter.
       const Object& getter_result = Object::Handle(
           DartEntry::InvokeFunction(function, Object::empty_array()));
       if (getter_result.IsError()) {
         Exceptions::PropagateError(Error::Cast(getter_result));
         UNREACHABLE();
       }
       // Make room for the closure (receiver) in the argument list.
-      intptr_t numArgs = args.Length();
-      const Array& call_args = Array::Handle(Array::New(numArgs + 1));
+      const intptr_t num_args = args.Length();
+      const Array& call_args = Array::Handle(Array::New(num_args + 1));
       Object& temp = Object::Handle();
-      for (int i = 0; i < numArgs; i++) {
+      for (int i = 0; i < num_args; i++) {
         temp = args.At(i);
         call_args.SetAt(i + 1, temp);
       }
       call_args.SetAt(0, getter_result);
-      const Array& call_args_descriptor_array = Array::Handle(
-          ArgumentsDescriptor::New(call_args.Length(), arg_names));
+      const Array& call_args_descriptor_array =
+          Array::Handle(ArgumentsDescriptor::New(
+              kTypeArgsLen, call_args.Length(), arg_names));
       // Call the closure.
       const Object& call_result = Object::Handle(
           DartEntry::InvokeClosure(call_args, call_args_descriptor_array));
       if (call_result.IsError()) {
         Exceptions::PropagateError(Error::Cast(call_result));
         UNREACHABLE();
       }
       return call_result.raw();
     }
   }
 
-  const Array& args_descriptor_array =
-      Array::Handle(ArgumentsDescriptor::New(args.Length(), arg_names));
+  const Array& args_descriptor_array = Array::Handle(
+      ArgumentsDescriptor::New(kTypeArgsLen, args.Length(), arg_names));
 
   ArgumentsDescriptor args_descriptor(args_descriptor_array);
 
   if (function.IsNull() || !function.AreValidArguments(args_descriptor, NULL) ||
       !function.is_reflectable()) {
     ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()), function_name,
                       function, args, arg_names, InvocationMirror::kStatic,
                       InvocationMirror::kMethod);
     UNREACHABLE();
   }
@@ skipping 180 matching lines @@
   const Array& args =
       Array::Handle(Array::New(num_implicit_args + num_explicit_args));
 
   // Copy over the explicit arguments.
   Object& explicit_argument = Object::Handle();
   for (int i = 0; i < num_explicit_args; i++) {
     explicit_argument = explicit_args.At(i);
     args.SetAt(i + num_implicit_args, explicit_argument);
   }
 
-  const Array& args_descriptor_array =
-      Array::Handle(ArgumentsDescriptor::New(args.Length(), arg_names));
+  const int kTypeArgsLen = 0;
+  const Array& args_descriptor_array = Array::Handle(
+      ArgumentsDescriptor::New(kTypeArgsLen, args.Length(), arg_names));
 
   ArgumentsDescriptor args_descriptor(args_descriptor_array);
   if (!redirected_constructor.AreValidArguments(args_descriptor, NULL)) {
     external_constructor_name = redirected_constructor.name();
     ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                       external_constructor_name, redirected_constructor,
                       explicit_args, arg_names, InvocationMirror::kConstructor,
                       InvocationMirror::kMethod);
     UNREACHABLE();
   }
@@ skipping 39 matching lines @@
   // Argument 0 is the mirror, which is unused by the native. It exists
   // because this native is an instance method in order to be polymorphic
   // with its cousins.
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
   const Library& library = Library::Handle(ref.GetLibraryReferent());
   GET_NON_NULL_NATIVE_ARGUMENT(String, function_name,
                                arguments->NativeArgAt(2));
   GET_NON_NULL_NATIVE_ARGUMENT(Array, args, arguments->NativeArgAt(3));
   GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4));
 
+  // TODO(regis): Support invocation of generic functions with type arguments.
+  const int kTypeArgsLen = 0;
   Function& function =
       Function::Handle(library.LookupLocalFunction(function_name));
 
   if (function.IsNull()) {
     // Didn't find a method: try to find a getter and invoke call on its result.
     const Instance& getter_result =
         Instance::Handle(InvokeLibraryGetter(library, function_name, false));
     if (getter_result.raw() != Object::sentinel().raw()) {
       // Make room for the closure (receiver) in arguments.
       intptr_t numArgs = args.Length();
       const Array& call_args = Array::Handle(Array::New(numArgs + 1));
       Object& temp = Object::Handle();
       for (int i = 0; i < numArgs; i++) {
         temp = args.At(i);
         call_args.SetAt(i + 1, temp);
       }
       call_args.SetAt(0, getter_result);
-      const Array& call_args_descriptor_array = Array::Handle(
-          ArgumentsDescriptor::New(call_args.Length(), arg_names));
+      const Array& call_args_descriptor_array =
+          Array::Handle(ArgumentsDescriptor::New(
+              kTypeArgsLen, call_args.Length(), arg_names));
       // Call closure.
       const Object& call_result = Object::Handle(
           DartEntry::InvokeClosure(call_args, call_args_descriptor_array));
       if (call_result.IsError()) {
         Exceptions::PropagateError(Error::Cast(call_result));
         UNREACHABLE();
       }
       return call_result.raw();
     }
   }
 
-  const Array& args_descriptor_array =
-      Array::Handle(ArgumentsDescriptor::New(args.Length(), arg_names));
+  const Array& args_descriptor_array = Array::Handle(
+      ArgumentsDescriptor::New(kTypeArgsLen, args.Length(), arg_names));
   ArgumentsDescriptor args_descriptor(args_descriptor_array);
 
   if (function.IsNull() || !function.AreValidArguments(args_descriptor, NULL) ||
       !function.is_reflectable()) {
     ThrowNoSuchMethod(Instance::null_instance(), function_name, function, args,
                       arg_names, InvocationMirror::kTopLevel,
                       InvocationMirror::kMethod);
     UNREACHABLE();
   }
 
@@ skipping 249 matching lines @@
 
 DEFINE_NATIVE_ENTRY(TypeMirror_subtypeTest, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, a, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, b, arguments->NativeArgAt(1));
   return Bool::Get(a.IsSubtypeOf(b, NULL, NULL, Heap::kNew)).raw();
 }
 
 #endif  // !PRODUCT && !DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart