Support local functions in analyzer2dart.

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 413 matching lines @@
   ir.Primitive visitAssert(ast.Send node) {
     assert(irBuilder.isOpen);
     return giveup(node, 'Assert');
   }
 
   ir.Primitive visitNamedArgument(ast.NamedArgument node) {
     assert(irBuilder.isOpen);
     return visit(node.expression);
   }
 
-  ir.Primitive translateClosureCall(ir.Primitive receiver,
-                                    Selector closureSelector,
-                                    ast.NodeList arguments) {
-    Selector namedCallSelector = new Selector(closureSelector.kind,
-                     "call",
-                     closureSelector.library,
-                     closureSelector.argumentCount,
-                     closureSelector.namedArguments);
-    List<ir.Primitive> args = arguments.nodes.mapToList(visit, growable:false);
-    return irBuilder.buildDynamicInvocation(receiver, namedCallSelector, args);
-  }
-
   ir.Primitive visitClosureSend(ast.Send node) {
     assert(irBuilder.isOpen);
     Element element = elements[node];
-    ir.Primitive closureTarget;
+    Selector closureSelector = elements.getSelector(node);
     if (element == null) {
-      closureTarget = visit(node.selector);
-    } else if (irBuilder.isClosureVariable(element)) {
-      LocalElement local = element;
-      closureTarget = new ir.GetClosureVariable(local);
-      irBuilder.add(new ir.LetPrim(closureTarget));
+      ir.Primitive closureTarget = visit(node.selector);
+      List<ir.Primitive> args =
+          node.arguments.mapToList(visit, growable:false);
+      return irBuilder.buildFunctionExpressionInvocation(
+          closureTarget, elements.getSelector(node), args);
     } else {
-      assert(Elements.isLocal(element));
-      closureTarget = irBuilder.environment.lookup(element);
+      List<ir.Primitive> args =
+          node.arguments.mapToList(visit, growable:false);
+      return irBuilder.buildLocalInvocation(
+          element, elements.getSelector(node), args);
     }
-    Selector closureSelector = elements.getSelector(node);
-    return translateClosureCall(closureTarget, closureSelector,
-        node.argumentsNode);
   }
 
   /// If [node] is null, returns this.
   /// If [node] is super, returns null (for special handling)
   /// Otherwise visits [node] and returns the result.
   ir.Primitive visitReceiver(ast.Expression node) {
     if (node == null) return irBuilder.buildThis();
     if (node.isSuper()) return null;
     return visit(node);
   }
@@ skipping 313 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) {
-    // TODO(johnniwinther): Share the visitor.
-    return new IrBuilderVisitor(elements, compiler, sourceFile)
-           .buildFunctionInternal(elements[node]);
+    return buildFunctionInternal(elements[node]);
   }
 
   ir.Primitive visitFunctionExpression(ast.FunctionExpression node) {
-    FunctionElement element = elements[node];
-    ir.FunctionDefinition inner = makeSubFunction(node);
-    ir.CreateFunction prim = new ir.CreateFunction(inner);
-    irBuilder.add(new ir.LetPrim(prim));
-    return prim;
+    return irBuilder.buildFunctionExpression(makeSubFunction(node));
   }
 
-  ir.Primitive visitFunctionDeclaration(ast.FunctionDeclaration node) {
+  visitFunctionDeclaration(ast.FunctionDeclaration node) {
     LocalFunctionElement element = elements[node.function];
     ir.FunctionDefinition inner = makeSubFunction(node.function);
-    if (irBuilder.isClosureVariable(element)) {
-      irBuilder.add(new ir.DeclareFunction(element, inner));
-    } else {
-      ir.CreateFunction prim = new ir.CreateFunction(inner);
-      irBuilder.add(new ir.LetPrim(prim));
-      irBuilder.environment.extend(element, prim);
-      prim.useElementAsHint(element);
-    }
-    return null;
+    irBuilder.declareLocalFunction(element, inner);
   }
 
   static final String ABORT_IRNODE_BUILDER = "IrNode builder aborted";
 
   dynamic giveup(ast.Node node, [String reason]) {
     throw ABORT_IRNODE_BUILDER;
   }
 
   ir.FunctionDefinition nullIfGiveup(ir.FunctionDefinition action()) {
     try {
@@ skipping 45 matching lines @@
     node.visitChildren(this);
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     FunctionElement oldFunction = currentFunction;
     currentFunction = elements[node];
     visit(node.body);
     currentFunction = oldFunction;
   }
 }