Introduce ParameterStructure

pkg/compiler/lib/src/universe/call_structure.dart

 // Copyright (c) 2015, 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.call_structure;
 
 import '../common/names.dart' show Names;
-import '../elements/types.dart' show FunctionType;
+import '../elements/entities.dart' show ParameterStructure;
 import '../util/util.dart';
 import 'selector.dart' show Selector;
 
 /// The structure of the arguments at a call-site.
 // TODO(johnniwinther): Should these be cached?
 // TODO(johnniwinther): Should isGetter/isSetter be part of the call structure
 // instead of the selector?
 class CallStructure {
   static const CallStructure NO_ARGS = const CallStructure.unnamed(0);
   static const CallStructure ONE_ARG = const CallStructure.unnamed(1);
@@ skipping 48 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(FunctionType type) {
-    int requiredParameterCount = type.parameterTypes.length;
-    int optionalParameterCount =
-        type.optionalParameterTypes.length + type.namedParameters.length;
+  bool signatureApplies(ParameterStructure parameters) {
+    int requiredParameterCount = parameters.requiredParameters;
+    int optionalParameterCount = parameters.optionalParameters;
     int parameterCount = requiredParameterCount + optionalParameterCount;
     if (argumentCount > parameterCount) return false;
     if (positionalArgumentCount < requiredParameterCount) return false;
 
-    if (type.namedParameters.isEmpty) {
+    if (parameters.namedParameters.isEmpty) {
       // 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.
       assert(positionalArgumentCount <= parameterCount);
       return namedArguments.isEmpty;
     } else {
       if (positionalArgumentCount > requiredParameterCount) return false;
       assert(positionalArgumentCount == requiredParameterCount);
       if (namedArgumentCount > optionalParameterCount) return false;
 
       int nameIndex = 0;
-      List<String> namedParameters = type.namedParameters;
+      List<String> namedParameters = parameters.namedParameters;
       for (String name in getOrderedNamedArguments()) {
         bool found = false;
         // Note: we start at the existing index because arguments are sorted.
         while (nameIndex < namedParameters.length) {
           if (name == namedParameters[nameIndex]) {
             found = true;
             break;
           }
           nameIndex++;
         }
@@ skipping 42 matching lines @@
       return first.compareTo(second);
     });
     return _orderedNamedArguments;
   }
 
   @override
   String structureToString() {
     return 'arity=$argumentCount, named=[${namedArguments.join(', ')}]';
   }
 }