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

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 "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "lib/stacktrace.h"
@@ skipping 336 matching lines @@
   static const int kExtNewRatio = 16;
   if (size > (heap->CapacityInWords(Heap::kNew) * kWordSize) / kExtNewRatio) {
     return Heap::kOld;
   } else {
     return Heap::kNew;
   }
 }
 
 
 static RawObject* Send0Arg(const Instance& receiver, const String& selector) {
+  const intptr_t kTypeArgsLen = 0;
   const intptr_t kNumArgs = 1;
   ArgumentsDescriptor args_desc(
-      Array::Handle(ArgumentsDescriptor::New(kNumArgs)));
+      Array::Handle(ArgumentsDescriptor::New(kTypeArgsLen, kNumArgs)));
   const Function& function =
       Function::Handle(Resolver::ResolveDynamic(receiver, selector, args_desc));
   if (function.IsNull()) {
     return ApiError::New(String::Handle(String::New("")));
   }
   const Array& args = Array::Handle(Array::New(kNumArgs));
   args.SetAt(0, receiver);
   return DartEntry::InvokeFunction(function, args);
 }
 
 
 static RawObject* Send1Arg(const Instance& receiver,
                            const String& selector,
                            const Instance& argument) {
+  const intptr_t kTypeArgsLen = 0;
   const intptr_t kNumArgs = 2;
   ArgumentsDescriptor args_desc(
-      Array::Handle(ArgumentsDescriptor::New(kNumArgs)));
+      Array::Handle(ArgumentsDescriptor::New(kTypeArgsLen, kNumArgs)));
   const Function& function =
       Function::Handle(Resolver::ResolveDynamic(receiver, selector, args_desc));
   if (function.IsNull()) {
     return ApiError::New(String::Handle(String::New("")));
   }
   const Array& args = Array::Handle(Array::New(kNumArgs));
   args.SetAt(0, receiver);
   args.SetAt(1, argument);
   return DartEntry::InvokeFunction(function, args);
 }
@@ skipping 2331 matching lines @@
     GET_LIST_LENGTH(Z, ExternalTypedData, obj, len);
   }
   CHECK_CALLBACK_STATE(T);
 
   // Now check and handle a dart object that implements the List interface.
   const Instance& instance = Instance::Handle(Z, GetListInstance(Z, obj));
   if (instance.IsNull()) {
     return Api::NewError("Object does not implement the List interface");
   }
   const String& name = String::Handle(Z, Field::GetterName(Symbols::Length()));
+  const int kTypeArgsLen = 0;
   const int kNumArgs = 1;
   ArgumentsDescriptor args_desc(
-      Array::Handle(Z, ArgumentsDescriptor::New(kNumArgs)));
+      Array::Handle(Z, ArgumentsDescriptor::New(kTypeArgsLen, kNumArgs)));
   const Function& function =
       Function::Handle(Z, Resolver::ResolveDynamic(instance, name, args_desc));
   if (function.IsNull()) {
     return Api::NewError("List object does not have a 'length' field.");
   }
 
   const Array& args = Array::Handle(Z, Array::New(kNumArgs));
   args.SetAt(0, instance);  // Set up the receiver as the first argument.
   const Object& retval =
       Object::Handle(Z, DartEntry::InvokeFunction(function, args));
