[kernel] Support for top-level generic functions.

runtime/vm/kernel_binary_flowgraph.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 "vm/kernel_binary_flowgraph.h"
-
 #include "vm/compiler.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 namespace dart {
 namespace kernel {
 
 #define Z (zone_)
@@ skipping 1070 matching lines @@
   Function& function = Function::Handle(Z, parsed_function_->function().raw());
   while (function.IsClosureFunction()) {
     function = function.parent_function();
   }
 
   if (function.IsFactory()) {
     // The type argument vector is passed as the very first argument to the
     // factory constructor function.
     HandleSpecialLoad(&result_->type_arguments_variable,
                       Symbols::TypeArgumentsParameter());
-  } else {
-    // The type argument vector is stored on the instance object. We therefore
-    // need to capture `this`.
+  } else if (!function.IsGeneric()) {
+    // KERNEL_GENERIC_METHODS_UNDONE(sjindel):
+    // Currently we only support generic toplevel methods. For no special load
+    // needs to be prepared for these, because the 'LocalVariable' for the type
+    // arguments is set on the 'ParsedFunction' directly. So we do nothing for
+    // generic methods.
+
+    // The type argument vector is stored on the
+    // instance object. We therefore need to capture `this`.
     HandleSpecialLoad(&result_->this_variable, Symbols::This());
   }
 
   builder_->ReadUInt();              // read index for parameter.
   builder_->SkipOptionalDartType();  // read bound bound.
 }
 
 void StreamingScopeBuilder::HandleLocalFunction(intptr_t parent_kernel_offset) {
   // "Peek" ahead into the function node
   intptr_t offset = builder_->ReaderOffset();
@@ skipping 509 matching lines @@
       }
       parameter_index -= class_types.Length();
     }
 
     intptr_t procedure_type_parameter_count =
         active_class_->MemberIsProcedure()
             ? active_class_->MemberTypeParameterCount(Z)
             : 0;
     if (procedure_type_parameter_count > 0) {
       if (procedure_type_parameter_count > parameter_index) {
-        // Here we technically could load the correct one via something like
-        //     result_ ^= dart::TypeArguments::Handle(
-        //                    Z, active_class_->member->type_parameters())
-        //                    .TypeAt(parameter_index);
-        // but that isn't currently supported elsewhere
-        // (FlowGraphBuilder::LoadFunctionTypeArguments()).
-        result_ ^= dart::Type::DynamicType();
+        if (FLAG_reify_generic_functions) {
+          result_ ^= dart::TypeArguments::Handle(
+                         Z, active_class_->member->type_parameters())
+                         .TypeAt(parameter_index);
+        } else {
+          result_ ^= dart::Type::DynamicType();
+        }
         return;
       }
       parameter_index -= procedure_type_parameter_count;
     }
   }
 
   if (type_parameter_scope_ != NULL && parameter_index >= 0 &&
       parameter_index < type_parameter_scope_->outer_parameter_count() +
                             type_parameter_scope_->parameters_count()) {
     result_ ^= dart::Type::DynamicType();
@@ skipping 1296 matching lines @@
     const Function& function) {
   const Function& target = Function::ZoneHandle(Z, function.parent_function());
 
   TargetEntryInstr* normal_entry = flow_graph_builder_->BuildTargetEntry();
   flow_graph_builder_->graph_entry_ = new (Z) GraphEntryInstr(
       *parsed_function(), normal_entry, Compiler::kNoOSRDeoptId);
   SetupDefaultParameterValues();
 
   Fragment body(normal_entry);
   body += flow_graph_builder_->CheckStackOverflowInPrologue();
+  body += NullConstant();
+  LocalVariable* result = MakeTemporary();
 
   // Load all the arguments.
   ASSERT(target.is_static());
 
+  // KERNEL_GENERIC_METHODS_UNDONE(sjindel): Since the frontend can't yet emit
+  // generic methods into kernel, all type parameters to the target must come
+  // from the context. When generic methods are fully supported, we will need to
+  // get the type arguments provided by the caller and append them to the
+  // captured type arguments via 'prependTypeArguments'.
+
   FunctionNodeHelper function_node_helper(this);
+  function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kTypeParameters);
+  intptr_t type_param_count = PeekUInt();
   function_node_helper.ReadUntilExcluding(
       FunctionNodeHelper::kPositionalParameters);
 
   // Positional.
   const intptr_t positional_argument_count = ReadListLength();
 
   // The first argument is the instance of the closure class.  For converted
   // closures its context field contains the context vector that is used by the
   // converted top-level function (target) explicitly and that should be passed
   // to that function as the first parameter.
   body += LoadLocal(LookupVariable(ReaderOffset()));  // 0th variable offset.
   body += flow_graph_builder_->LoadField(Closure::context_offset());
