Refactored treatment of closure variables in dart2js CPS.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_visitor.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.
 
 part of dart2js.ir_builder;
 
 /**
  * This task iterates through all resolved elements and builds [ir.Node]s. The
  * nodes are stored in the [nodes] map and accessible through [hasIr] and
  * [getIr].
@@ skipping 157 matching lines @@
     return withBuilder(builder, () {
       ir.Primitive initializer;
       if (fieldDefinition is ast.SendSet) {
         ast.SendSet sendSet = fieldDefinition;
         initializer = visit(sendSet.arguments.first);
       }
       return builder.makeFieldDefinition(initializer);
     });
   }
 
+  ir.FunctionDefinition _makeFunctionBody(FunctionElement element,
+                                          ast.FunctionExpression node) {
+    FunctionSignature signature = element.functionSignature;
+    signature.orderedForEachParameter((ParameterElement parameterElement) {
+      irBuilder.createFunctionParameter(parameterElement);
+    });
+
+    List<ConstantExpression> defaults = new List<ConstantExpression>();
+    signature.orderedOptionalParameters.forEach((ParameterElement element) {
+      defaults.add(getConstantForVariable(element));
+    });
+
+    visit(node.body);
+
+    return irBuilder.makeFunctionDefinition(defaults);
+  }
+
   ir.FunctionDefinition buildFunction(FunctionElement element) {
     assert(invariant(element, element.isImplementation));
-    ast.FunctionExpression function = element.node;
-    assert(function != null);
-    assert(elements[function] != null);
+    ast.FunctionExpression node = element.node;
+    assert(node != null);
+    assert(elements[node] != null);
 
     DetectClosureVariables closureLocals = new DetectClosureVariables(elements);
-    closureLocals.visit(function);
+    closureLocals.visit(node);
 
-    return withBuilder(
-        new IrBuilder(compiler.backend.constantSystem,
-                      element, closureLocals.usedFromClosure),
-        () {
-      FunctionSignature signature = element.functionSignature;
-      signature.orderedForEachParameter((ParameterElement parameterElement) {
-        irBuilder.createParameter(parameterElement);
-      });
+    IrBuilder builder = new IrBuilder(compiler.backend.constantSystem,
+                                      element,
+                                      closureLocals.usedFromClosure);
 
-      List<ConstantExpression> defaults = new List<ConstantExpression>();
-      signature.orderedOptionalParameters.forEach((ParameterElement element) {
-        defaults.add(getConstantForVariable(element));
-      });
-
-      visit(function.body);
-      return irBuilder.makeFunctionDefinition(defaults);
-    });
+    return withBuilder(builder, () => _makeFunctionBody(element, node));
   }
 
   ir.Primitive visit(ast.Node node) => node.accept(this);
 
   // ==== Statements ====
   visitBlock(ast.Block node) {
     irBuilder.buildBlock(node.statements.nodes, build);
   }
 
   ir.Primitive visitBreakStatement(ast.BreakStatement node) {
@@ skipping 623 matching lines @@
 
   ir.Primitive translateConstant(ast.Node node, [ConstantExpression constant]) {
     assert(irBuilder.isOpen);
     if (constant == null) {
       constant = getConstantForNode(node);
     }
     return irBuilder.buildConstantLiteral(constant);
   }
 
   ir.FunctionDefinition makeSubFunction(ast.FunctionExpression node) {
-    return buildFunction(elements[node]);
+    FunctionElement element = elements[node];
+    assert(invariant(element, element.isImplementation));
+
+    IrBuilder builder = new IrBuilder.innerFunction(irBuilder, element);
+
+    return withBuilder(builder, () => _makeFunctionBody(element, node));
   }
 
   ir.Primitive visitFunctionExpression(ast.FunctionExpression node) {
     return irBuilder.buildFunctionExpression(makeSubFunction(node));
   }
 
   visitFunctionDeclaration(ast.FunctionDeclaration node) {
     LocalFunctionElement element = elements[node.function];
     ir.FunctionDefinition inner = makeSubFunction(node.function);
     irBuilder.declareLocalFunction(element, inner);
@@ skipping 55 matching lines @@
     node.visitChildren(this);
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     FunctionElement oldFunction = currentFunction;
     currentFunction = elements[node];
     visit(node.body);
     currentFunction = oldFunction;
   }
 }