@@ skipping 83 matching lines @@
     GET_LIST_RANGE(T, Array, obj, offset, length);
   } else if (obj.IsGrowableObjectArray()) {
     GET_LIST_RANGE(T, GrowableObjectArray, obj, offset, length);
   } else if (obj.IsError()) {
     return list;
   } else {
     CHECK_CALLBACK_STATE(T);
     // Check and handle a dart object that implements the List interface.
     const Instance& instance = Instance::Handle(Z, GetListInstance(Z, obj));
     if (!instance.IsNull()) {
+      const intptr_t kTypeArgsLen = 0;
       const intptr_t kNumArgs = 2;
       ArgumentsDescriptor args_desc(
-          Array::Handle(ArgumentsDescriptor::New(kNumArgs)));
+          Array::Handle(ArgumentsDescriptor::New(kTypeArgsLen, kNumArgs)));
       const Function& function = Function::Handle(
           Z, Resolver::ResolveDynamic(instance, Symbols::AssignIndexToken(),
                                       args_desc));
       if (!function.IsNull()) {
         const Array& args = Array::Handle(Array::New(kNumArgs));
         args.SetAt(0, instance);
         Instance& index = Instance::Handle(Z);
         for (intptr_t i = 0; i < length; ++i) {
           index = Integer::New(i);
           args.SetAt(1, index);
@@ skipping 35 matching lines @@
   } else if (obj.IsGrowableObjectArray()) {
     SET_LIST_ELEMENT(GrowableObjectArray, obj, index, value);
   } else if (obj.IsError()) {
     return list;
   } else {
     CHECK_CALLBACK_STATE(T);
 
     // Check and handle a dart object that implements the List interface.
     const Instance& instance = Instance::Handle(Z, GetListInstance(Z, obj));
     if (!instance.IsNull()) {
+      const intptr_t kTypeArgsLen = 0;
       const intptr_t kNumArgs = 3;
       ArgumentsDescriptor args_desc(
-          Array::Handle(ArgumentsDescriptor::New(kNumArgs)));
+          Array::Handle(ArgumentsDescriptor::New(kTypeArgsLen, kNumArgs)));
       const Function& function = Function::Handle(
           Z, Resolver::ResolveDynamic(instance, Symbols::AssignIndexToken(),
                                       args_desc));
       if (!function.IsNull()) {
         const Integer& index_obj = Integer::Handle(Z, Integer::New(index));
         const Object& value_obj = Object::Handle(Z, Api::UnwrapHandle(value));
         if (!value_obj.IsNull() && !value_obj.IsInstance()) {
           RETURN_TYPE_ERROR(Z, value, Instance);
         }
         const Array& args = Array::Handle(Z, Array::New(kNumArgs));
@@ skipping 163 matching lines @@
                               length);
   }
   if (obj.IsError()) {
     return list;
   }
   CHECK_CALLBACK_STATE(T);
 
   // Check and handle a dart object that implements the List interface.
   const Instance& instance = Instance::Handle(Z, GetListInstance(Z, obj));
   if (!instance.IsNull()) {
+    const int kTypeArgsLen = 0;
     const int kNumArgs = 2;
     ArgumentsDescriptor args_desc(
-        Array::Handle(ArgumentsDescriptor::New(kNumArgs)));
+        Array::Handle(ArgumentsDescriptor::New(kTypeArgsLen, kNumArgs)));
     const Function& function = Function::Handle(
         Z,
         Resolver::ResolveDynamic(instance, Symbols::IndexToken(), args_desc));
     if (!function.IsNull()) {
       Object& result = Object::Handle(Z);
       Integer& intobj = Integer::Handle(Z);
       const Array& args = Array::Handle(Z, Array::New(kNumArgs));
       args.SetAt(0, instance);  // Set up the receiver as the first argument.
       for (int i = 0; i < length; i++) {
         HANDLESCOPE(T);
@@ skipping 64 matching lines @@
                               length);
   }
   if (obj.IsError()) {
     return list;
   }
   CHECK_CALLBACK_STATE(T);
 
   // Check and handle a dart object that implements the List interface.
   const Instance& instance = Instance::Handle(Z, GetListInstance(Z, obj));
   if (!instance.IsNull()) {
+    const int kTypeArgsLen = 0;
     const int kNumArgs = 3;
     ArgumentsDescriptor args_desc(
-        Array::Handle(ArgumentsDescriptor::New(kNumArgs)));
+        Array::Handle(Z, ArgumentsDescriptor::New(kTypeArgsLen, kNumArgs)));
     const Function& function = Function::Handle(
         Z, Resolver::ResolveDynamic(instance, Symbols::AssignIndexToken(),
                                     args_desc));
     if (!function.IsNull()) {
       Integer& indexobj = Integer::Handle(Z);
       Integer& valueobj = Integer::Handle(Z);
       const Array& args = Array::Handle(Z, 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);
@@ skipping 607 matching lines @@
           "%s: could not find factory '%s' in class '%s'.", current_func,
           constr_name.ToCString(), lookup_class_name.ToCString()));
       return ApiError::New(message);
     } else {
       const String& message = String::Handle(
           String::NewFormatted("%s: could not find constructor '%s'.",
                                current_func, constr_name.ToCString()));
       return ApiError::New(message);
     }
   }
-  int extra_args = 1;
+  const int kTypeArgsLen = 0;
+  const int extra_args = 1;
   String& error_message = String::Handle();
