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

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, 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 <set>
 
 #include "vm/kernel_to_il.h"
 
 #include "vm/compiler.h"
 #include "vm/intermediate_language.h"
@@ skipping 1725 matching lines @@
           TypeArguments::Handle(Z, type_arguments.Canonicalize()));
     }
     arg_values.SetAt(0, instance);
   } else {
     // Prepend type_arguments to list of arguments to factory.
     ASSERT(type_arguments.IsZoneHandle());
     arg_values.SetAt(0, type_arguments);
   }
   arg_values.SetAt((0 + kNumExtraArgs), argument);
   const Array& args_descriptor = Array::Handle(
-      Z, ArgumentsDescriptor::New(num_arguments, Object::empty_array()));
+      Z, ArgumentsDescriptor::New(0, num_arguments, Object::empty_array()));
   const Object& result = Object::Handle(
       Z, DartEntry::InvokeFunction(constructor, arg_values, args_descriptor));
   ASSERT(!result.IsError());
   if (constructor.IsFactory()) {
     // The factory method returns the allocated object.
     instance ^= result.raw();
   }
   return H.Canonicalize(instance);
 }
 
@@ skipping 393 matching lines @@
     names.SetAt(i, H.DartSymbol(named_expression->name()));
   }
   return RunFunction(function, arguments, names);
 }
 
 
 const Object& ConstantEvaluator::RunFunction(const Function& function,
                                              const Array& arguments,
                                              const Array& names) {
   const Array& args_descriptor =
-      Array::Handle(Z, ArgumentsDescriptor::New(arguments.Length(), names));
+      Array::Handle(Z, ArgumentsDescriptor::New(0, arguments.Length(), names));
   const Object& result = Object::Handle(
       Z, DartEntry::InvokeFunction(function, arguments, args_descriptor));
   if (result.IsError()) {
     H.ReportError(Error::Cast(result), "error evaluating constant constructor");
   }
   return result;
 }
 
 
 FlowGraphBuilder::FlowGraphBuilder(
@@ skipping 497 matching lines @@
 }
 
 
 Fragment FlowGraphBuilder::InstanceCall(TokenPosition position,
                                         const dart::String& name,
                                         Token::Kind kind,
                                         intptr_t argument_count,
                                         const Array& argument_names,
                                         intptr_t num_args_checked) {
   ArgumentArray arguments = GetArguments(argument_count);
-  InstanceCallInstr* call =
-      new (Z) InstanceCallInstr(position, name, kind, arguments, argument_names,
-                                num_args_checked, ic_data_array_);
+  const intptr_t kTypeArgsLen = 0;  // Generic instance calls not yet supported.
+  InstanceCallInstr* call = new (Z)
+      InstanceCallInstr(position, name, kind, arguments, kTypeArgsLen,
+                        argument_names, num_args_checked, ic_data_array_);
   Push(call);
   return Fragment(call);
 }
 
 
 Fragment FlowGraphBuilder::ClosureCall(int argument_count,
                                        const Array& argument_names) {
   Value* function = Pop();
   ArgumentArray arguments = GetArguments(argument_count);
-  ClosureCallInstr* call = new (Z) ClosureCallInstr(
-      function, arguments, argument_names, TokenPosition::kNoSource);
+  const intptr_t kTypeArgsLen = 0;  // Generic closures not yet supported.
+  ClosureCallInstr* call =
+      new (Z) ClosureCallInstr(function, arguments, kTypeArgsLen,
+                               argument_names, TokenPosition::kNoSource);
   Push(call);
   return Fragment(call);
 }
 
 
 Fragment FlowGraphBuilder::ThrowException(TokenPosition position) {
   Fragment instructions;
   instructions += Drop();
   instructions += Fragment(new (Z) ThrowInstr(position)).closed();
   // Use it's side effect of leaving a constant on the stack (does not change
@@ skipping 192 matching lines @@
   }
   return FactoryRecognizer::ResultCid(function);
 }
 
 
 Fragment FlowGraphBuilder::StaticCall(TokenPosition position,
                                       const Function& target,
                                       intptr_t argument_count,
                                       const Array& argument_names) {
   ArgumentArray arguments = GetArguments(argument_count);
-  StaticCallInstr* call = new (Z) StaticCallInstr(
-      position, target, argument_names, arguments, ic_data_array_);
+  const intptr_t kTypeArgsLen = 0;  // Generic static calls not yet supported.
+  StaticCallInstr* call =
+      new (Z) StaticCallInstr(position, target, kTypeArgsLen, argument_names,
+                              arguments, ic_data_array_);
   const intptr_t list_cid =
       GetResultCidOfListFactory(Z, target, argument_count);
   if (list_cid != kDynamicCid) {
     call->set_result_cid(list_cid);
     call->set_is_known_list_constructor(true);
   } else if (target.recognized_kind() != MethodRecognizer::kUnknown) {
     call->set_result_cid(MethodRecognizer::ResultCid(target));
   }
   Push(call);
   return Fragment(call);
@@ skipping 100 matching lines @@
 Fragment FlowGraphBuilder::StringInterpolate(TokenPosition position) {
   Value* array = Pop();
   StringInterpolateInstr* interpolate =
       new (Z) StringInterpolateInstr(array, position);
   Push(interpolate);
   return Fragment(interpolate);
 }
 
 
 Fragment FlowGraphBuilder::StringInterpolateSingle(TokenPosition position) {
+  const int kTypeArgsLen = 0;
   const int kNumberOfArguments = 1;
   const Array& kNoArgumentNames = Object::null_array();
   const dart::Class& cls = dart::Class::Handle(
       dart::Library::LookupCoreClass(Symbols::StringBase()));
   ASSERT(!cls.IsNull());
   const Function& function = dart::Function::ZoneHandle(
-      Z, dart::Resolver::ResolveStatic(cls, dart::Library::PrivateCoreLibName(
-                                                Symbols::InterpolateSingle()),
-                                       kNumberOfArguments, kNoArgumentNames));
+      Z,
+      dart::Resolver::ResolveStatic(
+          cls, dart::Library::PrivateCoreLibName(Symbols::InterpolateSingle()),
+          kTypeArgsLen, kNumberOfArguments, kNoArgumentNames));
   Fragment instructions;
   instructions += PushArgument();
   instructions += StaticCall(position, function, 1);
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::ThrowTypeError() {
   const dart::Class& klass = dart::Class::ZoneHandle(
       Z, dart::Library::LookupCoreClass(Symbols::TypeError()));
@@ skipping 1183 matching lines @@
       Z, dart::Library::LookupCoreClass(Symbols::InvocationMirror()));
   ASSERT(!mirror_class.IsNull());
   const Function& allocation_function = Function::ZoneHandle(
       Z, mirror_class.LookupStaticFunction(dart::Library::PrivateCoreLibName(
              Symbols::AllocateInvocationMirror())));
   ASSERT(!allocation_function.IsNull());
   body += StaticCall(TokenPosition::kMinSource, allocation_function, 4);
   body += PushArgument();  // For the call to noSuchMethod.
 
   ArgumentsDescriptor two_arguments(
-      Array::Handle(Z, ArgumentsDescriptor::New(2)));
+      Array::Handle(Z, ArgumentsDescriptor::New(0, 2)));
   Function& no_such_method =
       Function::ZoneHandle(Z, Resolver::ResolveDynamicForReceiverClass(
                                   dart::Class::Handle(Z, function.Owner()),
                                   Symbols::NoSuchMethod(), two_arguments));
   if (no_such_method.IsNull()) {
     // If noSuchMethod is not found on the receiver class, call
     // Object.noSuchMethod.
     no_such_method = Resolver::ResolveDynamicForReceiverClass(
         dart::Class::Handle(Z, I->object_store()->object_class()),
         Symbols::NoSuchMethod(), two_arguments);
@@ skipping 840 matching lines @@
   if (target.IsGenerativeConstructor() || target.IsFactory()) {
     // The VM requires a TypeArguments object as first parameter for
     // every factory constructor.
     ++argument_count;
   }
 
   List<NamedExpression>& named = node->arguments()->named();
   const Array& argument_names = H.ArgumentNames(&named);
 
   // The frontend ensures we the [StaticInvocation] has matching arguments.
-  ASSERT(target.AreValidArguments(argument_count, argument_names, NULL));
+  const intptr_t kTypeArgsLen = 0;  // Generic functions not yet supported.
+  ASSERT(target.AreValidArguments(kTypeArgsLen, argument_count, argument_names,
+                                  NULL));
 
   Fragment instructions;
   LocalVariable* instance_variable = NULL;
 
   // If we cross the Kernel -> VM core library boundary, a [StaticInvocation]
   // can appear, but the thing we're calling is not a static method, but a
   // factory constructor.
   // The `H.LookupStaticmethodByKernelProcedure` will potentially resolve to the
   // forwarded constructor.
   // In that case we'll make an instance and pass it as first argument.
@@ skipping 1733 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)