tree-ir: Always declare captured variables.

pkg/compiler/lib/src/tree_ir/tree_ir_builder.dart

 // Copyright (c) 2014, 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 tree_ir_builder;
 
 import '../dart2jslib.dart' as dart2js;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
@@ skipping 51 matching lines @@
   /// This is not safe if the code is moved inside the scope of an exception
   /// handler (i.e., into a try block).  We keep a stack of singly-referenced
   /// continuations that are in scope without crossing a binding for a handler.
   List<cps_ir.Continuation> safeForInlining = <cps_ir.Continuation>[];
 
   ExecutableElement currentElement;
   /// The 'this' Parameter for currentElement or the enclosing method.
   cps_ir.Parameter thisParameter;
   cps_ir.Continuation returnContinuation;
 
-  /// Number of loops enclosing the currently visited node.
-  int enclosingLoops = 0;
-
   Builder parent;
 
   Builder(this.internalError, [this.parent]);
 
   Builder createInnerBuilder() {
     return new Builder(internalError, this);
   }
 
   /// Variable used in [buildPhiAssignments] as a temporary when swapping
   /// variables.
@@ skipping 384 matching lines @@
           nextBuilder);
     }
   }
 
   Statement visitLetMutable(cps_ir.LetMutable node) {
     Variable variable = addMutableVariable(node.variable);
     Expression value = getVariableUse(node.value);
     Statement body = visit(node.body);
     // If the variable was captured by an inner function in the body, this
     // must be declared here so we assign to a fresh copy of the variable.
-    if (variable.isCaptured && enclosingLoops > 0) {
+    if (variable.isCaptured) {
       return new VariableDeclaration(variable, value, body);
     }
     return Assign.makeStatement(variable, value, body);
   }
 
   Expression visitGetMutableVariable(cps_ir.GetMutableVariable node) {
     return getMutableVariableUse(node.variable);
   }
 
   Statement visitSetMutableVariable(cps_ir.SetMutableVariable node) {
@@ skipping 46 matching lines @@
             //       inline at the invocation site.
             //     - If there are multiple uses, translate to Break.
             //   * Recursive continuations
             //     - There is a single non-recursive invocation.  Translate
             //       the continuation body inline as a labeled loop at the
             //       invocation site.
             //     - Translate the recursive invocations to Continue.
             if (cont.isRecursive) {
               return node.isRecursive
                   ? new Continue(labels[cont])
-                  : new WhileTrue(labels[cont], makeLoopBody(cont.body));
+                  : new WhileTrue(labels[cont], visit(cont.body));
             } else {
               if (cont.hasExactlyOneUse) {
                 if (safeForInlining.contains(cont)) {
                   return visit(cont.body);
                 }
                 labels[cont] = new Label();
               }
               return new Break(labels[cont]);
             }
           });
     }
   }
 
-  Statement makeLoopBody(cps_ir.Expression body) {
-    ++enclosingLoops;
-    Statement result = visit(body);
-    --enclosingLoops;
-    return result;
-  }
-
   Statement visitBranch(cps_ir.Branch node) {
     Expression condition = visit(node.condition);
     Statement thenStatement, elseStatement;
     cps_ir.Continuation cont = node.trueContinuation.definition;
     assert(cont.parameters.isEmpty);
     thenStatement =
         cont.hasExactlyOneUse ? visit(cont.body) : new Break(labels[cont]);
     cont = node.falseContinuation.definition;
     assert(cont.parameters.isEmpty);
     elseStatement =
@@ skipping 74 matching lines @@
   }
 
   @override
   Node visitTypeExpression(cps_ir.TypeExpression node) {
     return new TypeExpression(
         node.dartType,
         node.arguments.map(getVariableUse).toList());
   }
 }