Support parameter access 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/implementation/elements/elements.dart' as dart2js;
 import 'package:analyzer/src/generated/element.dart' as analyzer;
@@ skipping 17 matching lines @@
 
   @override
   ir.FunctionDefinition visitFunctionDeclaration(FunctionDeclaration node) {
     analyzer.FunctionElement function = node.element;
     function.parameters.forEach((analyzer.ParameterElement parameter) {
       // TODO(johnniwinther): Support "closure variables", that is variables
       // accessed from an inner function.
       irBuilder.createParameter(converter.convertElement(parameter),
                                 isClosureVariable: false);
     });
-    super.visitFunctionDeclaration(node);
+    // Visit the body directly to avoid processing the signature as expressions.
+    node.functionExpression.body.accept(this);
     return irBuilder.buildFunctionDefinition(
         converter.convertElement(function), const [], const []);
   }
-
+/*

[sigurdm, 2014/09/11 11:13:13]

Why is this commented out?

[Johnni Winther, 2014/09/11 11:31:40]

I thought I needed to process the function expression but had to skip it
instead. Removed.

+  @override
+  visitFunctionExpression(FunctionExpression node) {
+    node.body
+  }
+*/
   @override
   visitMethodInvocation(MethodInvocation node) {
     analyzer.Element staticElement = node.methodName.staticElement;
     if (staticElement != null) {
       dart2js.Element element = converter.convertElement(staticElement);
       List<ir.Definition> arguments = <ir.Definition>[];
       for (Expression argument in node.argumentList.arguments) {
-        arguments.add(argument.accept(this));
+        ir.Definition value = argument.accept(this);
+        if (value == null) {
+          giveUp('Unsupported argument: $argument (${argument.runtimeType}).');
+        }
+        arguments.add(value);
       }
       return irBuilder.buildStaticInvocation(
           element, createSelectorFromMethodInvocation(node), arguments);
     }
   }
 
   @override
   ir.Constant visitNullLiteral(NullLiteral node) {
     return irBuilder.buildNullLiteral();
   }
@@ skipping 33 matching lines @@
   }
 
   @override
   visitReturnStatement(ReturnStatement node) {
     if (node.expression != null) {
       irBuilder.buildReturn(node.expression.accept(this));
     } else {
       irBuilder.buildReturn();
     }
   }
+
+  @override
+  visitSimpleIdentifier(SimpleIdentifier node) {
+    analyzer.Element element = node.staticElement;
+    if (element != null) {
+      dart2js.Element target = converter.convertElement(element);
+      if (dart2js.Elements.isLocal(target)) {
+        return irBuilder.buildGetLocal(target);
+      }
+      giveUp('Unhandled static reference: '
+             '$node -> $target (${target.runtimeType})');
+    }
+    giveUp('Unresolved identifier: $node.');
+  }
 }