Revert "dart2js cps: Remove unneeded bailout on captured loop variables."

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.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_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../common.dart';
 import '../common/names.dart' show
@@ skipping 2259 matching lines @@
   }
 
   dynamic giveup(ast.Node node, [String reason]) {
     bailoutMessage = '($node): $reason';
     throw ABORT_IRNODE_BUILDER;
   }
 }
 
 final String ABORT_IRNODE_BUILDER = "IrNode builder aborted";
 
-/// Determines which local variables should be boxed in a mutable variable
-/// inside a given try block.
-class TryBoxedVariables extends ast.Visitor {
+/// 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 DartCapturedVariables extends ast.Visitor {
   final TreeElements elements;
-  TryBoxedVariables(this.elements);
+  DartCapturedVariables(this.elements);
 
   FunctionElement currentFunction;
   bool insideInitializer = false;
   Set<Local> capturedVariables = new Set<Local>();
 
   /// A map containing variables boxed inside try blocks.
   ///
   /// The map is keyed by the [NodeList] of catch clauses for try/catch and
   /// by the finally block for try/finally.  try/catch/finally is treated
   /// as a try/catch nested in the try block of a try/finally.
@@ skipping 25 matching lines @@
       info.boxedOnEntry.removeAll(capturedVariables);
     }
   }
 
   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;
       markAsCaptured(local);
     }
   }
 
@@ skipping 37 matching lines @@
     node.visitChildren(this);
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     FunctionElement savedFunction = currentFunction;
     currentFunction = elements[node];
 
     if (currentFunction.asyncMarker != AsyncMarker.SYNC &&
         currentFunction.asyncMarker != AsyncMarker.SYNC_STAR &&
         currentFunction.asyncMarker != AsyncMarker.ASYNC) {
-      giveup(node, "cannot handle async* functions");
+      giveup(node, "cannot handle sync*/async* functions");
     }
 
+    bool savedInsideInitializer = insideInitializer;
     if (node.initializers != null) {
+      insideInitializer = true;
       visit(node.initializers);
     }
+    insideInitializer = false;
     visit(node.body);
     currentFunction = savedFunction;
+    insideInitializer = savedInsideInitializer;
   }
 
   visitTryStatement(ast.TryStatement node) {
     // Try/catch/finally is treated as two simpler constructs: try/catch and
     // try/finally.  The encoding is:
     //
     // try S0 catch (ex, st) S1 finally S2
     // ==>
     // try { try S0 catch (ex, st) S1 } finally S2
     //
@@ skipping 687 matching lines @@
     body.functionSignature.orderedForEachParameter((ParameterElement param) {
       if (scope != null && scope.capturedVariables.containsKey(param)) {
         // Do not pass this parameter; the box will carry its value.
       } else {
         parameters.add(param);
       }
     });
     return parameters;
   }
 
-  TryBoxedVariables _analyzeTryBoxedVariables(ast.Node node) {
-    TryBoxedVariables variables = new TryBoxedVariables(elements);
+  DartCapturedVariables _analyzeCapturedVariables(ast.Node node) {
+    DartCapturedVariables variables = new DartCapturedVariables(elements);
     try {
       variables.analyze(node);
     } catch (e) {
       bailoutMessage = variables.bailoutMessage;
       rethrow;
     }
     return variables;
   }
 
   /// Builds the IR for the body of a constructor.
   ///
   /// This function is invoked from one or more "factory" constructors built by
   /// [buildConstructor].
   ir.FunctionDefinition buildConstructorBody(ConstructorBodyElement body) {
     ConstructorElement constructor = body.constructor;
     ast.FunctionExpression node = constructor.node;
     closureClassMap =
         compiler.closureToClassMapper.computeClosureToClassMapping(
             constructor,
             node,
             elements);
 
     // We compute variables boxed in mutable variables on entry to each try
     // block, not including variables captured by a closure (which are boxed
     // in the heap).  This duplicates some of the work of closure conversion
     // without directly using the results.  This duplication is wasteful and
     // error-prone.
     // TODO(kmillikin): We should combine closure conversion and try/catch
     // variable analysis in some way.
-    TryBoxedVariables variables = _analyzeTryBoxedVariables(node);
+    DartCapturedVariables variables = _analyzeCapturedVariables(node);
     tryStatements = variables.tryStatements;
     IrBuilder builder = getBuilderFor(body);
 
     return withBuilder(builder, () {
       irBuilder.buildConstructorBodyHeader(getConstructorBodyParameters(body),
                                            getClosureScopeForNode(node));
       visit(node.body);
       return irBuilder.makeFunctionDefinition();
     });
   }
 
   ir.FunctionDefinition buildFunction(FunctionElement element) {
     assert(invariant(element, element.isImplementation));
     ast.FunctionExpression node = element.node;
 
     assert(!element.isSynthesized);
     assert(node != null);
     assert(elements[node] != null);
 
     closureClassMap =
         compiler.closureToClassMapper.computeClosureToClassMapping(
             element,
             node,
             elements);
-    TryBoxedVariables variables = _analyzeTryBoxedVariables(node);
+    DartCapturedVariables variables = _analyzeCapturedVariables(node);
     tryStatements = variables.tryStatements;
     IrBuilder builder = getBuilderFor(element);
     return withBuilder(builder, () => _makeFunctionBody(element, node));
   }
 
   /// Creates a primitive for the default value of [parameter].
   ir.Primitive translateDefaultValue(ParameterElement parameter) {
     if (parameter.initializer == null) {
       return irBuilder.buildNullConstant();
     } else {
@@ skipping 382 matching lines @@
     if (compiler.backend.isForeign(function)) {
       return handleForeignCode(node, function, argumentList, callStructure);
     } else {
       return irBuilder.buildStaticFunctionInvocation(function, callStructure,
           translateStaticArguments(argumentList, function, callStructure),
           sourceInformation:
               sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 }