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 1543 matching lines @@
 }
 
 
 RawObject* ConstantEvaluator::EvaluateConstConstructorCall(
     const dart::Class& type_class,
     const TypeArguments& type_arguments,
     const Function& constructor,
     const Object& argument) {
   // Factories have one extra argument: the type arguments.
   // Constructors have 1 extra arguments: receiver.
+  const int kTypeArgsLen = 0;
   const int kNumArgs = 1;
   const int kNumExtraArgs = 1;
   const int num_arguments = kNumArgs + kNumExtraArgs;
   const Array& arg_values =
       Array::Handle(Z, Array::New(num_arguments, Heap::kOld));
   Instance& instance = Instance::Handle(Z);
   if (!constructor.IsFactory()) {
     instance = Instance::New(type_class, Heap::kOld);
     if (!type_arguments.IsNull()) {
       ASSERT(type_arguments.IsInstantiated());
       instance.SetTypeArguments(
           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()));
+  const Array& args_descriptor =
+      Array::Handle(Z, ArgumentsDescriptor::New(kTypeArgsLen, 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 392 matching lines @@
     arguments.SetAt(pos++, result_);
     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));
+  const int kTypeArgsLen = 0;  // Generic functions not yet supported.
+  const Array& args_descriptor = Array::Handle(
+      Z, ArgumentsDescriptor::New(kTypeArgsLen, 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 515 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 = Function::ZoneHandle(
-      Z, Resolver::ResolveStatic(cls, dart::Library::PrivateCoreLibName(
-                                          Symbols::InterpolateSingle()),
-                                 kNumberOfArguments, kNoArgumentNames));
+      Z,
+      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 1145 matching lines @@
   ZoneGrowableArray<const Instance*>* default_values =
       new ZoneGrowableArray<const Instance*>(Z, descriptor.NamedCount());
   for (intptr_t i = 0; i < descriptor.NamedCount(); ++i) {
     default_values->Add(&Object::null_instance());
   }
   parsed_function_->set_default_parameter_values(default_values);
 
   Fragment body(normal_entry);
   body += CheckStackOverflowInPrologue();
 
+  // TODO(regis): Check if a type argument vector is passed.
+
   // The receiver is the first argument to noSuchMethod, and it is the first
   // argument passed to the dispatcher function.
   LocalScope* scope = parsed_function_->node_sequence()->scope();
   body += LoadLocal(scope->VariableAt(0));
   body += PushArgument();
 
   // The second argument to noSuchMethod is an invocation mirror.  Push the
   // arguments for allocating the invocation mirror.  First, the name.
   body += Constant(dart::String::ZoneHandle(Z, function.name()));
   body += PushArgument();
@@ skipping 35 matching lines @@
   const dart::Class& mirror_class = dart::Class::Handle(
       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.
 
+  const int kTypeArgsLen = 0;
   ArgumentsDescriptor two_arguments(
-      Array::Handle(Z, ArgumentsDescriptor::New(2)));
+      Array::Handle(Z, ArgumentsDescriptor::New(kTypeArgsLen, 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 886 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 1784 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)