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

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 161 matching lines @@
   /// [nodes] in its context using [build].
   // TODO(johnniwinther): Type [nodes] as `Iterable<N>` when `NodeList` uses
   // `List` instead of `Link`.
   SubbuildFunction subbuildSequence(/*Iterable<N>*/ nodes) {
     return (IrBuilder builder) {
       return withBuilder(builder, () => builder.buildSequence(nodes, build));
     };
   }
 }
 
-/// Shared state between IrBuilders of nested functions.
-class IrBuilderClosureState {
-  /// Maps local variables to their corresponding [ClosureVariable] object.
-  final Map<Local, ir.ClosureVariable> local2closure =
-      <Local, ir.ClosureVariable>{};
-
-  /// Maps functions to the list of closure variables declared in that function.
-  final Map<ExecutableElement, List<ir.ClosureVariable>> function2closures =
-      <ExecutableElement, List<ir.ClosureVariable>>{};
-
-  /// Returns the closure variables declared in the given function.
-  List<ir.ClosureVariable> getClosureList(ExecutableElement element) {
-    return function2closures.putIfAbsent(element, () => <ir.ClosureVariable>[]);
-  }
-
-  /// Creates a closure variable for the given local.
-  void makeClosureVariable(Local local) {
-    ir.ClosureVariable variable =
-        new ir.ClosureVariable(local.executableContext, local);
-    local2closure[local] = variable;
-    getClosureList(local.executableContext).add(variable);
-  }
-}
-
 /// Shared state between delimited IrBuilders within the same function.
