enterForLoop body should be in scope in for-loop update

pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart

 // Copyright (c) 2013, 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.
 
 library dart2js.ir_builder;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
@@ skipping 925 matching lines @@
                  JumpTarget target,
                  ClosureScope closureScope,
                  List<LocalElement> loopVariables}) {
     assert(isOpen);
 
     // For loops use four named continuations: the entry to the condition,
     // the entry to the body, the loop exit, and the loop successor (break).
     // The CPS translation of
     // [[for (initializer; condition; update) body; successor]] is:
     //
+    // _enterForLoopInitializer();
     // [[initializer]];
     // let cont loop(x, ...) =
     //     let prim cond = [[condition]] in
     //     let cont break() = [[successor]] in
     //     let cont exit() = break(v, ...) in
     //     let cont body() =
-    //       let cont continue(x, ...) = [[update]]; loop(v, ...) in
-    //       [[body]]; continue(v, ...) in
+    //         _enterForLoopBody();
+    //         let cont continue(x, ...) =
+    //             _enterForLoopUpdate();
+    //             [[update]];
+    //             loop(v, ...) in
+    //         [[body]];
+    //         continue(v, ...) in
     //     branch cond (body, exit) in
     // loop(v, ...)
     //
     // If there are no breaks in the body, the break continuation is inlined
     // in the exit continuation (i.e., the translation of the successor
     // statement occurs in the exit continuation).  If there is only one
     // invocation of the continue continuation (i.e., no continues in the
     // body), the continue continuation is inlined in the body.
 
     _enterForLoopInitializer(closureScope, loopVariables);
 
     buildInitializer(this);
 
     IrBuilder condBuilder = makeRecursiveBuilder();
     ir.Primitive condition = buildCondition(condBuilder);
     if (condition == null) {
       // If the condition is empty then the body is entered unconditionally.
       condition = condBuilder.buildBooleanLiteral(true);
     }
 
     JumpCollector breakCollector = new JumpCollector(target);
     JumpCollector continueCollector = new JumpCollector(target);
     state.breakCollectors.add(breakCollector);
     state.continueCollectors.add(continueCollector);
 
-    IrBuilder bodyBuilder = condBuilder.makeDelimitedBuilder();
+    IrBuilder outerBodyBuilder = condBuilder.makeDelimitedBuilder();
+    outerBodyBuilder._enterForLoopBody(closureScope, loopVariables);
 
-    bodyBuilder._enterForLoopBody(closureScope, loopVariables);
+    IrBuilder innerBodyBuilder = outerBodyBuilder.makeDelimitedBuilder();
 
-    buildBody(bodyBuilder);
+    buildBody(innerBodyBuilder);
     assert(state.breakCollectors.last == breakCollector);
     assert(state.continueCollectors.last == continueCollector);
     state.breakCollectors.removeLast();
     state.continueCollectors.removeLast();
 
     // The binding of the continue continuation should occur as late as
     // possible, that is, at the nearest common ancestor of all the continue
     // sites in the body.  However, that is difficult to compute here, so it
     // is instead placed just outside the body of the body continuation.
     bool hasContinues = !continueCollector.isEmpty;
     IrBuilder updateBuilder = hasContinues
-        ? condBuilder.makeRecursiveBuilder()
-        : bodyBuilder;
+        ? outerBodyBuilder.makeRecursiveBuilder()
+        : innerBodyBuilder;
     updateBuilder._enterForLoopUpdate(closureScope, loopVariables);
     buildUpdate(updateBuilder);
 
     // Create body entry and loop exit continuations and a branch to them.
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     ir.Continuation exitContinuation = new ir.Continuation([]);
     // Note the order of continuations: the first one is the one that will
     // be filled by LetCont.plug.
     ir.LetCont branch =
         new ir.LetCont.many(<ir.Continuation>[exitContinuation,
@@ skipping 10 matching lines @@
       condBuilder.add(letJoin);
       condBuilder._current = branch;
     } else {
       condBuilder.add(branch);
     }
     ir.Continuation continueContinuation;
     if (hasContinues) {
       // If there are continues in the body, we need a named continue
       // continuation as a join point.
       continueContinuation = new ir.Continuation(updateBuilder._parameters);
-      if (bodyBuilder.isOpen) continueCollector.addJump(bodyBuilder);
+      if (innerBodyBuilder.isOpen) continueCollector.addJump(innerBodyBuilder);
       invokeFullJoin(continueContinuation, continueCollector);
     }
     ir.Continuation loopContinuation =
         new ir.Continuation(condBuilder._parameters);
     if (updateBuilder.isOpen) {
       JumpCollector backEdges = new JumpCollector(null);
       backEdges.addJump(updateBuilder);
       invokeFullJoin(loopContinuation, backEdges, recursive: true);
     }
 
     // Fill in the body and possible continue continuation bodies.  Do this
     // only after it is guaranteed that they are not empty.
     if (hasContinues) {
       continueContinuation.body = updateBuilder._root;
-      bodyContinuation.body =
-          new ir.LetCont(continueContinuation,
-              bodyBuilder._root);
+      outerBodyBuilder.add(new ir.LetCont(continueContinuation,
+                                          innerBodyBuilder._root));
     } else {
-      bodyContinuation.body = bodyBuilder._root;
+      outerBodyBuilder.add(innerBodyBuilder._root);
     }
+    bodyContinuation.body = outerBodyBuilder._root;
 
     loopContinuation.body = condBuilder._root;
     add(new ir.LetCont(loopContinuation,
             new ir.InvokeContinuation(loopContinuation,
                 environment.index2value)));
     if (hasBreaks) {
       _current = branch;
       environment = condBuilder.environment;
       breakCollector.addJump(this);
       letJoin.continuations =
@@ skipping 1053 matching lines @@
   final Map<Local, ClosureLocation> freeVariables;
 
   ClosureEnvironment(this.selfReference, this.thisLocal, this.freeVariables);
 }
 
 class TryStatementInfo {
   final Set<LocalVariableElement> declared = new Set<LocalVariableElement>();
   final Set<LocalVariableElement> boxedOnEntry =
       new Set<LocalVariableElement>();
 }