Compute function types together with the parameters.

lib/compiler/implementation/universe.dart

 // Copyright (c) 2012, 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.
 
 class Universe {
   Map<Element, String> generatedCode;
   Map<Element, String> generatedBailoutCode;
   final Set<ClassElement> instantiatedClasses;
   final Set<SourceString> instantiatedClassInstanceFields;
   final Set<FunctionElement> staticFunctionsNeedingGetter;
@@ skipping 121 matching lines @@
       return kind === SelectorKind.GETTER || kind === SelectorKind.INVOCATION;
     }
     if (element.isField()) {
       return kind === SelectorKind.GETTER
           || kind === SelectorKind.INVOCATION
           || kind === SelectorKind.SETTER;
     }
     if (kind === SelectorKind.GETTER) return true;
 
     FunctionElement function = element;
-    FunctionParameters parameters = function.computeParameters(compiler);
+    FunctionSignature parameters = function.computeSignature(compiler);
     if (argumentCount > parameters.parameterCount) return false;
     int requiredParameterCount = parameters.requiredParameterCount;
     int optionalParameterCount = parameters.optionalParameterCount;
     if (positionalArgumentCount < requiredParameterCount) return false;
 
     bool hasOptionalParameters = !parameters.optionalParameters.isEmpty();
     if (namedArguments.isEmpty()) {
       if (!hasOptionalParameters) {
         return requiredParameterCount == argumentCount;
       } else {
@@ skipping 30 matching lines @@
   bool addArgumentsToList(Link<Node> arguments,
                           List list,
                           FunctionElement element,
                           compileArgument(Node argument),
                           compileConstant(Element element),
                           Compiler compiler) {
     if (!this.applies(element, compiler)) return false;
 
     void addMatchingArgumentsToList(Link<Node> link) {}
 
-    FunctionParameters parameters = element.computeParameters(compiler);
+    FunctionSignature parameters = element.computeSignature(compiler);
     if (this.positionalArgumentCount == parameters.parameterCount) {
       for (Link<Node> link = arguments; !link.isEmpty(); link = link.tail) {
         list.add(compileArgument(link.head));
       }
       return true;
     }
 
     // If there are named arguments, provide them in the order
     // expected by the called function, which is the source order.
 
@@ skipping 133 matching lines @@
 
     return false;
   }
 
   bool operator ==(other) {
     if (other is !TypedSelector) return false;
     if (other.receiverType !== receiverType) return false;
     return super == other;
   }
 }