Remove use of FunctionSignature et al from call_structure.dart

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 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask, Measurer;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
@@ skipping 847 matching lines @@
     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(resolution);
 
-    FunctionSignature signature = target.functionSignature;
-    if (!callStructure.signatureApplies(signature)) {
+    if (!callStructure.signatureApplies(target.type)) {
       String name = Elements.constructorNameForDiagnostics(
           target.enclosingClass.name, target.name);
       reporter.reportErrorMessage(node,
           MessageKind.INVALID_CONSTRUCTOR_ARGUMENTS, {'constructorName': name});
 
       return new List<AstConstant>.filled(
           target.functionSignature.parameterCount,
           new ErroneousAstConstant(context, node));
     }
-    return callStructure.makeArgumentsList(
-        arguments, target, compileArgument, compileDefaultValue);
+    return Elements.makeArgumentsList<AstConstant>(
+        callStructure, arguments, target, compileArgument, compileDefaultValue);
   }
 
   AstConstant visitNewExpression(NewExpression node) {
     if (!node.isConst) {
       return signalNotCompileTimeConstant(node);
     }
 
     Send send = node.send;
     ConstructorElement constructor = elements[send];
     if (Elements.isUnresolved(constructor)) {
@@ skipping 215 matching lines @@
       List<AstConstant> normalizedArguments) {
     if (target.isRedirectingFactory) {
       // This happens in 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.functionSignature) ||
+        callStructure.signatureApplies(constructor.type) ||
             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 =
@@ skipping 161 matching lines @@
    * the [fieldValues] map.
    */
   void evaluateConstructorInitializers() {
     ResolvedAst resolvedAst = constructor.resolvedAst;
     if (resolvedAst.kind != ResolvedAstKind.PARSED) {
       List<AstConstant> compiledArguments = <AstConstant>[];
 
       Function compileArgument = (element) => definitions[element];
       Function compileConstant = handler.compileConstant;
       FunctionElement target = constructor.definingConstructor.implementation;
-      CallStructure.addForwardingElementArgumentsToList(constructor,
+      Elements.addForwardingElementArgumentsToList<AstConstant>(constructor,
           compiledArguments, target, compileArgument, compileConstant);
-      CallStructure callStructure =
-          new CallStructure.fromSignature(target.functionSignature);
+      CallStructure callStructure = new CallStructure(
+          target.functionSignature.parameterCount, target.type.namedParameters);

[Siggi Cherem (dart-lang), 2017/01/13 17:11:07]

do we want to also get rid of functionSignature here?
 (compute parameterCount from target.type instead)?

[Johnni Winther, 2017/01/18 11:02:51]

I considered adding a 'parameterCount' property to FunctionType, but we
currently have a lot of inconsistent semantics on the various
(-/required/positional/named)ParameterCount properties so for this CL I didn't
want to add to the madness. Will look into it later.

       evaluateSuperOrRedirectSend(compiledArguments, callStructure, target);
       return;
     }
     FunctionExpression functionNode = resolvedAst.node;
     NodeList initializerList = functionNode.initializers;
 
     bool foundSuperOrRedirect = false;
 
     if (initializerList != null) {
       for (Link<Node> link = initializerList.nodes;
@@ skipping 137 matching lines @@
 class _CompilerEnvironment implements Environment {
   final Compiler compiler;
 
   _CompilerEnvironment(this.compiler);
 
   @override
   String readFromEnvironment(String name) {
     return compiler.fromEnvironment(name);
   }
 }