Support compilation of for loops.

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 592 matching lines @@
     target_entry->SetSuccessor(for_test.entry());
     body_exit->SetSuccessor(target_entry);
   }
 
   *for_test.true_successor_address() = join;
   exit_ = *for_test.false_successor_address() = new TargetEntryInstr();
 }
 
 
 void EffectGraphVisitor::VisitForNode(ForNode* node) {
-  Bailout("EffectGraphVisitor::VisitForNode");
+  EffectGraphVisitor for_initializer(owner(), temp_index());
+  node->initializer()->Visit(&for_initializer);
+  Append(for_initializer);
+  if (!is_open()) return;

[srdjan, 2012/03/08 17:55:12]

Should this be an assert? Can we have initializers that are not open?

[Kevin Millikin (Google), 2012/03/09 08:52:53]

Other than the throw in expression context issue that we have already assumed
will be changed somehow, I don't think we can have initializers that are not
open---from the concrete syntax there are no statement subparts.

On the other hand, it is a SequenceNode, and our assumption was that
SequenceNodes can have escapes, so I decided to write the code so it would not
assume otherwise.  Nothing in the types prevents abuses in the parser code like
putting a throw in there.  I actually prefer in that case to make this code
work, rather than relying on code coverage and tests to uncover a debug ASSERT.

This is a case where IMO it actively hurts us to discard the structure of the
concrete syntax in favor of an untyped AST representation.

I'll change this to an assert for now.

+
+  EffectGraphVisitor for_body(owner(), temp_index());
+  node->body()->Visit(&for_body);
+  if (for_body.is_open()) {
+    EffectGraphVisitor for_increment(owner(), temp_index());
+    node->increment()->Visit(&for_increment);
+    for_body.Append(for_increment);
+  }
+
+  if (node->condition() != NULL) {
+    TestGraphVisitor for_test(owner(), temp_index());
+    node->condition()->Visit(&for_test);
+    TieLoop(for_test, for_body);
+    return;
+  }
+
+  // Degenerate cases.  An absent condition is implicitly true.  No
+  // normal exit from loop => no back edge.
+  if (!for_body.is_open()) {
+    Append(for_body);
+    return;
+  }
+  JoinEntryInstr* join = new JoinEntryInstr();
+  AddInstruction(join);
+  if (for_body.is_empty()) {
+    join->SetSuccessor(join);
+  } else {
+    join->SetSuccessor(for_body.entry());
+    for_body.exit()->SetSuccessor(join);
+  }
+  CloseFragment();
 }
 
 
 void EffectGraphVisitor::VisitJumpNode(JumpNode* node) {
   Bailout("EffectGraphVisitor::VisitJumpNode");
 }
 
 
 void EffectGraphVisitor::VisitArgumentListNode(ArgumentListNode* node) {
   UNREACHABLE();
@@ skipping 552 matching lines @@
   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