Remove use of FunctionSignature et al from call_structure.dart

pkg/compiler/lib/src/resolution/members.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.resolution.members;
 
 import '../common.dart';
 import '../common/names.dart' show Selectors;
 import '../common/resolution.dart' show Resolution;
 import '../compile_time_constants.dart';
@@ skipping 1548 matching lines @@
     if (semantics == null) {
       semantics = computeSuperAccessSemanticsForSelector(node, selector,
           alternateName: name.setter);
     }
     if (node.isCall) {
       bool isIncompatibleInvoke = false;
       switch (semantics.kind) {
         case AccessKind.SUPER_METHOD:
           MethodElement superMethod = semantics.element;
           superMethod.computeType(resolution);
-          if (!callStructure.signatureApplies(superMethod.functionSignature)) {
+          if (!callStructure.signatureApplies(superMethod.type)) {
             registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
             registry.registerDynamicUse(new DynamicUse(selector, null));
             registry.registerFeature(Feature.SUPER_NO_SUCH_METHOD);
             isIncompatibleInvoke = true;
           } else {
             registry.registerStaticUse(
                 new StaticUse.superInvoke(semantics.element, callStructure));
           }
           break;
         case AccessKind.SUPER_FIELD:
@@ skipping 907 matching lines @@
     Selector selector;
     if (node.isCall) {
       CallStructure callStructure =
           resolveArguments(node.argumentsNode).callStructure;
       selector = new Selector.call(name, callStructure);
       bool isIncompatibleInvoke = false;
       switch (semantics.kind) {
         case AccessKind.LOCAL_FUNCTION:
           LocalFunctionElementX function = semantics.element;
           function.computeType(resolution);
-          if (!callStructure.signatureApplies(function.functionSignature)) {
+          if (!callStructure.signatureApplies(function.type)) {
             registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
             registry.registerDynamicUse(new DynamicUse(selector, null));
             isIncompatibleInvoke = true;
           }
           break;
         case AccessKind.PARAMETER:
         case AccessKind.FINAL_PARAMETER:
         case AccessKind.LOCAL_VARIABLE:
         case AccessKind.FINAL_LOCAL_VARIABLE:
           selector = callStructure.callSelector;
@@ skipping 147 matching lines @@
       ArgumentsResult argumentsResult = resolveArguments(node.argumentsNode);
       CallStructure callStructure = argumentsResult.callStructure;
       selector = new Selector.call(name, callStructure);
 
       bool isIncompatibleInvoke = false;
       switch (semantics.kind) {
         case AccessKind.STATIC_METHOD:
         case AccessKind.TOPLEVEL_METHOD:
           MethodElement method = semantics.element;
           method.computeType(resolution);
-          if (!callStructure.signatureApplies(method.functionSignature)) {
+          if (!callStructure.signatureApplies(method.type)) {
             registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
             registry.registerDynamicUse(new DynamicUse(selector, null));
             isIncompatibleInvoke = true;
           } else {
             registry.registerStaticUse(
                 new StaticUse.staticInvoke(semantics.element, callStructure));
             handleForeignCall(node, semantics.element, callStructure);
             if (method == resolution.commonElements.identicalFunction &&
                 argumentsResult.isValidAsConstant) {
               result = new ConstantResult(
@@ skipping 1158 matching lines @@
     CallStructure callStructure = selector.callStructure;
     registry.useElement(node.send, constructor);
 
     ResolutionDartType type = result.type;
     ConstructorAccessKind kind;
     bool isInvalid = false;
     switch (result.kind) {
       case ConstructorResultKind.GENERATIVE:
         // Ensure that the signature of [constructor] has been computed.
         constructor.computeType(resolution);
-        if (!callStructure.signatureApplies(constructor.functionSignature)) {
+        if (!callStructure.signatureApplies(constructor.type)) {
           isInvalid = true;
           kind = ConstructorAccessKind.INCOMPATIBLE;
           registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
         } else {
           kind = ConstructorAccessKind.GENERATIVE;
         }
         break;
       case ConstructorResultKind.FACTORY:
         // Ensure that the signature of [constructor] has been computed.
         constructor.computeType(resolution);
-        if (!callStructure.signatureApplies(constructor.functionSignature)) {
+        if (!callStructure.signatureApplies(constructor.type)) {
           // The effective target might still be valid(!) so the is not an
           // invalid case in itself. For instance
           //
           //    class A {
           //       factory A() = A.a;
           //       A.a(a);
           //    }
           //    m() => new A(0); // This creates a warning but works at runtime.
           //
           registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
@@ skipping 897 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(
     DiagnosticReporter reporter, Node node, Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), reporter, node);
 }