+  LocalVariable* context = MakeTemporary();
+
+  if (type_param_count > 0) {
+    body += LoadLocal(context);
+    body += flow_graph_builder_->LoadField(Context::variable_offset(0));
+    body += PushArgument();
+  }
+
+  body += LoadLocal(context);
   body += PushArgument();
   SkipVariableDeclaration();  // read 0th variable.
 
   // The rest of the parameters are the same for the method of the Closure class
   // being invoked and the top-level function (target).
   for (intptr_t i = 1; i < positional_argument_count; i++) {
     body += LoadLocal(LookupVariable(ReaderOffset()));  // ith variable offset.
     body += PushArgument();
     SkipVariableDeclaration();  // read ith variable.
   }
 
   // Named.
   const intptr_t named_argument_count = ReadListLength();
   Array& argument_names = Array::ZoneHandle(Z);
   if (named_argument_count > 0) {
     argument_names = Array::New(named_argument_count);
     for (intptr_t i = 0; i < named_argument_count; i++) {
       body +=
           LoadLocal(LookupVariable(ReaderOffset()));  // ith variable offset.
       body += PushArgument();
       argument_names.SetAt(
           i, H.DartSymbol(GetNameFromVariableDeclaration(ReaderOffset())));
       SkipVariableDeclaration();  // read ith variable.
     }
   }
 
   // Forward them to the target.
   const intptr_t argument_count =
-      positional_argument_count + named_argument_count;
+      positional_argument_count + named_argument_count + !!type_param_count;

[jensj, 2017/08/14 06:47:13]

Something like

```
intptr_t argument_count = positional_argument_count + named_argument_count;
if (type_param_count > 0) ++argument_count;
```
would read better.

[sjindel, 2017/08/14 11:05:50]

Done, although 'argument_count' can't be 'const' anymore.

   body += StaticCall(TokenPosition::kNoSource, target, argument_count,
-                     argument_names);
+                     argument_names, type_param_count);
 
   // Return the result.
+  body += StoreLocal(TokenPosition::kNoSource, result);
+  body += Drop();
+  body += Drop();
   body += Return(function_node_helper.end_position_);
 
   return new (Z)
       FlowGraph(*parsed_function(), flow_graph_builder_->graph_entry_,
                 flow_graph_builder_->next_block_id_ - 1);
 }
 
 FlowGraph* StreamingFlowGraphBuilder::BuildGraphOfFunction(
     intptr_t constructor_class_parent_offset) {
   const Function& dart_function = parsed_function()->function();
@@ skipping 1385 matching lines @@
 
 Fragment StreamingFlowGraphBuilder::StaticCall(TokenPosition position,
                                                const Function& target,
                                                intptr_t argument_count) {
   return flow_graph_builder_->StaticCall(position, target, argument_count);
 }
 
 Fragment StreamingFlowGraphBuilder::StaticCall(TokenPosition position,
                                                const Function& target,
                                                intptr_t argument_count,
-                                               const Array& argument_names) {
+                                               const Array& argument_names,
+                                               intptr_t type_args_count) {
   return flow_graph_builder_->StaticCall(position, target, argument_count,
-                                         argument_names);
+                                         argument_names, type_args_count);
 }
 
 Fragment StreamingFlowGraphBuilder::InstanceCall(
     TokenPosition position,
     const dart::String& name,
     Token::Kind kind,
     intptr_t argument_count,
     intptr_t checked_argument_count) {
   return flow_graph_builder_->InstanceCall(position, name, kind, argument_count,
                                            checked_argument_count);
@@ skipping 1398 matching lines @@
   instructions += Constant(function);
   instructions +=
       StoreInstanceField(TokenPosition::kNoSource, Closure::function_offset());
 
   instructions += LoadLocal(closure);
   instructions += LoadLocal(context);
   instructions +=
       StoreInstanceField(TokenPosition::kNoSource, Closure::context_offset());
 
   instructions += Drop();
+  SkipDartType();  // skip function type of the closure.
 
-  SkipDartType();  // skip function type of the closure.
-  SkipListOfDartTypes();  // skip list of type arguments.
+  // KERNEL_GENERIC_METHODS_UNDONE(sjindel): When generic methods are fully
+  // supported in kernel, we'll need to store a NULL in the type arguments slot
+  // when type arguments are absent, so the wrapper for the target function can
+  // tell how many type args are captured vs. provided by the caller of the
+  // closure.
+
+  intptr_t types_count = ReadListLength();  // read type count.
+  if (types_count > 0) {
+    instructions += LoadLocal(context);
+
+    const TypeArguments& type_args =
+        T.BuildTypeArguments(types_count);  // read list of type arguments.
+    instructions += TranslateInstantiatedTypeArguments(type_args);
+
+    instructions += StoreInstanceField(TokenPosition::kNoSource,
+                                       Context::variable_offset(0));
+  }
 
   return instructions;
 }
 
 Fragment StreamingFlowGraphBuilder::BuildInvalidStatement() {
   H.ReportError("Invalid statements not implemented yet!");
   return Fragment();
 }
 
 Fragment StreamingFlowGraphBuilder::BuildExpressionStatement() {
@@ skipping 1360 matching lines @@
     }
   }
 
   return Array::Handle(Array::null());
 }
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)