dart2dart: Fix a scoping bug in the translation of loops.

sdk/lib/_internal/compiler/implementation/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 'cps_ir_nodes.dart' as ir;
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
@@ skipping 528 matching lines @@
   void invokeRecursiveJoin(ir.Continuation join, List<IrBuilder> contexts) {
     for (IrBuilder context in contexts) {
       // Passing `this` as one of the contexts will not do the right thing
       // (this.environment has already been mutated).
       assert(context != this);
       List<ir.Primitive> args =
           context.environment.index2value.sublist(0, join.parameters.length);
       context.add(new ir.InvokeContinuation(join, args, recursive: true));
       context.current = null;
     }
-    assert(environment.index2value.length <= join.parameters.length);
-    for (int i = 0; i < environment.index2value.length; ++i) {
-      environment.index2value[i] = join.parameters[i];
-    }
   }
 
   ir.Primitive visitFor(ast.For node) {
     assert(isOpen);
     // TODO(kmillikin,sigurdm): Handle closure variables declared in a for-loop.
     if (node.initializer is ast.VariableDefinitions) {
       ast.VariableDefinitions definitions = node.initializer;
       for (ast.Node definition in definitions.definitions.nodes) {
         Element element = elements[definition];
         if (isClosureVariable(element)) {
           return giveup(definition, 'Closure variable in for loop initializer');
         }
       }
     }
 
     // For loops use three named continuations: the entry to the condition,
     // the entry to the body, and the loop exit (break).  The CPS translation
     // of [[for (initializer; condition; update) body; successor]] is:
     //
     // [[initializer]];
     // let cont loop(x, ...) =
+    //     let prim cond = [[condition]] in
     //     let cont exit() = [[successor]] in
     //     let cont body() = [[body]]; [[update]]; loop(v, ...) in
-    //     let prim cond = [[condition]] in
     //     branch cond (body, exit) in
     // loop(v, ...)
 
     if (node.initializer != null) visit(node.initializer);
 
     IrBuilder condBuilder = new IrBuilder.recursive(this);
     ir.Primitive condition;
     if (node.condition == null) {
       // If the condition is empty then the body is entered unconditionally.
       condition = makePrimConst(constantSystem.createBool(true));
       condBuilder.add(new ir.LetPrim(condition));
     } else {
       condition = condBuilder.visit(node.condition);
     }
 
     IrBuilder bodyBuilder = new IrBuilder.delimited(condBuilder);
     bodyBuilder.visit(node.body);
     for (ast.Node n in node.update) {
       if (!bodyBuilder.isOpen) break;
       bodyBuilder.visit(n);
     }
 
     // Create body entry and loop exit continuations and a join-point
     // continuation if control flow reaches the end of the body (update).
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     ir.Continuation exitContinuation = new ir.Continuation([]);
-    condBuilder.add(new ir.Branch(new ir.IsTrue(condition),
-                                  bodyContinuation,
-                                  exitContinuation));
+    condBuilder.add(
+        new ir.LetCont(exitContinuation,
+            new ir.LetCont(bodyContinuation,
+                new ir.Branch(new ir.IsTrue(condition),
+                              bodyContinuation,
+                              exitContinuation))));
     List<ir.Parameter> parameters = condBuilder.parameters;
     ir.Continuation loopContinuation = new ir.Continuation(parameters);
-    // Copy the environment here because invokeJoin will update it for the
-    // join-point continuation.
-    List<ir.Primitive> entryArguments =
-        new List<ir.Primitive>.from(environment.index2value);
     if (bodyBuilder.isOpen) {
       invokeRecursiveJoin(loopContinuation, [bodyBuilder]);
     }
     bodyContinuation.body = bodyBuilder.root;
 
-    ir.Expression resultContext =
-        new ir.LetCont(exitContinuation,
-            new ir.LetCont(bodyContinuation,
-                condBuilder.root));
-    loopContinuation.body = resultContext;
+    loopContinuation.body = condBuilder.root;
     add(new ir.LetCont(loopContinuation,
-            new ir.InvokeContinuation(loopContinuation, entryArguments)));
-    current = resultContext;
+            new ir.InvokeContinuation(loopContinuation,
+                                      environment.index2value)));
+    current = condBuilder.current;
+    environment = condBuilder.environment;
     return null;
   }
 
   ir.Primitive visitIf(ast.If node) {
     assert(isOpen);
     ir.Primitive condition = visit(node.condition);
 
     // The then and else parts are delimited.
     IrBuilder thenBuilder = new IrBuilder.delimited(this);
     IrBuilder elseBuilder = new IrBuilder.delimited(this);
@@ skipping 49 matching lines @@
     }
     return null;
   }
 
   ir.Primitive visitWhile(ast.While node) {
     assert(isOpen);
     // While loops use three named continuations: the entry to the body,
     // the loop exit (break), and the loop back edge (continue).
     // The CPS translation of [[while (condition) body; successor]] is:
     //
     // let cont loop(x, ...) =

[sigurdm, 2014/08/12 07:25:53]

Should this be loop(v, ...)?

[Kevin Millikin (Google), 2014/08/12 08:54:55]

It's not necessarily the same as the v, ... passed to loop or continue (those
aren't necessarily the same as each other, either, to be precise).  I'm trying
to use x to range over parameters, p (or sometimes a real name like cond) to
range over let-prim bound primitives, and v to range over all primitives.

But I'm probably not consistent :)

+    //     let prim cond = [[condition]] in
     //     let cont exit() = [[successor]] in
     //     let cont body() = [[body]]; continue(v, ...) in
-    //     let prim cond = [[condition]] in
     //     branch cond (body, exit) in
     // loop(v, ...)
 
     // The condition and body are delimited.
     IrBuilder condBuilder = new IrBuilder.recursive(this);
     ir.Primitive condition = condBuilder.visit(node.condition);
 
     IrBuilder bodyBuilder = new IrBuilder.delimited(condBuilder);
     bodyBuilder.visit(node.body);
 
     // Create body entry and loop exit continuations and a join-point
     // continuation if control flow reaches the end of the body.
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     ir.Continuation exitContinuation = new ir.Continuation([]);
-    condBuilder.add(new ir.Branch(new ir.IsTrue(condition),
-                                  bodyContinuation,
-                                  exitContinuation));
+    condBuilder.add(
+        new ir.LetCont(exitContinuation,
+            new ir.LetCont(bodyContinuation,
+                new ir.Branch(new ir.IsTrue(condition),
+                              bodyContinuation,
+                              exitContinuation))));
     List<ir.Parameter> parameters = condBuilder.parameters;
     ir.Continuation loopContinuation = new ir.Continuation(parameters);
-    // Copy the environment here because invokeJoin will update it for the
-    // join-point continuation.
-    List<ir.Primitive> entryArguments =
-        new List<ir.Primitive>.from(environment.index2value);
     if (bodyBuilder.isOpen) {
       invokeRecursiveJoin(loopContinuation, [bodyBuilder]);
     }
     bodyContinuation.body = bodyBuilder.root;
 
-    ir.Expression resultContext =
-        new ir.LetCont(exitContinuation,
-            new ir.LetCont(bodyContinuation,
-                condBuilder.root));
-    loopContinuation.body = resultContext;
+    loopContinuation.body = condBuilder.root;
     add(new ir.LetCont(loopContinuation,
-            new ir.InvokeContinuation(loopContinuation, entryArguments)));
-    current = resultContext;
+            new ir.InvokeContinuation(loopContinuation,
+                                      environment.index2value)));
+    current = condBuilder.current;
+    environment = condBuilder.environment;
     return null;
   }
 
   ir.Primitive visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(isOpen);
     if (node.modifiers.isConst) {
       for (ast.SendSet definition in node.definitions.nodes) {
         assert(!definition.arguments.isEmpty);
         assert(definition.arguments.tail.isEmpty);
         VariableElement element = elements[definition];
@@ skipping 930 matching lines @@
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     FunctionElement oldFunction = currentFunction;
     currentFunction = elements[node];
     visit(node.body);
     currentFunction = oldFunction;
   }
 
 }