-  if (!constructor.AreValidArgumentCounts(num_args + extra_args, 0,
-                                          &error_message)) {
+  if (!constructor.AreValidArgumentCounts(kTypeArgsLen, num_args + extra_args,
+                                          0, &error_message)) {
     const String& message = String::Handle(String::NewFormatted(
         "%s: wrong argument count for "
         "constructor '%s': %s.",
         current_func, constr_name.ToCString(), error_message.ToCString()));
     return ApiError::New(message);
   }
   return constructor.raw();
 }
 
 
@@ skipping 292 matching lines @@
   if (constructor_name.IsNull()) {
     strings.SetAt(2, Symbols::Empty());
   } else {
     strings.SetAt(2, constructor_name);
   }
   const String& dot_name = String::Handle(Z, String::ConcatAll(strings));
   const TypeArguments& type_arguments =
       TypeArguments::Handle(Z, type_obj.arguments());
   const Function& constructor =
       Function::Handle(Z, cls.LookupFunctionAllowPrivate(dot_name));
+  const int kTypeArgsLen = 0;
   const int extra_args = 1;
   if (!constructor.IsNull() && constructor.IsGenerativeConstructor() &&
-      constructor.AreValidArgumentCounts(number_of_arguments + extra_args, 0,
-                                         NULL)) {
+      constructor.AreValidArgumentCounts(
+          kTypeArgsLen, number_of_arguments + extra_args, 0, NULL)) {
     // Create the argument list.
     // Constructors get the uninitialized object.
     if (!type_arguments.IsNull()) {
       // The type arguments will be null if the class has no type
       // parameters, in which case the following call would fail
       // because there is no slot reserved in the object for the
       // type vector.
       instance.SetTypeArguments(type_arguments);
     }
     Dart_Handle result;
@@ skipping 33 matching lines @@
     return Api::NewError(
         "%s expects argument 'number_of_arguments' to be non-negative.",
         CURRENT_FUNC);
   }
   const Object& obj = Object::Handle(Z, Api::UnwrapHandle(target));
   if (obj.IsError()) {
     return target;
   }
   Dart_Handle result;
   Array& args = Array::Handle(Z);
