[kernel] Support for top-level 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 772 matching lines @@
     ASSERT(type_arguments_field_offset != dart::Class::kNoTypeArguments);
 
     instructions += LoadLocal(scopes_->this_variable);
     instructions += LoadField(type_arguments_field_offset);
   } else {
     instructions += NullConstant();
   }
   return instructions;
 }
 
+// TODO(sjindel): Kernel generic methods undone. This seems to work for static
+// top-level functions, but probably needs to be revisited when generic methods
+// are fully supported in kernel.
 Fragment FlowGraphBuilder::LoadFunctionTypeArguments() {
-  UNIMPLEMENTED();  // TODO(regis)
-  return Fragment(NULL);
+  Fragment instructions;
+  ASSERT(parsed_function_->function_type_arguments() != NULL);
+  instructions += LoadLocal(parsed_function_->function_type_arguments());
+  return instructions;
 }
 
 Fragment FlowGraphBuilder::InstantiateType(const AbstractType& type) {
   Value* function_type_args = Pop();
   Value* instantiator_type_args = Pop();
   InstantiateTypeInstr* instr = new (Z) InstantiateTypeInstr(
       TokenPosition::kNoSource, type, instantiator_type_args,
       function_type_args, GetNextDeoptId());
   Push(instr);
   return Fragment(instr);
@@ skipping 469 matching lines @@
       (function.name() == Symbols::ListFactory().raw())) {
     ASSERT(argument_count == 1 || argument_count == 2);
     return (argument_count == 1) ? kGrowableObjectArrayCid : kArrayCid;
   }
   return FactoryRecognizer::ResultCid(function);
 }
 
 Fragment FlowGraphBuilder::StaticCall(TokenPosition position,
                                       const Function& target,
                                       intptr_t argument_count,
-                                      const Array& argument_names) {
+                                      const Array& argument_names,
+                                      intptr_t type_args_count) {
   ArgumentArray arguments = GetArguments(argument_count);
-  const intptr_t kTypeArgsLen = 0;  // Generic static calls not yet supported.
   StaticCallInstr* call =
-      new (Z) StaticCallInstr(position, target, kTypeArgsLen, argument_names,
+      new (Z) StaticCallInstr(position, target, type_args_count, argument_names,
                               arguments, ic_data_array_, GetNextDeoptId());
   const intptr_t list_cid =
       GetResultCidOfListFactory(Z, target, argument_count);
   if (list_cid != kDynamicCid) {
     call->set_result_cid(list_cid);
     call->set_is_known_list_constructor(true);
   } else if (target.recognized_kind() != MethodRecognizer::kUnknown) {
     call->set_result_cid(MethodRecognizer::ResultCid(target));
   }
   Push(call);
@@ skipping 1110 matching lines @@
   array_object = AsSortedDuplicateFreeArray(&token_positions);
   script.set_debug_positions(array_object);
   array_object = AsSortedDuplicateFreeArray(&yield_positions);
   script.set_yield_positions(array_object);
 }
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)