Compute function types together with the parameters.

lib/compiler/implementation/resolver.dart

Index: lib/compiler/implementation/resolver.dart
diff --git a/lib/compiler/implementation/resolver.dart b/lib/compiler/implementation/resolver.dart
index 67f338b387a5da84c0cb49992898cd2c3f47e8eb..7b4da12ae2c813f87921dd4db6f9771e544374c8 100644
--- a/lib/compiler/implementation/resolver.dart
+++ b/lib/compiler/implementation/resolver.dart
@@ -233,7 +233,7 @@ class ResolverTask extends CompilerTask {
     });
   }
 
-  FunctionParameters resolveSignature(FunctionElement element) {
+  FunctionSignature resolveSignature(FunctionElement element) {
     return measure(() => SignatureResolver.analyze(compiler, element));
   }
 
@@ -677,8 +677,8 @@ class ResolverVisitor extends CommonResolverVisitor<Element> {
   void setupFunction(FunctionExpression node, FunctionElement function) {
     context = new MethodScope(context, function);
     // Put the parameters in scope.
-    FunctionParameters functionParameters =
-        function.computeParameters(compiler);
+    FunctionSignature functionParameters =
+        function.computeSignature(compiler);
     Link<Node> parameterNodes = node.parameters.nodes;
     functionParameters.forEachParameter((Element element) {
       if (element == functionParameters.optionalParameters.head) {
@@ -1639,8 +1639,6 @@ class SignatureResolver extends CommonResolverVisitor<Element> {
   }
 
   Element visitVariableDefinitions(VariableDefinitions node) {
-    resolveType(node.type);
-
     Link<Node> definitions = node.definitions.nodes;
     if (definitions.isEmpty()) {
       cancel(node, 'internal error: no parameter definition');
@@ -1740,16 +1738,29 @@ class SignatureResolver extends CommonResolverVisitor<Element> {
     return elements;
   }
 
-  static FunctionParameters analyze(Compiler compiler,
-                                    FunctionElement element) {
-    FunctionExpression node = element.parseNode(compiler);
+  static FunctionSignature analyze(Compiler compiler,
+                                   FunctionElement element) {
+    FunctionExpression node =
+          compiler.parser.measure(() => element.parseNode(compiler));
     SignatureResolver visitor = new SignatureResolver(compiler, element);
     Link<Node> nodes = node.parameters.nodes;
-    LinkBuilder<Element> parameters = visitor.analyzeNodes(nodes);
-    return new FunctionParameters(parameters.toLink(),
-                                  visitor.optionalParameters,
-                                  parameters.length,
-                                  visitor.optionalParameterCount);
+    LinkBuilder<Element> parametersBuilder = visitor.analyzeNodes(nodes);
+    Link<Element> parameters = parametersBuilder.toLink();
+    Type returnType =
+        compiler.resolveTypeAnnotation(element, node.returnType);
+    LinkBuilder<Type> parameterTypes = new LinkBuilder<Type>();
+    for (Link<Element> link = parameters;
+         !link.isEmpty();
+         link = link.tail) {
+       parameterTypes.addLast(link.head.computeType(compiler));
+       // TODO(karlklose): optional parameters.
+    }
+    return new FunctionSignature(parameters,
+                                 visitor.optionalParameters,
+                                 parametersBuilder.length,
+                                 visitor.optionalParameterCount,
+                                 parameterTypes.toLink(),
+                                 returnType);
   }
 
   // TODO(ahe): This is temporary.
@@ -1759,12 +1770,6 @@ class SignatureResolver extends CommonResolverVisitor<Element> {
   }
 
   // TODO(ahe): This is temporary.
-  void resolveType(Node node) {
-    if (node == null) return;
-    node.accept(new ResolverVisitor(compiler, enclosingElement));
-  }
-
-  // TODO(ahe): This is temporary.
   ClassElement get currentClass() {
     return enclosingElement.isMember()
       ? enclosingElement.enclosingElement : null;