[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 1077 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()) {
+    // TODO(sjindel): Kernel generic methods undone. 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 506 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_->parameter_count()) {
     result_ ^= dart::Type::DynamicType();
@@ skipping 1324 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

[Dmitry Stefantsov, 2017/08/16 11:44:39]

How about creating an issue and using something like "TODO(<issue_number>)" here
and other places explaining that the frontend doesn't yet fully support generic
methods?  This way anyone can easily find all the places related to the issue. 
We use this technique for TODOs everywhere.

As I get it from my last conversation with Peter, he's ok with creating an issue
in the tracker for generic methods support in fasta.

[sjindel, 2017/08/16 12:57:12]

Done.

+  // 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() + relative_kernel_offset_));  // 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() + relative_kernel_offset_));  // ith variable offset.
     body += PushArgument();
     SkipVariableDeclaration();  // read ith variable.
@@ skipping 12 matching lines @@
 
       // read ith variable.
       VariableDeclarationHelper helper(this);
       helper.ReadUntilExcluding(VariableDeclarationHelper::kEnd);
 
       argument_names.SetAt(i, H.DartSymbol(helper.name_index_));
     }
   }
 
   // Forward them to the target.
-  const intptr_t argument_count =
-      positional_argument_count + named_argument_count;
+  intptr_t argument_count = positional_argument_count + named_argument_count;
+  if (type_param_count) ++argument_count;
   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(bool constructor) {
   const Function& dart_function = parsed_function()->function();
   TargetEntryInstr* normal_entry = flow_graph_builder_->BuildTargetEntry();
@@ skipping 1381 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 1397 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.
+  // TODO(sjindel): Kernel generic methods undone. 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 1375 matching lines @@
     }
   }
 
   return Array::Handle(Array::null());
 }
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)