Add support for converted closures with explicit contexts to VM

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 311 matching lines @@
 
   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::kConvertedClosureFunction:
     case RawFunction::kRegularFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction:
     case RawFunction::kConstructor: {
       FunctionNode* node;
       if (node_->IsProcedure()) {
         node = Procedure::Cast(node_)->function();
       } else if (node_->IsConstructor()) {
         node = Constructor::Cast(node_)->function();
       } else {
         node = FunctionNode::Cast(node_);
       }
       current_function_node_ = node;
 
       intptr_t pos = 0;
       if (function.IsClosureFunction()) {
         LocalVariable* variable = MakeVariable(
             TokenPosition::kNoSource, TokenPosition::kNoSource,
             Symbols::ClosureParameter(), AbstractType::dynamic_type());
         variable->set_is_forced_stack();
         scope_->InsertParameterAt(pos++, variable);
+      } else if (function.IsConvertedClosureFunction()) {
+        // Do nothing.  The explicit context parameter is already included into
+        // the parameter list of the parent function.
       } else if (!function.is_static()) {
         // We use [is_static] instead of [IsStaticFunction] because the latter
         // returns `false` for constructors.
         dart::Class& klass = dart::Class::Handle(Z, function.Owner());
         Type& klass_type = H.GetCanonicalType(klass);
         LocalVariable* variable =
             MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                          Symbols::This(), klass_type);
         scope_->InsertParameterAt(pos++, variable);
         result_->this_variable = variable;
@@ skipping 14 matching lines @@
         }
       } else if (function.IsFactory()) {
         LocalVariable* variable = MakeVariable(
             TokenPosition::kNoSource, TokenPosition::kNoSource,
             Symbols::TypeArgumentsParameter(), AbstractType::dynamic_type());
         scope_->InsertParameterAt(pos++, variable);
         result_->type_arguments_variable = variable;
       }
       AddParameters(node, pos);
 
-      // We generate a syntethic body for implicit closure functions - which
-      // will forward the call to the real function.
+      // We generate a syntethic body for implicit closure functions and
+      // converted
+      // closure functions - which will forward the call to the real function.
       //     -> see BuildGraphOfImplicitClosureFunction
-      if (!function.IsImplicitClosureFunction()) {
+      //     -> see BuildGraphOfConvertedClosureFunction
+
+      if (!function.IsImplicitClosureFunction() &&
+          !function.IsConvertedClosureFunction()) {
         // TODO(jensj): HACK: Push the begin token to after any parameters to
         // avoid crash when breaking on definition line of async method in
         // debugger. It seems that another scope needs to be added
         // in which captures are made, but I can't make that work.
         // This 'solution' doesn't crash, but I cannot see the parameters at
         // that particular breakpoint either.
         // Also push the end token to after the "}" to avoid crashing on
         // stepping past the last line (to the "}" character).
         if (node->body() != NULL && node->body()->position().IsReal()) {
           scope_->set_begin_token_pos(node->body()->position());
@@ skipping 2793 matching lines @@
 
   // The IR builder will create its own local variables and scopes, and it
   // will not need an AST.  The code generator will assume that there is a
   // local variable stack slot allocated for the current context and (I
   // think) that the runtime will expect it to be at a fixed offset which
   // requires allocating an unused expression temporary variable.
   scopes_ = parsed_function_->EnsureKernelScopes();
 
   switch (function.kind()) {
     case RawFunction::kClosureFunction:
+    case RawFunction::kConvertedClosureFunction:
     case RawFunction::kRegularFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction: {
       FunctionNode* kernel_function = node_->IsProcedure()
                                           ? Procedure::Cast(node_)->function()
                                           : FunctionNode::Cast(node_);
       ActiveFunctionScope active_function_scope(&active_class_,
                                                 kernel_function);
-      return function.IsImplicitClosureFunction()
-                 ? BuildGraphOfImplicitClosureFunction(kernel_function,
-                                                       function)
-                 : BuildGraphOfFunction(kernel_function);
+      if (function.IsImplicitClosureFunction()) {
+        return BuildGraphOfImplicitClosureFunction(kernel_function, function);
+      } else if (function.IsConvertedClosureFunction()) {
+        return BuildGraphOfConvertedClosureFunction(kernel_function, function);
+      } else {
+        return BuildGraphOfFunction(kernel_function);
+      }
     }
     case RawFunction::kConstructor: {
       bool is_factory = function.IsFactory();
       if (is_factory) {
         Procedure* procedure = Procedure::Cast(node_);
         FunctionNode* function = procedure->function();
         ActiveFunctionScope active_function_scope(&active_class_, function);
         return BuildGraphOfFunction(function, NULL);
       } else {
         Constructor* constructor = Constructor::Cast(node_);
@@ skipping 795 matching lines @@
   body += StaticCall(TokenPosition::kNoSource, target, argument_count,
                      argument_names);
 
   // Return the result.
   body += Return(kernel_function->end_position());
 
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
+// This method follows the logic similar to that of
+// FlowGraphBuilder::BuildGraphOfImplicitClosureFunction.  For additional
+// details on converted closure functions, please, see the comment on the method
+// Function::ConvertedClosureFunction.
+FlowGraph* FlowGraphBuilder::BuildGraphOfConvertedClosureFunction(
+    FunctionNode* kernel_function,
+    const Function& function) {
+  const Function& target = Function::ZoneHandle(Z, function.parent_function());
+
+  TargetEntryInstr* normal_entry = BuildTargetEntry();
+  graph_entry_ = new (Z)
+      GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
+  SetupDefaultParameterValues(kernel_function);
+
+  Fragment body(normal_entry);
+  body += CheckStackOverflowInPrologue();
+
+  // Load all the arguments.
+  ASSERT(target.is_static());
+  // The first argument is the value that the target function is converted over.
+  // It is stored in the context field of the Closure class instance.  The
+  // instance is passed as the first argument to the call.
+  body += LoadLocal(parsed_function_->node_sequence()->scope()->VariableAt(0));
+  body += LoadField(Closure::context_offset());
+  body += PushArgument();
+
+  // The rest of the parameters are the same for the method of the Closure class
+  // being invoked and the top-level target function.
+  intptr_t positional_argument_count =
+      kernel_function->positional_parameters().length();
+  for (intptr_t i = 1; i < positional_argument_count; i++) {
+    body +=
+        LoadLocal(LookupVariable(kernel_function->positional_parameters()[i]));
+    body += PushArgument();
+  }
+  intptr_t named_argument_count = kernel_function->named_parameters().length();
+  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++) {
+      VariableDeclaration* variable = kernel_function->named_parameters()[i];
+      body += LoadLocal(LookupVariable(variable));
+      body += PushArgument();
+      argument_names.SetAt(i, H.DartSymbol(variable->name()));
+    }
+  }
+  // Forward them to the target.
+  intptr_t argument_count = positional_argument_count + named_argument_count;
+  body += StaticCall(TokenPosition::kNoSource, target, argument_count,
+                     argument_names);
+
+  // Return the result.
+  body += Return(kernel_function->end_position());
+
+  return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
+}
+
+
 FlowGraph* FlowGraphBuilder::BuildGraphOfNoSuchMethodDispatcher(
     const Function& function) {
   // This function is specialized for a receiver class, a method name, and
   // the arguments descriptor at a call site.
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
       GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
 
   // The backend will expect an array of default values for all the named
@@ skipping 683 matching lines @@
 void DartTypeTranslator::VisitDynamicType(DynamicType* node) {
   result_ = Object::dynamic_type().raw();
 }
 
 
 void DartTypeTranslator::VisitVoidType(VoidType* node) {
   result_ = Object::void_type().raw();
 }
 
 
+void DartTypeTranslator::VisitVectorType(VectorType* node) {
+  result_ = Object::vector_type().raw();
+}
+
+
 void DartTypeTranslator::VisitBottomType(BottomType* node) {
   result_ =
       dart::Class::Handle(Z, I->object_store()->null_class()).CanonicalType();
 }
 
 
 const TypeArguments& DartTypeTranslator::TranslateTypeArguments(
     DartType** dart_types,
     intptr_t length) {
   bool only_dynamic = true;
@@ skipping 908 matching lines @@
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitRethrow(Rethrow* node) {
   fragment_ =
       streaming_flow_graph_builder_->BuildExpressionAt(node->kernel_offset());
 }
 
 
+void FlowGraphBuilder::VisitVectorCreation(VectorCreation* node) {
+  ASSERT(node->value() > 0);

[jensj, 2017/05/18 11:19:06]

STREAM_EXPRESSION_IF_POSSIBLE(node); ? (the same for the other ones)

[Dmitry Stefantsov, 2017/05/18 12:18:53]

Yep, that explains why the code worked without the invocation of 'SkipDartType'
:)

So, I enabled streaming on the new nodes, and seems to work.

+  Fragment instructions = AllocateContext(node->value());
+  fragment_ = instructions;
+}
+
+
+void FlowGraphBuilder::VisitVectorGet(VectorGet* node) {
+  Fragment instructions;
+
+  instructions += TranslateExpression(node->vector_expression());
+  instructions += LoadField(Context::variable_offset(node->index()));
+
+  fragment_ = instructions;
+}
+
+
+void FlowGraphBuilder::VisitVectorSet(VectorSet* node) {
+  Fragment instructions;
+
+  instructions += TranslateExpression(node->vector_expression());
+  instructions += TranslateExpression(node->value());
+  LocalVariable* result = MakeTemporary();
+
+  Value* value = Pop();
+  StoreInstanceFieldInstr* store = new (Z)
+      StoreInstanceFieldInstr(Context::variable_offset(node->index()), Pop(),
+                              value, kNoStoreBarrier, TokenPosition::kNoSource);
+  instructions <<= store;
+
+  // Result of a vector-set operation is its rhs.  It is useful, especially for
+  // assignment chains.
+  instructions += LoadLocal(result);
+
+  fragment_ = instructions;
+}
+
+
+void FlowGraphBuilder::VisitVectorCopy(VectorCopy* node) {
+  Fragment instructions;
+
+  instructions += TranslateExpression(node->vector_expression());
+  CloneContextInstr* clone_instruction =
+      new (Z) CloneContextInstr(TokenPosition::kNoSource, Pop());
+  instructions <<= clone_instruction;
+  Push(clone_instruction);
+
+  fragment_ = instructions;
+}
+
+
+void FlowGraphBuilder::VisitClosureCreation(ClosureCreation* node) {
+  Fragment instructions;
+
+  Function& function = Function::ZoneHandle(
+      Z, H.LookupStaticMethodByKernelProcedure(node->top_level_function()));
+  function = function.ConvertedClosureFunction();
+  ASSERT(!function.IsNull());
+
+  const dart::Class& closure_class =
+      dart::Class::ZoneHandle(Z, I->object_store()->closure_class());
+  instructions += AllocateObject(closure_class, function);
+  LocalVariable* closure = MakeTemporary();
+
+  instructions += TranslateExpression(node->context_vector());
+  LocalVariable* context = MakeTemporary();
+
+  instructions += LoadLocal(closure);
+  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();
+
+  fragment_ = instructions;
+}
+
+
 Fragment FlowGraphBuilder::TranslateArguments(Arguments* node,
                                               Array* argument_names) {
   Fragment instructions;
 
   List<Expression>& positional = node->positional();
   for (intptr_t i = 0; i < positional.length(); ++i) {
     instructions += TranslateExpression(positional[i]);
     instructions += PushArgument();
   }
 
@@ skipping 1143 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)