-class IrBuilderSharedState {
+class IrBuilderDelimitedState {
   final ConstantSystem constantSystem;
 
   /// A stack of collectors for breaks.
   final List<JumpCollector> breakCollectors = <JumpCollector>[];
 
   /// A stack of collectors for continues.
   final List<JumpCollector> continueCollectors = <JumpCollector>[];
 
   final List<ConstDeclaration> localConstants = <ConstDeclaration>[];
 
   final ExecutableElement currentElement;
 
   final ir.Continuation returnContinuation = new ir.Continuation.retrn();
 
   final List<ir.Definition> functionParameters = <ir.Definition>[];
 
-  /// Maps boxed locals to their location. These locals are not part of
-  /// the environment.
-  final Map<Local, ClosureLocation> boxedVariables = {};
-
-  /// If non-null, this refers to the receiver (`this`) in the enclosing method.
-  ir.Primitive receiver;
-
-  IrBuilderSharedState(this.constantSystem, this.currentElement);
+  IrBuilderDelimitedState(this.constantSystem, this.currentElement);
 }
 
 /// A factory for building the cps IR.
 ///
 /// [DartIrBuilder] and [JsIrBuilder] implement nested functions and captured
 /// variables in different ways.
 abstract class IrBuilder {
   IrBuilder _makeInstance();
 
   void declareLocalVariable(LocalVariableElement element,
                             {ir.Primitive initialValue});
   void declareLocalFunction(LocalFunctionElement element, Object function);
   ir.Primitive buildFunctionExpression(Object function);
   ir.Primitive buildLocalGet(LocalElement element);
   ir.Primitive buildLocalSet(LocalElement element, ir.Primitive value);
 
   /// Called when entering a nested function with free variables.
-  /// The free variables should subsequently be accessible using [buildLocalGet]
+  ///
+  /// The free variables must subsequently be accessible using [buildLocalGet]
   /// and [buildLocalSet].
-  void _buildClosureEnvironmentSetup(ClosureEnvironment env);
+  void _enterClosureEnvironment(ClosureEnvironment env);

[asgerf, 2015/01/14 08:55:57]

I reverted to the "enterXXX" naming scheme because names like
"buildForLoopInitializerScopeSetup" are not that helpful.

Instead I named these functions based on how they are used rather than what they
do.

 
-  /// Enter a scope that declares boxed variables. The boxed variables must
-  /// subsequently be accessible using [buildLocalGet], [buildLocalSet], etc.
-  void _buildClosureScopeSetup(ClosureScope scope);
+  /// Called when entering a function body or loop body.
+  ///
+  /// This does not called for for-loops, which instead use the methods

[sigurdm, 2015/01/14 12:02:48]

This 'is' not

[asgerf, 2015/01/14 12:08:21]

Thanks.

+  /// [_enterForLoopInitializer], [_enterForLoopBody], and [_enterForLoopUpdate]
+  /// due to their special scoping rules.
+  ///
+  /// The boxed variables declared in this scope must subsequently be available
+  /// using [buildLocalGet], [buildLocalSet], etc.
+  void _enterScope(ClosureScope scope);
+
+  /// Called before building the initializer of a for-loop.
+  ///
+  /// The loop variables will subsequently be declared using
+  /// [declareLocalVariable].
+  void _enterForLoopInitializer(ClosureScope scope,
+                                List<LocalElement> loopVariables);
+
+  /// Called before building the body of a for-loop.
+  void _enterForLoopBody(ClosureScope scope,
+                         List<LocalElement> loopVariables);
+
+  /// Called before building the update of a for-loop.
+  void _enterForLoopUpdate(ClosureScope scope,
+                           List<LocalElement> loopVariables);
 
   /// Add the given function parameter to the IR, and bind it in the environment
   /// or put it in its box, if necessary.
   void _createFunctionParameter(ParameterElement parameterElement);
 
-  /// Called before the update expression of a for-loop. A new box should be
-  /// created for [scope] and the values from the old box should be copied over.
-  void _migrateLoopVariables(ClosureScope scope);
+  /// Returns the list of closure variables declared in the given function or
+  /// field initializer.
+  List<ir.ClosureVariable> _getDeclaredClosureVariables(ExecutableElement elm);
+
+  /// Creates an access to the receiver from the current (or enclosing) method.
+  ///
+  /// If inside a closure class, [buildThis] will redirect access through
+  /// closure fields in order to access the receiver from the enclosing method.
+  ir.Primitive buildThis();
 
   // TODO(johnniwinther): Make these field final and remove the default values
   // when [IrBuilder] is a property of [IrBuilderVisitor] instead of a mixin.
 
   final List<ir.Parameter> _parameters = <ir.Parameter>[];
 
-  IrBuilderSharedState state;
-
-  IrBuilderClosureState closure;
+  IrBuilderDelimitedState state;
 
   /// A map from variable indexes to their values.
   ///
   /// [BoxLocal]s map to their box. [LocalElement]s that are boxed are not
   /// in the map; look up their [BoxLocal] instead.
   Environment environment;
 
   // The IR builder maintains a context, which is an expression with a hole in
   // it.  The hole represents the focus where new expressions can be added.
   // The context is implemented by 'root' which is the root of the expression
@@ skipping 16 matching lines @@
   // We do not pass contexts as arguments or return them.  Rather we use the
   // current context (root, current) as the visitor state and mutate current.
   // Visiting a statement returns null; visiting an expression returns the
   // primitive denoting its value.
 
   ir.Expression _root = null;
   ir.Expression _current = null;
 
   /// Initialize a new top-level IR builder.
   void _init(ConstantSystem constantSystem, ExecutableElement currentElement) {
-    state = new IrBuilderSharedState(constantSystem, currentElement);
-    closure = new IrBuilderClosureState();
+    state = new IrBuilderDelimitedState(constantSystem, currentElement);
     environment = new Environment.empty();
   }
 
   /// Construct a delimited visitor for visiting a subtree.
   ///
   /// The delimited visitor has its own compile-time environment mapping
   /// local variables to their values, which is initially a copy of the parent
   /// environment.  It has its own context for building an IR expression, so
   /// the built expression is not plugged into the parent's context.
   IrBuilder makeDelimitedBuilder() {
     return _makeInstance()
         ..state = state
-        ..closure = closure
         ..environment = new Environment.from(environment);
   }
 
   /// Construct a visitor for a recursive continuation.
   ///
   /// The recursive continuation builder has fresh parameters (i.e. SSA phis)
   /// for all the local variables in the parent, because the invocation sites
   /// of the continuation are not all known when the builder is created.  The
   /// recursive invocations will be passed values for all the local variables,
   /// which may be eliminated later if they are redundant---if they take on
   /// the same value at all invocation sites.
   IrBuilder makeRecursiveBuilder() {
     IrBuilder inner = _makeInstance()
         ..state = state
-        ..closure = closure
         ..environment = new Environment.empty();
     environment.index2variable.forEach(inner.createLocalParameter);
     return inner;
   }
 
   /// Construct a builder for an inner function.
   IrBuilder makeInnerFunctionBuilder(ExecutableElement currentElement) {
     return _makeInstance()
-        ..state = new IrBuilderSharedState(state.constantSystem, currentElement)
-        ..closure = closure
+        ..state = new IrBuilderDelimitedState(state.constantSystem, currentElement)
         ..environment = new Environment.empty();
   }
 
   bool get isOpen => _root == null || _current != null;
 
 
   void buildFieldInitializerHeader({ClosureScope closureScope}) {
-    _buildClosureScopeSetup(closureScope);
+    _enterScope(closureScope);
   }
 
   void buildFunctionHeader(Iterable<ParameterElement> parameters,
                           {ClosureScope closureScope,
                            ClosureEnvironment closureEnvironment}) {
-    _buildClosureEnvironmentSetup(closureEnvironment);
-    _buildClosureScopeSetup(closureScope);
+    _enterClosureEnvironment(closureEnvironment);
+    _enterScope(closureScope);
     parameters.forEach(_createFunctionParameter);
   }
 
   /// Creates a parameter for [local] and adds it to the current environment.
   ir.Parameter createLocalParameter(Local local) {
     ir.Parameter parameter = new ir.Parameter(local);
     _parameters.add(parameter);
     environment.extend(local, parameter);
     return parameter;
   }
@@ skipping 234 matching lines @@
           message: "Non-empty body for abstract method $element: $_root"));
       assert(invariant(element, state.localConstants.isEmpty,
           message: "Local constants for abstract method $element: "
                    "${state.localConstants}"));
       return new ir.FunctionDefinition.abstract(
                 element, state.functionParameters, defaults);
     } else {
       ir.RunnableBody body = makeRunnableBody();
       return new ir.FunctionDefinition(
           element, state.functionParameters, body,
-          state.localConstants, defaults, closure.getClosureList(element));
+          state.localConstants, defaults,
+          _getDeclaredClosureVariables(element));
     }
   }
 
   ir.ConstructorDefinition makeConstructorDefinition(
       List<ConstantExpression> defaults, List<ir.Initializer> initializers) {
     FunctionElement element = state.currentElement;
     if (element.isExternal) {
       assert(invariant(element, _root == null,
           message: "Non-empty body for external constructor $element: $_root"));
       assert(invariant(element, state.localConstants.isEmpty,
           message: "Local constants for external constructor $element: "
                    "${state.localConstants}"));
       return new ir.ConstructorDefinition.abstract(
                 element, state.functionParameters, defaults);
     }
     ir.RunnableBody body = makeRunnableBody();
     return new ir.ConstructorDefinition(
         element, state.functionParameters, body, initializers,
         state.localConstants, defaults,
-        closure.getClosureList(element));
+        _getDeclaredClosureVariables(element));
   }
 
   /// Create a super invocation where the method name and the argument structure
   /// are defined by [selector] and the argument values are defined by
   /// [arguments].
   ir.Primitive buildSuperInvocation(Selector selector,
                                     List<ir.Primitive> arguments) {
     return _buildInvokeSuper(selector, arguments);
   }
 