+  const intptr_t kTypeArgsLen = 0;
   if (obj.IsType()) {
     if (!Type::Cast(obj).IsFinalized()) {
       return Api::NewError(
           "%s expects argument 'target' to be a fully resolved type.",
           CURRENT_FUNC);
     }
 
     const Class& cls = Class::Handle(Z, Type::Cast(obj).type_class());
-    const Function& function = Function::Handle(
-        Z, Resolver::ResolveStaticAllowPrivate(
-               cls, function_name, number_of_arguments, Object::empty_array()));
+    const Function& function =
+        Function::Handle(Z, Resolver::ResolveStaticAllowPrivate(
+                                cls, function_name, kTypeArgsLen,
+                                number_of_arguments, Object::empty_array()));
     if (function.IsNull()) {
       const String& cls_name = String::Handle(Z, cls.Name());
       return Api::NewError("%s: did not find static method '%s.%s'.",
                            CURRENT_FUNC, cls_name.ToCString(),
                            function_name.ToCString());
     }
 #if !defined(PRODUCT)
     if (tds.enabled()) {
       const String& cls_name = String::Handle(Z, cls.Name());
       tds.SetNumArguments(1);
       tds.FormatArgument(0, "name", "%s.%s", cls_name.ToCString(),
                          function_name.ToCString());
     }
 #endif  // !defined(PRODUCT)
     // Setup args and check for malformed arguments in the arguments list.
     result = SetupArguments(T, number_of_arguments, arguments, 0, &args);
     if (!::Dart_IsError(result)) {
       result = Api::NewHandle(T, DartEntry::InvokeFunction(function, args));
     }
     return result;
   } else if (obj.IsNull() || obj.IsInstance()) {
     // Since we have allocated an object it would mean that the type of the
     // receiver is already resolved and finalized, hence it is not necessary
     // to check here.
     Instance& instance = Instance::Handle(Z);
     instance ^= obj.raw();
-    ArgumentsDescriptor args_desc(
-        Array::Handle(Z, ArgumentsDescriptor::New(number_of_arguments + 1)));
+    ArgumentsDescriptor args_desc(Array::Handle(
+        Z, ArgumentsDescriptor::New(kTypeArgsLen, number_of_arguments + 1)));
     const Function& function = Function::Handle(
         Z, Resolver::ResolveDynamic(instance, function_name, args_desc));
     if (function.IsNull()) {
       // Setup args and check for malformed arguments in the arguments list.
       result = SetupArguments(T, number_of_arguments, arguments, 1, &args);
       if (!::Dart_IsError(result)) {
         args.SetAt(0, instance);
-        const Array& args_descriptor =
-            Array::Handle(Z, ArgumentsDescriptor::New(args.Length()));
+        const Array& args_descriptor = Array::Handle(
+            Z, ArgumentsDescriptor::New(kTypeArgsLen, args.Length()));
         result = Api::NewHandle(
             T, DartEntry::InvokeNoSuchMethod(instance, function_name, args,
                                              args_descriptor));
       }
       return result;
     }
 #if !defined(PRODUCT)
     if (tds.enabled()) {
       const Class& cls = Class::Handle(Z, instance.clazz());
       ASSERT(!cls.IsNull());
@@ skipping 32 matching lines @@
       const String& lib_name = String::Handle(Z, lib.url());
       tds.SetNumArguments(1);
       tds.FormatArgument(0, "name", "%s.%s", lib_name.ToCString(),
                          function_name.ToCString());
     }
 #endif  // !defined(PRODUCT)
 
     // LookupFunctionAllowPrivate does not check argument arity, so we
     // do it here.
     String& error_message = String::Handle(Z);
-    if (!function.AreValidArgumentCounts(number_of_arguments, 0,
+    if (!function.AreValidArgumentCounts(kTypeArgsLen, 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());
     }
     // Setup args and check for malformed arguments in the arguments list.
     result = SetupArguments(T, number_of_arguments, arguments, 0, &args);
     if (!::Dart_IsError(result)) {
       result = Api::NewHandle(T, DartEntry::InvokeFunction(function, args));
     }
@@ skipping 109 matching lines @@
 #if !defined(PRODUCT)
     if (tds.enabled()) {
       const String& cls_name = String::Handle(cls.Name());
       tds.SetNumArguments(1);
       tds.FormatArgument(0, "name", "%s.%s", cls_name.ToCString(),
                          field_name.ToCString());
     }
 #endif  // !defined(PRODUCT)
 
     // Invoke the getter and return the result.
+    const int kTypeArgsLen = 0;
     const int kNumArgs = 1;
     const Array& args = Array::Handle(Z, Array::New(kNumArgs));
     args.SetAt(0, instance);
     if (getter.IsNull()) {
-      const Array& args_descriptor =
-          Array::Handle(Z, ArgumentsDescriptor::New(args.Length()));
+      const Array& args_descriptor = Array::Handle(
+          Z, ArgumentsDescriptor::New(kTypeArgsLen, args.Length()));
       return Api::NewHandle(
           T, DartEntry::InvokeNoSuchMethod(instance, getter_name, args,
                                            args_descriptor));
     }
     return Api::NewHandle(T, DartEntry::InvokeFunction(getter, args));
 
   } else if (obj.IsLibrary()) {
     // To access a top-level we may need to use the Field or the
     // getter Function.  The getter function may either be in the
     // library or in the field's owner class, depending.
@@ skipping 130 matching lines @@
                              field_name.ToCString());
       }
       setter = cls.LookupDynamicFunctionAllowPrivate(setter_name);
       if (!setter.IsNull()) {
         break;
       }
       cls = cls.SuperClass();
     }
 
     // Invoke the setter and return the result.
+    const int kTypeArgsLen = 0;
     const int kNumArgs = 2;
     const Array& args = Array::Handle(Z, Array::New(kNumArgs));
     args.SetAt(0, instance);
     args.SetAt(1, value_instance);
     if (setter.IsNull()) {
-      const Array& args_descriptor =
-          Array::Handle(Z, ArgumentsDescriptor::New(args.Length()));
+      const Array& args_descriptor = Array::Handle(
+          Z, ArgumentsDescriptor::New(kTypeArgsLen, args.Length()));
       return Api::NewHandle(
           T, DartEntry::InvokeNoSuchMethod(instance, setter_name, args,
                                            args_descriptor));
     }
     return Api::NewHandle(T, DartEntry::InvokeFunction(setter, args));
 
   } else if (obj.IsLibrary()) {
     // To access a top-level we may need to use the Field or the
     // setter Function.  The setter function may either be in the
     // library or in the field's owner class, depending.
@@ skipping 2275 matching lines @@
 }
 
 
 DART_EXPORT void Dart_DumpNativeStackTrace(void* context) {
 #ifndef PRODUCT
   Profiler::DumpStackTrace(context);
 #endif
 }
 
 }  // namespace dart