Use a FunctionSignature in CallStructure.signatureApplies

pkg/compiler/lib/src/universe/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.
 
 library universe;
 
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
 import '../types/types.dart';
@@ skipping 403 matching lines @@
   int get hashCode {
     return Hashing.listHash(namedArguments,
         Hashing.objectHash(argumentCount, namedArguments.length));
   }
 
   bool operator ==(other) {
     if (other is! CallStructure) return false;
     return match(other);
   }
 
-  bool signatureApplies(FunctionElement function) {
-    if (Elements.isUnresolved(function)) return false;
-    FunctionSignature parameters = function.functionSignature;
+  bool signatureApplies(FunctionSignature parameters) {
     if (argumentCount > parameters.parameterCount) return false;
     int requiredParameterCount = parameters.requiredParameterCount;
     int optionalParameterCount = parameters.optionalParameterCount;
     if (positionalArgumentCount < requiredParameterCount) return false;
 
     if (!parameters.optionalParametersAreNamed) {
       // We have already checked that the number of arguments are
       // not greater than the number of parameters. Therefore the
       // number of positional arguments are not greater than the
       // number of parameters.
@@ skipping 85 matching lines @@
    *
    * Returns [:true:] if the signature of the [caller] matches the
    * signature of the [callee], [:false:] otherwise.
    */
   static /*<T>*/ bool addForwardingElementArgumentsToList(
       ConstructorElement caller,
       List/*<T>*/ list,
       ConstructorElement callee,
       /*T*/ compileArgument(ParameterElement element),
       /*T*/ compileConstant(ParameterElement element)) {
+    assert(invariant(caller, !callee.isErroneous,
+        message: "Cannot compute arguments to erroneous constructor: "
+                 "$caller calling $callee."));
 
     FunctionSignature signature = caller.functionSignature;
     Map<Node, ParameterElement> mapping = <Node, ParameterElement>{};
 
     // TODO(ngeoffray): This is a hack that fakes up AST nodes, so
     // that we can call [addArgumentsToList].
     Link<Node> computeCallNodesFromParameters() {
       LinkBuilder<Node> builder = new LinkBuilder<Node>();
       signature.forEachRequiredParameter((ParameterElement element) {
         Node node = element.node;
@@ skipping 23 matching lines @@
 
     // Synthesize a structure for the call.
     // TODO(ngeoffray): Should the resolver do it instead?
     List<String> namedParameters;
     if (signature.optionalParametersAreNamed) {
       namedParameters =
           signature.optionalParameters.map((e) => e.name).toList();
     }
     CallStructure callStructure =
         new CallStructure(signature.parameterCount, namedParameters);
-    if (!callStructure.signatureApplies(callee)) {
+    if (!callStructure.signatureApplies(signature)) {
       return false;
     }
     list.addAll(callStructure.makeArgumentsList(
         nodes,
         callee,
         internalCompileArgument,
         compileConstant));
 
     return true;
   }
@@ skipping 260 matching lines @@
       return isSetter
           ? !element.isFinal && !element.isConst
           : isGetter || isCall;
     }
     if (isGetter) return true;
     if (isSetter) return false;
     return signatureApplies(element);
   }
 
   bool signatureApplies(FunctionElement function) {
-    return callStructure.signatureApplies(function);
+    if (Elements.isUnresolved(function)) return false;
+    return callStructure.signatureApplies(function.functionSignature);
   }
 
   bool sameNameHack(Element element, World world) {
     // TODO(ngeoffray): Remove workaround checks.
     return element.isConstructor ||
            name == element.name ||
            name == 'assert' && world.isAssertMethod(element);
   }
 
   bool applies(Element element, World world) {
@@ skipping 17 matching lines @@
     // Add bits from the call structure.
     return Hashing.mixHashCodeBits(hash, callStructure.hashCode);
   }
 
   String toString() {
     return 'Selector($kind, $name, ${callStructure.structureToString()})';
   }
 
   Selector toCallSelector() => new Selector.callClosureFrom(this);
 }