Support local functions in analyzer2dart.

pkg/analyzer2dart/lib/src/cps_generator.dart

 // Copyright (c) 2014, 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 analyzer2dart.cps_generator;
 
 import 'package:analyzer/analyzer.dart';
 
 import 'package:compiler/src/dart_types.dart' as dart2js;
 import 'package:compiler/src/elements/elements.dart' as dart2js;
@@ skipping 18 matching lines @@
 
   CpsGeneratingVisitor(this.converter, this.element);
 
   Source get currentSource => element.source;
 
   analyzer.LibraryElement get currentLibrary => element.library;
 
   ir.Node visit(AstNode node) => node.accept(this);
 
   @override
-  ir.FunctionDefinition visitFunctionDeclaration(FunctionDeclaration node) {
-    analyzer.FunctionElement function = node.element;
+  ir.Primitive visitFunctionExpression(FunctionExpression node) {
+    return irBuilder.buildFunctionExpression(
+        handleFunctionDeclaration(node.element, node));
+  }
+
+  ir.FunctionDefinition handleFunctionDeclaration(
+      analyzer.FunctionElement function, FunctionExpression node) {
     dart2js.FunctionElement element = converter.convertElement(function);
     return withBuilder(
         new IrBuilder(DART_CONSTANT_SYSTEM,
                       element,
                       // TODO(johnniwinther): Supported closure variables.
                       const <dart2js.Local>[]),
         () {
       function.parameters.forEach((analyzer.ParameterElement parameter) {
         // TODO(johnniwinther): Support "closure variables", that is variables
         // accessed from an inner function.
         irBuilder.createParameter(converter.convertElement(parameter));
       });
       // Visit the body directly to avoid processing the signature as
       // expressions.
-      visit(node.functionExpression.body);
+      visit(node.body);
       return irBuilder.buildFunctionDefinition(element, const []);
     });
   }
 
+  @override
+  ir.FunctionDefinition visitFunctionDeclaration(FunctionDeclaration node) {
+    return handleFunctionDeclaration(node.element, node.functionExpression);
+  }
+
+  @override
+  visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
+    FunctionDeclaration functionDeclaration = node.functionDeclaration;
+    analyzer.FunctionElement function = functionDeclaration.element;
+    dart2js.FunctionElement element = converter.convertElement(function);
+    ir.FunctionDefinition definition = handleFunctionDeclaration(
+        function, functionDeclaration.functionExpression);
+    irBuilder.declareLocalFunction(element, definition);
+  }
+
   List<ir.Definition> visitArguments(ArgumentList argumentList) {
     List<ir.Definition> arguments = <ir.Definition>[];
     for (Expression argument in argumentList.arguments) {
       ir.Definition value = build(argument);
       if (value == null) {
         giveUp(argument,
             'Unsupported argument: $argument (${argument.runtimeType}).');
       }
       arguments.add(value);
     }
@@ skipping 26 matching lines @@
     dart2js.Element element = converter.convertElement(staticElement);
     List<ir.Definition> arguments = visitArguments(node.argumentList);
     return irBuilder.buildStaticInvocation(
         element,
         createSelectorFromMethodInvocation(
             node.argumentList, node.methodName.name),
         arguments);
   }
 
   @override
+  ir.Node visitLocalFunctionAccess(AstNode node, AccessSemantics semantics) {
+    return handleLocalAccess(node, semantics);
+  }
+
+  ir.Primitive handleLocalInvocation(MethodInvocation node,
+                                     AccessSemantics semantics) {
+    analyzer.Element staticElement = semantics.element;
+    dart2js.Element element = converter.convertElement(staticElement);
+    List<ir.Definition> arguments = visitArguments(node.argumentList);
+    return irBuilder.buildLocalInvocation(
+      element,
+      createSelectorFromMethodInvocation(
+          node.argumentList, node.methodName.name),
+      arguments);
+  }
+
+  @override
+  ir.Node visitLocalVariableInvocation(MethodInvocation node,
+                                       AccessSemantics semantics) {
+    return handleLocalInvocation(node, semantics);
+  }
+
+  @override
+  ir.Primitive visitLocalFunctionInvocation(MethodInvocation node,
+                                            AccessSemantics semantics) {
+    return handleLocalInvocation(node, semantics);
+  }
+
+  @override
+  ir.Primitive visitFunctionExpressionInvocation(
+      FunctionExpressionInvocation node) {
+    ir.Primitive target = build(node.function);
+    List<ir.Definition> arguments = visitArguments(node.argumentList);
+    return irBuilder.buildFunctionExpressionInvocation(
+        target,
+        createSelectorFromMethodInvocation(node.argumentList, 'call'),
+        arguments);
+  }
+
+  @override
   ir.Primitive visitInstanceCreationExpression(
       InstanceCreationExpression node) {
     analyzer.Element staticElement = node.staticElement;
     if (staticElement != null) {
       dart2js.Element element = converter.convertElement(staticElement);
       dart2js.DartType type = converter.convertType(node.staticType);
       List<ir.Definition> arguments = visitArguments(node.argumentList);
       String name = '';
       if (node.constructorName.name != null) {
         name = node.constructorName.name.name;
@@ skipping 280 matching lines @@
   }
 
   @override
   ir.Primitive visitAsExpression(AsExpression node) {
     return irBuilder.buildTypeOperator(
         visit(node.expression),
         converter.convertType(node.type.type),
         isTypeTest: false);
   }
 }