Fix an assertion failure in dart2js.

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/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
@@ skipping 470 matching lines @@
   /// Mutable variables are treated as boxed.  Writes to them are observable
   /// side effects.
   Map<Local, ir.MutableVariable> mutableVariables;
 
   /// True if [local] should currently be accessed from a [ir.MutableVariable].
   bool isInMutableVariable(Local local) {
     return mutableVariables.containsKey(local);
   }
 
   /// Creates a [ir.MutableVariable] for the given local.
-  void makeMutableVariable(Local local) {
-    mutableVariables[local] =
-        new ir.MutableVariable(local.executableContext, local);
+  void makeMutableVariable(Local local, [ClosureClassMap closureMap]) {
+    ExecutableElement owner;
+    if (closureMap == null || closureMap.closureClassElement == null) {
+      owner = local.executableContext;
+    } else {
+      assert(local.executableContext == closureMap.closureElement);
+      owner = closureMap.callElement;
+    }
+    mutableVariables[local] = new ir.MutableVariable(owner, local);
   }
 
   /// Remove an [ir.MutableVariable] for a local.
   ///
   /// Subsequent access to the local will be direct rather than through the
   /// mutable variable.
   void removeMutableVariable(Local local) {
     mutableVariables.remove(local);
   }
 
@@ skipping 1195 matching lines @@
   /// Creates a try-statement.
   ///
   /// [tryInfo] provides information on local variables declared and boxed
   /// within this try statement.
   /// [buildTryBlock] builds the try block.
   /// [catchClauseInfos] provides access to the catch type, exception variable,
   /// and stack trace variable, and a function for building the catch block.
   void buildTry(
       {TryStatementInfo tryStatementInfo,
        SubbuildFunction buildTryBlock,
-       List<CatchClauseInfo> catchClauseInfos: const <CatchClauseInfo>[]}) {
+       List<CatchClauseInfo> catchClauseInfos: const <CatchClauseInfo>[],
+       ClosureClassMap closureClassMap}) {
     assert(isOpen);
 
     // Catch handlers are in scope for their body.  The CPS translation of
     // [[try tryBlock catch (e) catchBlock; successor]] is:
     //
     // let cont join(v0, v1, ...) = [[successor]] in
     //   let mutable m0 = x0 in
     //     let mutable m1 = x1 in
     //       ...
     //       let handler catch_(e) =
@@ skipping 21 matching lines @@
     JumpCollector join = new ForwardJumpCollector(environment);
     IrBuilder tryCatchBuilder = makeDelimitedBuilder();
 
     // Variables treated as mutable in a try are not mutable outside of it.
     // Work with a copy of the outer builder's mutable variables.
     tryCatchBuilder.mutableVariables =
         new Map<Local, ir.MutableVariable>.from(mutableVariables);
     for (LocalVariableElement variable in tryStatementInfo.boxedOnEntry) {
       assert(!tryCatchBuilder.isInMutableVariable(variable));
       ir.Primitive value = tryCatchBuilder.buildLocalVariableGet(variable);
-      tryCatchBuilder.makeMutableVariable(variable);
+      tryCatchBuilder.makeMutableVariable(variable, closureClassMap);
       tryCatchBuilder.declareLocalVariable(variable, initialValue: value);
     }
 
     IrBuilder tryBuilder = tryCatchBuilder.makeDelimitedBuilder();
 
     void interceptJumps(JumpCollector collector) {
       collector.enterTry(tryStatementInfo.boxedOnEntry);
     }
     void restoreJumps(JumpCollector collector) {
       collector.leaveTry();
@@ skipping 893 matching lines @@
 }
 
 /// Synthetic parameter to a JavaScript factory method that takes the type
 /// argument given for the type variable [variable].
 class TypeInformationParameter implements Local {
   final TypeVariableElement variable;
   final ExecutableElement executableContext;
   TypeInformationParameter(this.variable, this.executableContext);
   String get name => variable.name;
 }