Support inlining of calls where type arguments are passed to generic functions.

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 302 matching lines @@
 
   LocalScope* enclosing_scope = NULL;
   if (function.IsLocalFunction()) {
     enclosing_scope = LocalScope::RestoreOuterScope(
         ContextScope::Handle(Z, function.context_scope()));
   }
   current_function_scope_ = scope_ = new (Z) LocalScope(enclosing_scope, 0, 0);
   scope_->set_begin_token_pos(function.token_pos());
   scope_->set_end_token_pos(function.end_token_pos());
 
+  if (FLAG_reify_generic_functions && function.IsGeneric()) {
+    LocalVariable* type_args_var = MakeVariable(
+        TokenPosition::kNoSource, TokenPosition::kNoSource,
+        Symbols::FunctionTypeArgumentsVar(), Object::dynamic_type());
+    type_args_var->set_is_forced_stack();  // TODO(regis): Necessary?
+    scope_->AddVariable(type_args_var);
+    ASSERT(parsed_function->function_type_arguments() == NULL);
+    parsed_function->set_function_type_arguments(type_args_var);
+  }
   LocalVariable* context_var = parsed_function->current_context_var();
   context_var->set_is_forced_stack();
   scope_->AddVariable(context_var);
 
   parsed_function->SetNodeSequence(
       new SequenceNode(TokenPosition::kNoSource, scope_));
 
   switch (function.kind()) {
     case RawFunction::kClosureFunction:
     case RawFunction::kRegularFunction:
@@ skipping 2209 matching lines @@
   ArgumentArray arguments = GetArguments(argument_count);
   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_, GetNextDeoptId());
   Push(call);
   return Fragment(call);
 }
 
 
-Fragment FlowGraphBuilder::ClosureCall(int argument_count,
+Fragment FlowGraphBuilder::ClosureCall(intptr_t type_args_len,
+                                       intptr_t argument_count,
                                        const Array& argument_names) {
   Value* function = Pop();
-  ArgumentArray arguments = GetArguments(argument_count);
-  const intptr_t kTypeArgsLen = 0;  // Generic closures not yet supported.
+  const intptr_t total_count = argument_count + (type_args_len > 0 ? 1 : 0);
+  ArgumentArray arguments = GetArguments(total_count);
   ClosureCallInstr* call = new (Z)
-      ClosureCallInstr(function, arguments, kTypeArgsLen, argument_names,
+      ClosureCallInstr(function, arguments, type_args_len, argument_names,
                        TokenPosition::kNoSource, GetNextDeoptId());
   Push(call);
   return Fragment(call);
 }
 
 
 Fragment FlowGraphBuilder::ThrowException(TokenPosition position) {
   Fragment instructions;
   instructions += Drop();
   instructions +=
@@ skipping 1640 matching lines @@
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
       GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
 
   Fragment body(normal_entry);
   body += CheckStackOverflowInPrologue();
 
   LocalScope* scope = parsed_function_->node_sequence()->scope();
 
+  if (descriptor.TypeArgsLen() > 0) {
+    LocalVariable* type_args = parsed_function_->function_type_arguments();
+    ASSERT(type_args != NULL);
+    body += LoadLocal(type_args);
+    body += PushArgument();
+  }
+
   LocalVariable* closure = NULL;
   if (is_closure_call) {
     closure = scope->VariableAt(0);
 
     // The closure itself is the first argument.
     body += LoadLocal(closure);
   } else {
     // Invoke the getter to get the field value.
     body += LoadLocal(scope->VariableAt(0));
     body += PushArgument();
     body +=
         InstanceCall(TokenPosition::kMinSource, getter_name, Token::kGET, 1);
   }
 
   body += PushArgument();
 
   // Push all arguments onto the stack.
   intptr_t pos = 1;
   for (; pos < descriptor.Count(); pos++) {
     body += LoadLocal(scope->VariableAt(pos));
     body += PushArgument();
   }
 
   if (is_closure_call) {
     // Lookup the function in the closure.
     body += LoadLocal(closure);
     body += LoadField(Closure::function_offset());
 
-    body += ClosureCall(descriptor.Count(), argument_names);
+    body += ClosureCall(descriptor.TypeArgsLen(), descriptor.Count(),
+                        argument_names);
   } else {
+    if (descriptor.TypeArgsLen() > 0) {
+      UNIMPLEMENTED();
+    }
     body += InstanceCall(TokenPosition::kMinSource, Symbols::Call(),
                          Token::kILLEGAL, descriptor.Count(), argument_names);
   }
 
   body += Return(TokenPosition::kNoSource);
 
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
@@ skipping 2610 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)