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

runtime/vm/flow_graph_compiler.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 "vm/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
@@ skipping 1179 matching lines @@
       break;
     default:
       UNIMPLEMENTED();
   }
 }
 
 
 void FlowGraphCompiler::GenerateStaticCall(intptr_t deopt_id,
                                            TokenPosition token_pos,
                                            const Function& function,
+                                           intptr_t type_args_len,

[Vyacheslav Egorov (Google), 2017/05/04 12:12:22]

I wonder if triple of <type-args-len, pushed_argc, argument_names> should be
wrapped into a structure:

struct ArgumentsInfo {
  public:
    const Array& ToArgumentDescriptor();

  private:
  ...
}; 

[regis, 2017/05/09 18:31:23]

Done.

                                            intptr_t argument_count,
                                            const Array& argument_names,
                                            LocationSummary* locs,
                                            const ICData& ic_data_in) {
   const ICData& ic_data = ICData::ZoneHandle(ic_data_in.Original());
-  const Array& arguments_descriptor =
-      Array::ZoneHandle(ic_data.IsNull() ? ArgumentsDescriptor::New(
-                                               argument_count, argument_names)
-                                         : ic_data.arguments_descriptor());
+  const Array& arguments_descriptor = Array::ZoneHandle(
+      ic_data.IsNull()
+          ? ArgumentsDescriptor::New(
+                type_args_len, argument_count - (type_args_len > 0 ? 1 : 0),
+                argument_names)
+          : ic_data.arguments_descriptor());
   if (is_optimizing()) {
     EmitOptimizedStaticCall(function, arguments_descriptor, argument_count,
                             deopt_id, token_pos, locs);
   } else {
     ICData& call_ic_data = ICData::ZoneHandle(ic_data.raw());
     if (call_ic_data.IsNull()) {
       const intptr_t kNumArgsChecked = 0;
       call_ic_data =
           GetOrAddStaticCallICData(deopt_id, function, arguments_descriptor,
                                    kNumArgsChecked)
@@ skipping 617 matching lines @@
   return true;
 }
 
 
 #if !defined(TARGET_ARCH_DBC)
 // DBC emits calls very differently from other architectures due to its
 // interpreted nature.
 void FlowGraphCompiler::EmitPolymorphicInstanceCall(
     const CallTargets& targets,
     const InstanceCallInstr& original_call,
+    intptr_t type_args_len,
     intptr_t argument_count,
     const Array& argument_names,
     intptr_t deopt_id,
     TokenPosition token_pos,
     LocationSummary* locs,
     bool complete,
     intptr_t total_ic_calls) {
   if (FLAG_polymorphic_with_deopt) {
     Label* deopt =
         AddDeoptStub(deopt_id, ICData::kDeoptPolymorphicInstanceCallTestFail);
     Label ok;
-    EmitTestAndCall(targets, original_call.function_name(), argument_count,
-                    argument_names,
+    EmitTestAndCall(targets, original_call.function_name(), type_args_len,
+                    argument_count, argument_names,
                     deopt,  // No cid match.
                     &ok,    // Found cid.
                     deopt_id, token_pos, locs, complete, total_ic_calls);
     assembler()->Bind(&ok);
   } else {
     if (complete) {
       Label ok;
-      EmitTestAndCall(targets, original_call.function_name(), argument_count,
-                      argument_names,
+      EmitTestAndCall(targets, original_call.function_name(), type_args_len,
+                      argument_count, argument_names,
                       NULL,  // No cid match.
                       &ok,   // Found cid.
                       deopt_id, token_pos, locs, true, total_ic_calls);
       assembler()->Bind(&ok);
     } else {
       const ICData& unary_checks = ICData::ZoneHandle(
           zone(), original_call.ic_data()->AsUnaryClassChecks());
       EmitSwitchableInstanceCall(unary_checks, argument_count, deopt_id,
                                  token_pos, locs);
     }
   }
 }
 
 
 #define __ assembler()->
 void FlowGraphCompiler::EmitTestAndCall(const CallTargets& targets,
                                         const String& function_name,
+                                        intptr_t type_args_len,
                                         intptr_t argument_count,
                                         const Array& argument_names,
                                         Label* failed,
                                         Label* match_found,
                                         intptr_t deopt_id,
                                         TokenPosition token_index,
                                         LocationSummary* locs,
                                         bool complete,
                                         intptr_t total_ic_calls) {
   ASSERT(is_optimizing());
 
   const Array& arguments_descriptor = Array::ZoneHandle(
-      zone(), ArgumentsDescriptor::New(argument_count, argument_names));
+      zone(), ArgumentsDescriptor::New(
+                  type_args_len, argument_count - (type_args_len > 0 ? 1 : 0),
+                  argument_names));
 
   EmitTestAndCallLoadReceiver(argument_count, arguments_descriptor);
 
   static const int kNoCase = -1;
   int smi_case = kNoCase;
   int which_case_to_skip = kNoCase;
 
   const int length = targets.length();
   ASSERT(length > 0);
   int non_smi_length = length;
@@ skipping 161 matching lines @@
 
 
 void FlowGraphCompiler::FrameStateClear() {
   ASSERT(!is_optimizing());
   frame_state_.TruncateTo(0);
 }
 #endif  // defined(DEBUG) && !defined(TARGET_ARCH_DBC)
 
 
 }  // namespace dart