Check for a passed-in type argument vector in the prolog of 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 1779 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 1636 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)