Dart2dart: Support for-loop variables captured in loop body.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_visitor.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.
 
 part of dart2js.ir_builder;
 
 /**
  * This task iterates through all resolved elements and builds [ir.Node]s. The
  * nodes are stored in the [nodes] map and accessible through [hasIr] and
  * [getIr].
@@ skipping 392 matching lines @@
 
   // Build(ExpressionStatement(e), C) = C'
   //   where (C', _) = Build(e, C)
   ir.Primitive visitExpressionStatement(ast.ExpressionStatement node) {
     assert(irBuilder.isOpen);
     visit(node.expression);
     return null;
   }
 
   visitFor(ast.For node) {
-    // TODO(asgerf): Handle closure variables declared in a for-loop.
-    if (!isJavaScriptBackend && node.initializer is ast.VariableDefinitions) {
+    List<LocalElement> loopVariables = <LocalElement>[];
+    if (node.initializer is ast.VariableDefinitions) {
       ast.VariableDefinitions definitions = node.initializer;
-      for (ast.Node definition in definitions.definitions.nodes) {
-        LocalElement element = elements[definition];
-        DartIrBuilder dartIrBuilder = irBuilder;
-        if (dartIrBuilder.isInClosureVariable(element)) {
-          return giveup(definition, 'Closure variable in for loop initializer');
-        }
+      for (ast.Node node in definitions.definitions.nodes) {
+        LocalElement loopVariable = elements[node];
+        loopVariables.add(loopVariable);
       }
     }
 
     JumpTarget target = elements.getTargetDefinition(node);
     irBuilder.buildFor(
         buildInitializer: subbuild(node.initializer),
         buildCondition: subbuild(node.condition),
         buildBody: subbuild(node.body),
         buildUpdate: subbuildSequence(node.update),
         closureScope: getClosureScope(node),
+        loopVariables: loopVariables,
         target: target);
   }
 
   visitIf(ast.If node) {
     irBuilder.buildIf(
         build(node.condition),
         subbuild(node.thenPart),
         subbuild(node.elsePart));
   }
 
@@ skipping 596 matching lines @@
   ir.Primitive visitFunctionExpression(ast.FunctionExpression node) {
     return irBuilder.buildFunctionExpression(makeSubFunction(node));
   }
 
   visitFunctionDeclaration(ast.FunctionDeclaration node) {
     LocalFunctionElement element = elements[node.function];
     Object inner = makeSubFunction(node.function);
     irBuilder.declareLocalFunction(element, inner);
   }
 
-  static final String ABORT_IRNODE_BUILDER = "IrNode builder aborted";
-
-  dynamic giveup(ast.Node node, [String reason]) {
-    throw ABORT_IRNODE_BUILDER;
-  }
-
   ir.ExecutableDefinition nullIfGiveup(ir.ExecutableDefinition action()) {
     try {
       return action();
     } catch(e, tr) {
       if (e == ABORT_IRNODE_BUILDER) {
         return null;
       }
       rethrow;
     }
   }
 
   void internalError(String reason, {ast.Node node}) {
     giveup(node);
   }
 }
 
-/// Classifies local variables and local functions as 'closure variables'.
-/// A closure variable is one that is accessed from an inner function nested
-/// one or more levels inside the one that declares it.
+final String ABORT_IRNODE_BUILDER = "IrNode builder aborted";
+
+dynamic giveup(ast.Node node, [String reason]) {
+  throw ABORT_IRNODE_BUILDER;
+}
+
+/// Classifies local variables and local functions as captured, if they
+/// are accessed from within a nested function.
+///
+/// This class is specific to the [DartIrBuilder], in that it gives up if it
+/// sees a feature that is currently unsupport by that builder. In particular,
+/// loop variables captured in a for-loop initializer, condition, or update
+/// expression are unsupported.
 class DetectClosureVariables extends ast.Visitor
                              implements ClosureVariableInfo {
   final TreeElements elements;
   DetectClosureVariables(this.elements);
 
   FunctionElement currentFunction;
   bool insideInitializer = false;
   Set<Local> capturedVariables = new Set<Local>();
 
   void markAsClosureVariable(Local local) {
     capturedVariables.add(local);
   }
 
   visit(ast.Node node) => node.accept(this);
 
   visitNode(ast.Node node) {
     node.visitChildren(this);
   }
 
+  visitFor(ast.For node) {
+    if (node.initializer != null) visit(node.initializer);
+    if (node.condition != null) visit(node.condition);
+    if (node.update != null) visit(node.update);
+
+    // Give up if a variable was captured outside of the loop body.
+    if (node.initializer is ast.VariableDefinitions) {
+      ast.VariableDefinitions definitions = node.initializer;
+      for (ast.Node node in definitions.definitions.nodes) {
+        LocalElement loopVariable = elements[node];
+        if (capturedVariables.contains(loopVariable)) {
+          return giveup(node, 'For-loop variable captured in loop header');
+        }
+      }
+    }
+
+    if (node.body != null) visit(node.body);
+  }
+
   void handleSend(ast.Send node) {
     Element element = elements[node];
     if (Elements.isLocal(element) &&
         !element.isConst &&
         element.enclosingElement != currentFunction) {
       LocalElement local = element;
       markAsClosureVariable(local);
     }
   }
 
@@ skipping 26 matching lines @@
     currentFunction = elements[node];
     if (node.initializers != null) {
       insideInitializer = true;
       visit(node.initializers);
       insideInitializer = false;
     }
     visit(node.body);
     currentFunction = oldFunction;
   }
 }