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

runtime/vm/precompiler.cc

 // Copyright (c) 2015, 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/precompiler.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/branch_optimizer.h"
@@ skipping 805 matching lines @@
       for (intptr_t k = 0; k < fields.Length(); k++) {
         field ^= fields.At(k);
         if (field.is_static()) continue;
         field_type = field.type();
         if (!field_type.IsFunctionType()) continue;
         field_name = field.name();
         if (!IsSent(field_name)) continue;
         // Create arguments descriptor with fixed parameters from
         // signature of field_type.
         function = Type::Cast(field_type).signature();
+        if (function.IsGeneric()) continue;
         if (function.HasOptionalParameters()) continue;
         if (FLAG_trace_precompiler) {
           THR_Print("Found callback field %s\n", field_name.ToCString());
         }
-        args_desc = ArgumentsDescriptor::New(function.num_fixed_parameters());
+        args_desc = ArgumentsDescriptor::New(0,  // No type argument vector.
+                                             function.num_fixed_parameters());
         cids.Clear();
         if (T->cha()->ConcreteSubclasses(cls, &cids)) {
           for (intptr_t j = 0; j < cids.length(); ++j) {
             subcls ^= I->class_table()->At(cids[j]);
             if (subcls.is_allocated()) {
               // Add dispatcher to cls.
               dispatcher = subcls.GetInvocationDispatcher(
                   field_name, args_desc, RawFunction::kInvokeFieldDispatcher,
                   /* create_if_absent = */ true);
               if (FLAG_trace_precompiler) {
@@ skipping 1665 matching lines @@
   Zone* zone = Thread::Current()->zone();
 
   for (BlockIterator block_it = graph->reverse_postorder_iterator();
        !block_it.Done(); block_it.Advance()) {
     ForwardInstructionIterator it(block_it.Current());
     for (; !it.Done(); it.Advance()) {
       Instruction* instr = it.Current();
       if (instr->IsInstanceCall()) {
         InstanceCallInstr* call = instr->AsInstanceCall();
         if (!call->HasICData()) {
-          const Array& arguments_descriptor = Array::Handle(
-              zone, ArgumentsDescriptor::New(call->ArgumentCount(),
-                                             call->argument_names()));
+          const Array& arguments_descriptor =
+              Array::Handle(zone, call->GetArgumentsDescriptor());
           const ICData& ic_data = ICData::ZoneHandle(
               zone, ICData::New(function, call->function_name(),
                                 arguments_descriptor, call->deopt_id(),
                                 call->checked_argument_count(), false));
           call->set_ic_data(&ic_data);
         }
       } else if (instr->IsStaticCall()) {
         StaticCallInstr* call = instr->AsStaticCall();
         if (!call->HasICData()) {
-          const Array& arguments_descriptor = Array::Handle(
-              zone, ArgumentsDescriptor::New(call->ArgumentCount(),
-                                             call->argument_names()));
+          const Array& arguments_descriptor =
+              Array::Handle(zone, call->GetArgumentsDescriptor());
           const Function& target = call->function();
           MethodRecognizer::Kind recognized_kind =
               MethodRecognizer::RecognizeKind(target);
           int num_args_checked = 0;
           switch (recognized_kind) {
             case MethodRecognizer::kDoubleFromInteger:
             case MethodRecognizer::kMathMin:
             case MethodRecognizer::kMathMax:
               num_args_checked = 2;
               break;
@@ skipping 822 matching lines @@
 
   ASSERT(FLAG_precompiled_mode);
   const bool optimized = function.IsOptimizable();  // False for natives.
   DartPrecompilationPipeline pipeline(zone, field_type_map);
   return PrecompileFunctionHelper(precompiler, &pipeline, function, optimized);
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart