Support allocating and calling closures in the new non-optimizing compiler.

runtime/vm/flow_graph_builder.cc

 // Copyright (c) 2012, 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/flow_graph_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/flags.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
@@ skipping 789 matching lines @@
     Append(for_value);
     values->Add(for_value.value());
     index = for_value.temp_index();
   }
   CreateArrayComp* create = new CreateArrayComp(node, values);
   ReturnComputation(create);
 }
 
 
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
-  Bailout("EffectGraphVisitor::VisitClosureNode");
+  const Function& function = node->function();
+
+  int next_index = temp_index();
+  if (function.IsNonImplicitClosureFunction()) {
+    const int context_level = 0;  // Only because we don't handle nesting yet.
+    const ContextScope& context_scope = ContextScope::ZoneHandle(
+        node->scope()->PreserveOuterScope(context_level));
+    ASSERT(!function.HasCode());
+    ASSERT(function.context_scope() == ContextScope::null());
+    function.set_context_scope(context_scope);
+  } else if (function.IsImplicitInstanceClosureFunction()) {
+    ValueGraphVisitor for_receiver(owner(), temp_index());
+    node->receiver()->Visit(&for_receiver);
+    Append(for_receiver);
+    if (!for_receiver.value()->IsTemp()) {
+      AddInstruction(new BindInstr(temp_index(), for_receiver.value()));
+    }
+    ++next_index;
+  }
+  ASSERT(function.context_scope() != ContextScope::null());
+
+  // The function type of a closure may have type arguments. In that case, pass
+  // the type arguments of the instantiator.
+  const Class& cls = Class::Handle(function.signature_class());
+  ASSERT(!cls.IsNull());
+  const bool requires_type_arguments = cls.HasTypeArguments();
+  if (requires_type_arguments) {
+    Bailout("Closure creation requiring type arguments");
+  }
+
+  CreateClosureComp* create = new CreateClosureComp(node);
+  ReturnComputation(create);
 }
 
 
 void EffectGraphVisitor::TranslateArgumentList(
     const ArgumentListNode& node,
     intptr_t next_temp_index,
     ZoneGrowableArray<Value*>* values) {
   for (intptr_t i = 0; i < node.length(); ++i) {
     ArgumentGraphVisitor for_argument(owner(), next_temp_index);
     node.NodeAt(i)->Visit(&for_argument);
@@ skipping 31 matching lines @@
   StaticCallComp* call =
       new StaticCallComp(node->token_index(),
                          node->function(),
                          node->arguments()->names(),
                          values);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
-  Bailout("EffectGraphVisitor::VisitClosureCallNode");
+  // Context is saved around the call, it's treated as an extra operand
+  // consumed by the call (but not an argument).
+  AddInstruction(new BindInstr(temp_index(), new CurrentContextComp()));
+
+  ArgumentGraphVisitor for_closure(owner(), temp_index() + 1);
+  node->closure()->Visit(&for_closure);
+  Append(for_closure);
+
+  ZoneGrowableArray<Value*>* arguments =
+      new ZoneGrowableArray<Value*>(node->arguments()->length());
+  arguments->Add(for_closure.value());
+  TranslateArgumentList(*node->arguments(), temp_index() + 2, arguments);
+  // First operand is the saved context, consumed by the call.
+  ClosureCallComp* call =
+      new ClosureCallComp(node, new TempVal(temp_index()), arguments);
+  ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
   Bailout("EffectGraphVisitor::VisitCloneContextNode");
 }
 
 
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
@@ skipping 370 matching lines @@
 }
 
 
 void FlowGraphPrinter::VisitAssertAssignable(AssertAssignableComp* comp) {
   OS::Print("AssertAssignable(");
   comp->value()->Accept(this);
   OS::Print(", %s)", comp->type().ToCString());
 }
 
 
+void FlowGraphPrinter::VisitCurrentContext(CurrentContextComp* comp) {
+  OS::Print("CurrentContext");
+}
+
+
+void FlowGraphPrinter::VisitClosureCall(ClosureCallComp* comp) {
+  OS::Print("ClosureCall(");
+  comp->context()->Accept(this);
+  for (intptr_t i = 0; i < comp->ArgumentCount(); ++i) {
+    OS::Print(", ");
+    comp->ArgumentAt(i)->Accept(this);
+  }
+  OS::Print(")");
+}
+
+
 void FlowGraphPrinter::VisitInstanceCall(InstanceCallComp* comp) {
   OS::Print("InstanceCall(%s", comp->function_name().ToCString());
-  for (int i = 0; i < comp->ArgumentCount(); ++i) {
+  for (intptr_t i = 0; i < comp->ArgumentCount(); ++i) {
     OS::Print(", ");
     comp->ArgumentAt(i)->Accept(this);
   }
   OS::Print(")");
 }
 
 
 void FlowGraphPrinter::VisitStrictCompare(StrictCompareComp* comp) {
   OS::Print("StrictCompare(%s, ", Token::Str(comp->kind()));
   comp->left()->Accept(this);
   OS::Print(", ");
   comp->right()->Accept(this);
   OS::Print(")");
 }
 
 
 
 void FlowGraphPrinter::VisitStaticCall(StaticCallComp* comp) {
   OS::Print("StaticCall(%s",
             String::Handle(comp->function().name()).ToCString());
-  for (int i = 0; i < comp->ArgumentCount(); ++i) {
+  for (intptr_t i = 0; i < comp->ArgumentCount(); ++i) {
     OS::Print(", ");
     comp->ArgumentAt(i)->Accept(this);
   }
   OS::Print(")");
 }
 
 
 void FlowGraphPrinter::VisitLoadLocal(LoadLocalComp* comp) {
   OS::Print("LoadLocal(%s)", comp->local().name().ToCString());
 }
@@ skipping 91 matching lines @@
 void FlowGraphPrinter::VisitCreateArray(CreateArrayComp* comp) {
   OS::Print("CreateArray(");
   for (int i = 0; i < comp->ElementCount(); ++i) {
     if (i != 0) OS::Print(", ");
     comp->ElementAt(i)->Accept(this);
   }
   OS::Print(")");
 }
 
 
+void FlowGraphPrinter::VisitCreateClosure(CreateClosureComp* comp) {
+  OS::Print("CreateClosure(%s)", comp->function().ToCString());
+}
+
+
 void FlowGraphPrinter::VisitJoinEntry(JoinEntryInstr* instr) {
   OS::Print("%2d: [join]", instr->block_number());
 }
 
 
 void FlowGraphPrinter::VisitTargetEntry(TargetEntryInstr* instr) {
   OS::Print("%2d: [target]", instr->block_number());
 }
 
 
@@ skipping 29 matching lines @@
   OS::Print("    if ");
   instr->value()->Accept(this);
   OS::Print(" goto(%d, %d)", instr->true_successor()->block_number(),
             instr->false_successor()->block_number());
 }
 
 
 void FlowGraphBuilder::BuildGraph() {
   if (FLAG_print_ast) {
     // Print the function ast before IL generation.
-    AstPrinter::PrintFunctionNodes(parsed_function_);
+    AstPrinter::PrintFunctionNodes(parsed_function());
+  }
+  const Function& function = parsed_function().function();
+  if ((function.num_optional_parameters() != 0)) {
+    Bailout("function has optional parameters");
   }
   EffectGraphVisitor for_effect(this, 0);
   for_effect.AddInstruction(new TargetEntryInstr());
   parsed_function().node_sequence()->Visit(&for_effect);
   // Check that the graph is properly terminated.
   ASSERT(!for_effect.is_open());
   if (for_effect.entry() != NULL) {
     // Accumulate basic block entries via postorder traversal.
     for_effect.entry()->Postorder(&postorder_block_entries_);
     // Number the blocks in reverse postorder starting with 0.
     intptr_t last_index = postorder_block_entries_.length() - 1;
     for (intptr_t i = last_index; i >= 0; --i) {
       postorder_block_entries_[i]->set_block_number(last_index - i);
     }
   }
   if (FLAG_print_flow_graph) {
-    FlowGraphPrinter printer(parsed_function().function());
+    FlowGraphPrinter printer(function);
     printer.VisitBlocks(postorder_block_entries_);
   }
 }
 
 
 void FlowGraphBuilder::Bailout(const char* reason) {
   const char* kFormat = "FlowGraphBuilder Bailout: %s %s";
   const char* function_name = parsed_function_.function().ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart