Use a FunctionSignature in CallStructure.signatureApplies

pkg/compiler/lib/src/compile_time_constants.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 dart2js.compile_time_constant_evaluator;
 
 import 'constant_system_dart.dart';
 import 'constants/constant_system.dart';
 import 'constants/expressions.dart';
 import 'constants/values.dart';
@@ skipping 761 matching lines @@
    * Returns the normalized list of constant arguments that are passed to the
    * constructor including both the concrete arguments and default values for
    * omitted optional arguments.
    *
    * Invariant: [target] must be an implementation element.
    */
   List<AstConstant> evaluateArgumentsToConstructor(
       Node node,
       CallStructure callStructure,
       Link<Node> arguments,
-      FunctionElement target,
+      ConstructorElement target,
       {AstConstant compileArgument(Node node)}) {
     assert(invariant(node, target.isImplementation));
 
     AstConstant compileDefaultValue(VariableElement element) {
       ConstantExpression constant = handler.compileConstant(element);
       return new AstConstant.fromDefaultValue(
           element, constant, handler.getConstantValue(constant));
     }
     target.computeType(compiler);
 
-    if (!callStructure.signatureApplies(target)) {
+    FunctionSignature signature = target.functionSignature;
+    if (!callStructure.signatureApplies(signature)) {
       String name = Elements.constructorNameForDiagnostics(
           target.enclosingClass.name, target.name);
       compiler.reportError(
           node,
           MessageKind.INVALID_CONSTRUCTOR_ARGUMENTS,
           {'constructorName': name});
 
       return new List<AstConstant>.filled(
           target.functionSignature.parameterCount,
           new ErroneousAstConstant(context, node));
@@ skipping 217 matching lines @@
       CallStructure callStructure,
       List<AstConstant> concreteArguments,
       List<AstConstant> normalizedArguments) {
     if (target.isRedirectingFactory) {
       // This happens is case of cyclic redirection.
       assert(invariant(node, compiler.compilationFailed,
           message: "makeConstructedConstant can only be called with the "
                    "effective target: $constructor"));
       return new ErroneousAstConstant(context, node);
     }
-    assert(invariant(node, callStructure.signatureApplies(constructor) ||
-                     compiler.compilationFailed,
+    assert(invariant(
+        node,
+        callStructure.signatureApplies(constructor.functionSignature) ||
+            compiler.compilationFailed,
         message: "Call structure $callStructure does not apply to constructor "
                  "$constructor."));
 
     ConstructorEvaluator evaluator = new ConstructorEvaluator(
         constructedType, target, handler, compiler);
     evaluator.evaluateConstructorFieldValues(normalizedArguments);
     Map<FieldElement, AstConstant> fieldConstants =
         evaluator.buildFieldConstants(target.enclosingClass);
     Map<FieldElement, ConstantValue> fieldValues =
         <FieldElement, ConstantValue>{};
@@ skipping 287 matching lines @@
           // TODO(johnniwinther): Return a [NonConstantValue] instead.
           new ErroneousConstantExpression(), new NullConstantValue());
 }
 
 // TODO(johnniwinther): Avoid the need for this hack.
 TreeElements _analyzeElementEagerly(Compiler compiler, AstElement element) {
   WorldImpact worldImpact = compiler.analyzeElement(element.declaration);
   compiler.enqueuer.resolution.applyImpact(element.declaration, worldImpact);
   return element.resolvedAst.elements;
 }