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

runtime/vm/flow_graph_inliner.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.
 #if !defined(DART_PRECOMPILED_RUNTIME)
 #include "vm/flow_graph_inliner.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/precompiler.h"
 #include "vm/block_scheduler.h"
 #include "vm/branch_optimizer.h"
@@ skipping 845 matching lines @@
             function.set_is_inlinable(false);
             TRACE_INLINING(THR_Print("     Bailout: optional arg mismatch\n"));
             PRINT_INLINING_TREE("Optional arg mismatch", &call_data->caller,
                                 &function, call_data->call);
             return false;
           }
         }
 
         // After treating optional parameters the actual/formal count must
         // match.
+        // TODO(regis): Consider type arguments in arguments.

[Vyacheslav Egorov (Google), 2017/05/13 22:20:14]

maybe also add 

if (function.IsGeneric()) return false;

for now to avoid hitting assertions / breaking inliner?

[regis, 2017/05/18 21:02:12]

I suspect that many generic functions of the sdk get inlined. They are currently
called without type arguments. I prefer to return only if type arguments are
passed. I already started to work on the inliner in another cl.

         ASSERT(arguments->length() == function.NumParameters());
         ASSERT(param_stubs->length() == callee_graph->parameter_count());
 
         // Update try-index of the callee graph.
         BlockEntryInstr* call_block = call_data->call->GetBlock();
         if (call_block->InsideTryBlock()) {
           intptr_t try_index = call_block->try_index();
           for (BlockIterator it = callee_graph->reverse_postorder_iterator();
                !it.Done(); it.Advance()) {
             BlockEntryInstr* block = it.Current();
@@ skipping 458 matching lines @@
                                    const Array& argument_names,
                                    GrowableArray<Value*>* arguments,
                                    ZoneGrowableArray<Definition*>* param_stubs,
                                    FlowGraph* callee_graph) {
     const Function& function = parsed_function.function();
     // The language and this code does not support both optional positional
     // and optional named parameters for the same function.
     ASSERT(!function.HasOptionalPositionalParameters() ||
            !function.HasOptionalNamedParameters());
 
+    // TODO(regis): Consider type arguments in arguments.
     intptr_t arg_count = arguments->length();
     intptr_t param_count = function.NumParameters();
     intptr_t fixed_param_count = function.num_fixed_parameters();
     ASSERT(fixed_param_count <= arg_count);
     ASSERT(arg_count <= param_count);
 
     if (function.HasOptionalPositionalParameters()) {
       // Create a stub for each optional positional parameters with an actual.
       for (intptr_t i = fixed_param_count; i < arg_count; ++i) {
         param_stubs->Add(CreateParameterStub(i, (*arguments)[i], callee_graph));
@@ skipping 2429 matching lines @@
     }
 
     default:
       return false;
   }
 }
 
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)