@@ skipping 214 matching lines @@
   /// Creates a for loop in which the initializer, condition, body, update are
   /// created by [buildInitializer], [buildCondition], [buildBody] and
   /// [buildUpdate], respectively.
   ///
   /// The jump [target] is used to identify which `break` and `continue`
   /// statements that have this `for` statement as their target.
   ///
   /// The [closureScope] identifies variables that should be boxed in this loop.
   /// This includes variables declared inside the body of the loop as well as
   /// in the for-loop initializer.
+  ///
+  /// [loopVariables] is the list of variable declared in the for-loop

[sigurdm, 2015/01/14 12:02:48]

variable -> variables

[asgerf, 2015/01/14 12:08:21]

Thanks again.

+  /// initializer.
   void buildFor({SubbuildFunction buildInitializer,
                  SubbuildFunction buildCondition,
                  SubbuildFunction buildBody,
                  SubbuildFunction buildUpdate,
                  JumpTarget target,
-                 ClosureScope closureScope}) {
+                 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:
     //
     // [[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
     //     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.
 
-    // If the variables declared in the initializer must be boxed, we must
-    // create the box before entering the loop and renew the box at the end
-    // of the loop.
-    bool hasBoxedLoopVariables = closureScope != null &&
-                                 !closureScope.boxedLoopVariables.isEmpty;
-
-    // If a variable declared in the initializer must be boxed, we should
-    // create the box before initializing these variables.
-    // Otherwise, it is best to create the box inside the body so we don't have
-    // to create a box before the loop AND at the end of the loop.
-    if (hasBoxedLoopVariables) {
-      _buildClosureScopeSetup(closureScope);
-    }
+    _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();
 
-    // If we did not yet create a box for the boxed variables, we must create it
-    // here. This saves us from
-    if (!hasBoxedLoopVariables) {
-      bodyBuilder._buildClosureScopeSetup(closureScope);
-    }
+    bodyBuilder._enterForLoopBody(closureScope, loopVariables);
 
     buildBody(bodyBuilder);
     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;
-    if (hasBoxedLoopVariables) {
-      updateBuilder._migrateLoopVariables(closureScope);
-    }
+    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([]);
     ir.LetCont branch =
         new ir.LetCont(exitContinuation,
             new ir.LetCont(bodyContinuation,
                 new ir.Branch(new ir.IsTrue(condition),
                               bodyContinuation,
@@ skipping 105 matching lines @@
         new ir.InvokeMethod(iterator,
             new Selector.call("moveNext", null, 0),
             moveNextInvoked, emptyArguments)));
 
     JumpCollector breakCollector = new JumpCollector(target);
     JumpCollector continueCollector = new JumpCollector(target);
     state.breakCollectors.add(breakCollector);
     state.continueCollectors.add(continueCollector);
 
     IrBuilder bodyBuilder = condBuilder.makeDelimitedBuilder();
-    bodyBuilder._buildClosureScopeSetup(closureScope);
+    bodyBuilder._enterScope(closureScope);
     if (buildVariableDeclaration != null) {
       buildVariableDeclaration(bodyBuilder);
     }
 
     ir.Parameter currentValue = new ir.Parameter(null);
     ir.Continuation currentInvoked = new ir.Continuation([currentValue]);
     bodyBuilder.add(new ir.LetCont(currentInvoked,
         new ir.InvokeMethod(iterator, new Selector.getter("current", null),
             currentInvoked, emptyArguments)));
     if (Elements.isLocal(variableElement)) {
@@ skipping 84 matching lines @@
     // The condition and body are delimited.
     IrBuilder condBuilder = makeRecursiveBuilder();
     ir.Primitive condition = buildCondition(condBuilder);
 
     JumpCollector breakCollector = new JumpCollector(target);
     JumpCollector continueCollector = new JumpCollector(target);
     state.breakCollectors.add(breakCollector);
     state.continueCollectors.add(continueCollector);
 
     IrBuilder bodyBuilder = condBuilder.makeDelimitedBuilder();
-    bodyBuilder._buildClosureScopeSetup(closureScope);
+    bodyBuilder._enterScope(closureScope);
     buildBody(bodyBuilder);
     assert(state.breakCollectors.last == breakCollector);
     assert(state.continueCollectors.last == continueCollector);
     state.breakCollectors.removeLast();
     state.continueCollectors.removeLast();
 
     // Create body entry and loop exit continuations and a branch to them.
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     ir.Continuation exitContinuation = new ir.Continuation([]);
     ir.LetCont branch =
@@ skipping 230 matching lines @@
             new ir.LetCont(leftTrueContinuation,
                 new ir.LetCont(leftFalseContinuation,
                     new ir.Branch(new ir.IsTrue(leftValue),
                                   leftTrueContinuation,
                                   leftFalseContinuation)))));
     // There is always a join parameter for the result value, because it
     // is different on at least two paths.
     return joinContinuation.parameters.last;
   }
 
