Fix an assertion failure in dart2js.

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 '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 180 matching lines @@
   @override
   SemanticSendVisitor get sendVisitor => this;
 
   /**
    * Builds the [ir.RootNode] for an executable element. In case the
    * function uses features that cannot be expressed in the IR, this element
    * returns `null`.
    */
   ir.RootNode buildExecutable(ExecutableElement element);
 
+  ClosureClassMap get closureClassMap;
   ClosureScope getClosureScopeForNode(ast.Node node);
   ClosureEnvironment getClosureEnvironment();
 
   /// Normalizes the argument list to a static invocation (i.e. where the target
   /// element is known).
   ///
   /// For the JS backend, inserts default arguments and normalizes order of
   /// named arguments.
   ///
   /// For the Dart backend, returns [arguments].
@@ skipping 316 matching lines @@
       }
       catchClauseInfos.add(new CatchClauseInfo(
           exceptionVariable: exceptionVariable,
           stackTraceVariable: stackTraceVariable,
           buildCatchBlock: subbuild(catchClause.block)));
     }
 
     irBuilder.buildTry(
         tryStatementInfo: tryStatements[node],
         buildTryBlock: subbuild(node.tryBlock),
-        catchClauseInfos: catchClauseInfos);
+        catchClauseInfos: catchClauseInfos,
+        closureClassMap: closureClassMap);
   }
 
   // ## Expressions ##
   ir.Primitive visitConditional(ast.Conditional node) {
     return irBuilder.buildConditional(
         build(node.condition),
         subbuild(node.thenExpression),
         subbuild(node.elseExpression));
   }
 
@@ skipping 1466 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);
   }
 
+  ClosureClassMap get closureClassMap => null;
   ClosureScope getClosureScopeForNode(ast.Node node) => null;
   ClosureEnvironment getClosureEnvironment() => null;
 
   ir.RootNode buildExecutable(ExecutableElement element) {
     return nullIfGiveup(() {
       ir.RootNode root;
       if (element is FieldElement) {
         root = buildField(element);
       } else if (element is FunctionElement || element is ConstructorElement) {
         root = buildFunction(element);
@@ skipping 114 matching lines @@
 
 /// IR builder specific to the JavaScript backend, coupled to the [JsIrBuilder].
 class JsIrBuilderVisitor extends IrBuilderVisitor {
   /// Promote the type of [irBuilder] to [JsIrBuilder].
   JsIrBuilder get irBuilder => super.irBuilder;
 
   /// Result of closure conversion for the current body of code.
   ///
   /// Will be initialized upon entering the body of a function.
   /// It is computed by the [ClosureTranslator].
-  ClosureClassMap closureMap;
+  ClosureClassMap closureClassMap;
 
   /// During construction of a constructor factory, [fieldValues] maps fields
   /// to the primitive containing their initial value.
   Map<FieldElement, ir.Primitive> fieldValues = <FieldElement, ir.Primitive>{};
 
   JsIrBuilderVisitor(TreeElements elements,
                      Compiler compiler,
                      SourceInformationBuilder sourceInformationBuilder)
       : super(elements, compiler, sourceInformationBuilder);
 
@@ skipping 33 matching lines @@
     } else {
       ClosureFieldElement field = v;
       return new ClosureLocation(null, field);
     }
   }
 
   /// If the current function is a nested function with free variables (or a
   /// captured reference to `this`), returns a [ClosureEnvironment]
   /// indicating how to access these.
   ClosureEnvironment getClosureEnvironment() {
-    if (closureMap.closureElement == null) return null;
+    if (closureClassMap.closureElement == null) return null;
     return new ClosureEnvironment(
-        closureMap.closureElement,
-        closureMap.thisLocal,
-        mapValues(closureMap.freeVariableMap, getLocation));
+        closureClassMap.closureElement,
+        closureClassMap.thisLocal,
+        mapValues(closureClassMap.freeVariableMap, getLocation));
   }
 
   /// If [node] has declarations for variables that should be boxed,
   /// returns a [ClosureScope] naming a box to create, and enumerating the
   /// variables that should be stored in the box.
   ///
   /// Also see [ClosureScope].
   ClosureScope getClosureScopeForNode(ast.Node node) {
-    closurelib.ClosureScope scope = closureMap.capturingScopes[node];
+    closurelib.ClosureScope scope = closureClassMap.capturingScopes[node];
     if (scope == null) return null;
     // We translate a ClosureScope from closure.dart into IR builder's variant
     // because the IR builder should not depend on the synthetic elements
     // created in closure.dart.
     return new ClosureScope(scope.boxElement,
                             mapValues(scope.capturedVariables, getLocation),
                             scope.boxedLoopVariables);
   }
 
   /// Returns the [ClosureScope] for any function, possibly different from the
@@ skipping 372 matching lines @@
     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;
-    closureMap = compiler.closureToClassMapper.computeClosureToClassMapping(
-        constructor,
-        node,
-        elements);
+    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.
     DartCapturedVariables variables = _analyzeCapturedVariables(node);
     tryStatements = variables.tryStatements;
     JsIrBuilder 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);
 
-    closureMap = compiler.closureToClassMapper.computeClosureToClassMapping(
-        element,
-        node,
-        elements);
+    closureClassMap =
+        compiler.closureToClassMapper.computeClosureToClassMapping(
+            element,
+            node,
+            elements);
     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();
@@ skipping 158 matching lines @@
     node.body = replacementFor(node.body);
   }
 }
 
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends ir.RecursiveVisitor {
   processReference(ir.Reference reference) {
     reference.unlink();
   }
 }