-  /// Creates an access to the receiver from the current (or enclosing) method.
-  ///
-  /// If inside a closure class, [buildThis] will redirect access through
-  /// closure fields in order to access the receiver from the enclosing method.
-  ir.Primitive buildThis() {
-    if (state.receiver != null) return state.receiver;
-    ir.Primitive thisPrim = new ir.This();
-    add(new ir.LetPrim(thisPrim));
-    return thisPrim;
-  }

[asgerf, 2015/01/14 08:55:57]

Moved to subclass because 'this' capture is JS-specific.

-
   /// Create a non-recursive join-point continuation.
   ///
   /// Given the environment length at the join point and a list of
   /// jumps that should reach the join point, create a join-point
   /// continuation.  The join-point continuation has a parameter for each
   /// variable that has different values reaching on different paths.
   ///
   /// The jumps are uninitialized [ir.InvokeContinuation] expressions.
   /// They are filled in with the target continuation and appropriate
   /// arguments.
@@ skipping 86 matching lines @@
     for (int i = 0; i < environment.length; ++i) {
       if (common[i] == null) {
         environment.index2value[i] = parameters[index++];
       }
     }
 
     return join;
   }
 }
 
+/// Shared state between DartIrBuilders within the same method.
+class DartIrBuilderSharedState {
+  /// Maps local variables to their corresponding [ClosureVariable] object.
+  final Map<Local, ir.ClosureVariable> local2closure =
+      <Local, ir.ClosureVariable>{};
+
+  /// Maps functions to the list of closure variables declared in that function.
+  final Map<ExecutableElement, List<ir.ClosureVariable>> function2closures =
+      <ExecutableElement, List<ir.ClosureVariable>>{};
+
+  final ClosureVariableInfo closureVariables;
+
+  /// Returns the closure variables declared in the given function.
+  List<ir.ClosureVariable> getClosureList(ExecutableElement element) {
+    return function2closures.putIfAbsent(element, () => <ir.ClosureVariable>[]);
+  }
+
+  /// Creates a closure variable for the given local.
+  void makeClosureVariable(Local local) {
+    ir.ClosureVariable variable =
+        new ir.ClosureVariable(local.executableContext, local);
+    local2closure[local] = variable;
+    getClosureList(local.executableContext).add(variable);
+  }
+
+  /// Closure variables that should temporarily be treated as registers.
+  final Set<Local> registerizedClosureVariables = new Set<Local>();
+
+  DartIrBuilderSharedState(this.closureVariables) {
+    closureVariables.capturedVariables.forEach(makeClosureVariable);
+  }
+}
+
 /// Dart-specific subclass of [IrBuilder].
 ///
 /// Inner functions are represented by a [FunctionDefinition] with the
 /// IR for the inner function nested inside.
 ///
 /// Captured variables are translated to ref cells (see [ClosureVariable])
 /// using [GetClosureVariable] and [SetClosureVariable].
 class DartIrBuilder extends IrBuilder {
-  ClosureVariableInfo closureVariables;
+  final DartIrBuilderSharedState dartState;
 
-  IrBuilder _makeInstance() => new DartIrBuilder._blank(closureVariables);
-  DartIrBuilder._blank(this.closureVariables);
+  IrBuilder _makeInstance() => new DartIrBuilder._blank(dartState);
+  DartIrBuilder._blank(this.dartState);
 
   DartIrBuilder(ConstantSystem constantSystem,
                 ExecutableElement currentElement,
-                this.closureVariables) {
+                ClosureVariableInfo  closureVariables)
+      : dartState = new DartIrBuilderSharedState(closureVariables) {
     _init(constantSystem, currentElement);
-    closureVariables.capturedVariables.forEach(closure.makeClosureVariable);
   }
 
-  /// True if [local] is stored in a [ClosureVariable].
+  /// True if [local] should currently be accessed from a [ClosureVariable].
   bool isInClosureVariable(Local local) {
-    return closure.local2closure.containsKey(local);
+    return dartState.local2closure.containsKey(local) &&
+           !dartState.registerizedClosureVariables.contains(local);
   }
 
   /// Gets the [ClosureVariable] containing the value of [local].
   ir.ClosureVariable getClosureVariable(Local local) {
-    return closure.local2closure[local];
+    return dartState.local2closure[local];
   }
 
-  void _buildClosureScopeSetup(ClosureScope scope) {
+  void _enterScope(ClosureScope scope) {
     assert(scope == null);
   }
 
-  void _buildClosureEnvironmentSetup(ClosureEnvironment env) {
+  void _enterClosureEnvironment(ClosureEnvironment env) {
     assert(env == null);
   }
 
-  void _migrateLoopVariables(ClosureScope scope) {
+  void _enterForLoopInitializer(ClosureScope scope,
+                                List<LocalElement> loopVariables) {
     assert(scope == null);
+    for (LocalElement loopVariable in loopVariables) {
+      if (dartState.local2closure.containsKey(loopVariable)) {
+        // Temporarily keep the loop variable in a primitive.
+        // The loop variable will be added to environment when
+        // [declareLocalVariable] is called.
+        dartState.registerizedClosureVariables.add(loopVariable);
+      }
+    }
+  }
+
+  void _enterForLoopBody(ClosureScope scope,
+                         List<LocalElement> loopVariables) {
+    assert(scope == null);
+    for (LocalElement loopVariable in loopVariables) {
+      if (dartState.local2closure.containsKey(loopVariable)) {
+        // Move from primitive into ClosureVariable.
+        dartState.registerizedClosureVariables.remove(loopVariable);
+        add(new ir.SetClosureVariable(getClosureVariable(loopVariable),
+                                      environment.lookup(loopVariable),
+                                      isDeclaration: true));
+      }
+    }
+  }
+
+  void _enterForLoopUpdate(ClosureScope scope,
+                           List<LocalElement> loopVariables) {
+    assert(scope == null);
+    // Move captured loop variables back into the local environment.
+    // The update expression will use the values we put in the environment,
+    // and then the environments for the initializer and update will be
+    // joined at the head of the body.
+    for (LocalElement loopVariable in loopVariables) {
+      if (isInClosureVariable(loopVariable)) {
+        ir.ClosureVariable closureVariable = getClosureVariable(loopVariable);
+        ir.Primitive get = new ir.GetClosureVariable(closureVariable);
+        add(new ir.LetPrim(get));
+        environment.update(loopVariable, get);
+        dartState.registerizedClosureVariables.add(loopVariable);
+      }
+    }
   }
 
   void _createFunctionParameter(ParameterElement parameterElement) {
     ir.Parameter parameter = new ir.Parameter(parameterElement);
     _parameters.add(parameter);
     if (isInClosureVariable(parameterElement)) {
       state.functionParameters.add(getClosureVariable(parameterElement));
     } else {
       state.functionParameters.add(parameter);
       environment.extend(parameterElement, parameter);
@@ skipping 56 matching lines @@
     assert(isOpen);
     if (isInClosureVariable(local)) {
       add(new ir.SetClosureVariable(getClosureVariable(local), value));
     } else {
       value.useElementAsHint(local);
       environment.update(local, value);
     }
     return value;
   }
 
+  List<ir.ClosureVariable> _getDeclaredClosureVariables(
+      ExecutableElement element) {
+    return dartState.getClosureList(element);
+  }
+
+  ir.Primitive buildThis() {
+    ir.Primitive thisPrim = new ir.This();
+    add(new ir.LetPrim(thisPrim));
+    return thisPrim;
+  }
 
 }
 
+/// State shared between JsIrBuilders within the same function.
+///
+/// Note that this is not shared between builders of nested functions.
+class JsIrBuilderSharedState {
+  /// Maps boxed locals to their location. These locals are not part of
+  /// the environment.
+  final Map<Local, ClosureLocation> boxedVariables = {};
+
+  /// If non-null, this refers to the receiver (`this`) in the enclosing method.
+  ir.Primitive receiver;
+}
+
 /// JS-specific subclass of [IrBuilder].
 ///
 /// Inner functions are represented by a [ClosureClassElement], and captured
 /// variables are boxed as necessary using [CreateBox], [GetField], [SetField].
 class JsIrBuilder extends IrBuilder {
-  IrBuilder _makeInstance() => new JsIrBuilder._blank();
-  JsIrBuilder._blank();
+  final JsIrBuilderSharedState jsState;
 
-  JsIrBuilder(ConstantSystem constantSystem, ExecutableElement currentElement) {
+  IrBuilder _makeInstance() => new JsIrBuilder._blank(jsState);
+  JsIrBuilder._blank(this.jsState);
+
+  JsIrBuilder(ConstantSystem constantSystem, ExecutableElement currentElement)
+      : jsState = new JsIrBuilderSharedState() {
     _init(constantSystem, currentElement);
   }
 
-  void _buildClosureEnvironmentSetup(ClosureEnvironment env) {
+  void _enterClosureEnvironment(ClosureEnvironment env) {
     if (env == null) return;
 
     // Obtain a reference to the function object (this).
     ir.Primitive thisPrim = new ir.This();
     add(new ir.LetPrim(thisPrim));
 
     // Obtain access to the free variables.
     env.freeVariables.forEach((Local local, ClosureLocation location) {
       if (location.isBox) {
         // Boxed variables are loaded from their box on-demand.
-        state.boxedVariables[local] = location;
+        jsState.boxedVariables[local] = location;
       } else {
         // Unboxed variables are loaded from the function object immediately.
         // This includes BoxLocals which are themselves unboxed variables.
         ir.Primitive load = new ir.GetField(thisPrim, location.field);
         add(new ir.LetPrim(load));
         environment.extend(local, load);
       }
     });
 
     // If the function captures a reference to the receiver from the
     // enclosing method, remember which primitive refers to the receiver object.
     if (env.thisLocal != null && env.freeVariables.containsKey(env.thisLocal)) {
-      state.receiver = environment.lookup(env.thisLocal);
+      jsState.receiver = environment.lookup(env.thisLocal);
     }
 
     // If the function has a self-reference, use the value of `this`.
     if (env.selfReference != null) {
       environment.extend(env.selfReference, thisPrim);
     }
   }
 
-  void _buildClosureScopeSetup(ClosureScope scope) {
+  void _enterScope(ClosureScope scope) {
     if (scope == null) return;
     ir.CreateBox boxPrim = new ir.CreateBox();
     add(new ir.LetPrim(boxPrim));
     environment.extend(scope.box, boxPrim);
     boxPrim.useElementAsHint(scope.box);
     scope.capturedVariables.forEach((Local local, ClosureLocation location) {
-      assert(!state.boxedVariables.containsKey(local));
+      assert(!jsState.boxedVariables.containsKey(local));
       if (location.isBox) {
-        state.boxedVariables[local] = location;
+        jsState.boxedVariables[local] = location;
       }
     });
   }
 
   void _createFunctionParameter(ParameterElement parameterElement) {
     ir.Parameter parameter = new ir.Parameter(parameterElement);
     _parameters.add(parameter);
     state.functionParameters.add(parameter);
-    ClosureLocation location = state.boxedVariables[parameterElement];
+    ClosureLocation location = jsState.boxedVariables[parameterElement];
     if (location != null) {
       add(new ir.SetField(environment.lookup(location.box),
                           location.field,
                           parameter));
     } else {
       environment.extend(parameterElement, parameter);
     }
   }
 
   void declareLocalVariable(LocalElement variableElement,
                             {ir.Primitive initialValue}) {
     assert(isOpen);
     if (initialValue == null) {
       initialValue = buildNullLiteral();
     }
-    ClosureLocation location = state.boxedVariables[variableElement];
+    ClosureLocation location = jsState.boxedVariables[variableElement];
     if (location != null) {
       add(new ir.SetField(environment.lookup(location.box),
                           location.field,
                           initialValue));
     } else {
       initialValue.useElementAsHint(variableElement);
       environment.extend(variableElement, initialValue);
     }
   }
 
@@ skipping 10 matching lines @@
       arguments.add(environment.lookup(field.local));
     }
     ir.Primitive closure = new ir.CreateClosureClass(classElement, arguments);
     add(new ir.LetPrim(closure));
     return closure;
   }
 
   /// Create a read access of [local].
   ir.Primitive buildLocalGet(LocalElement local) {
     assert(isOpen);
-    ClosureLocation location = state.boxedVariables[local];
+    ClosureLocation location = jsState.boxedVariables[local];
     if (location != null) {
       ir.Primitive result = new ir.GetField(environment.lookup(location.box),
                                             location.field);
       result.useElementAsHint(local);
       add(new ir.LetPrim(result));
       return result;
     } else {
       return environment.lookup(local);
     }
   }
 
   /// Create a write access to [local] with the provided [value].
   ir.Primitive buildLocalSet(LocalElement local, ir.Primitive value) {
     assert(isOpen);
-    ClosureLocation location = state.boxedVariables[local];
+    ClosureLocation location = jsState.boxedVariables[local];
     if (location != null) {
       add(new ir.SetField(environment.lookup(location.box),
                           location.field,
                           value));
     } else {
       value.useElementAsHint(local);
       environment.update(local, value);
     }
     return value;
   }
 
-  void _migrateLoopVariables(ClosureScope scope) {
+  void _enterForLoopInitializer(ClosureScope scope,
+                                List<LocalElement> loopVariables) {
     if (scope == null) return;
+    // If there are no boxed loop variables, don't create the box here, let
+    // it be created inside the body instead.
+    if (scope.boxedLoopVariables.isEmpty) return;
+    _enterScope(scope);
+  }
+
+  void _enterForLoopBody(ClosureScope scope,
+                         List<LocalElement> loopVariables) {
+    if (scope == null) return;
+    // If there are boxed loop variables, the box has already been created
+    // at the initializer.
+    if (!scope.boxedLoopVariables.isEmpty) return;
+    _enterScope(scope);
+  }
+
+  void _enterForLoopUpdate(ClosureScope scope,
+                           List<LocalElement> loopVariables) {
+    if (scope == null) return;
+    // If there are no boxed loop variables, then the box is created inside the
+    // body, so there is no need to explicitly renew it.
+    if (scope.boxedLoopVariables.isEmpty) return;
     ir.Primitive box = environment.lookup(scope.box);
     ir.Primitive newBox = new ir.CreateBox();
     newBox.useElementAsHint(scope.box);
     add(new ir.LetPrim(newBox));
     for (VariableElement loopVar in scope.boxedLoopVariables) {
       ClosureLocation location = scope.capturedVariables[loopVar];
       ir.Primitive get = new ir.GetField(box, location.field);
       add(new ir.LetPrim(get));
       add(new ir.SetField(newBox, location.field, get));
     }
     environment.update(scope.box, newBox);
   }
 
+  List<ir.ClosureVariable> _getDeclaredClosureVariables(
+      ExecutableElement element) {
+    return <ir.ClosureVariable>[];
+  }
+
+  ir.Primitive buildThis() {
+    if (jsState.receiver != null) return jsState.receiver;
+    ir.Primitive thisPrim = new ir.This();
+    add(new ir.LetPrim(thisPrim));
+    return thisPrim;
+  }
 }
 
 
 /// Location of a variable relative to a given closure.
 class ClosureLocation {
   /// If not `null`, this location is [box].[field].
   /// The location of [box] can be obtained separately from an
   /// enclosing [ClosureEnvironment] or [ClosureScope].
   /// If `null`, then the location is [field] on the enclosing function object.
   final BoxLocal box;
@@ skipping 36 matching lines @@
   /// to find the captured value of `this`.
   final ThisLocal thisLocal;
 
   /// Maps [LocalElement]s, [BoxLocal]s and [ThisLocal] to their location.
   final Map<Local, ClosureLocation> freeVariables;
 
   ClosureEnvironment(this.selfReference, this.thisLocal, this.freeVariables);
 }
 
 /// Information about which variables are captured in a closure.
+///
 /// This is used by the [DartIrBuilder] instead of [ClosureScope] and
 /// [ClosureEnvironment].
 abstract class ClosureVariableInfo {
   Iterable<Local> get capturedVariables;
 }