Remove use of FunctionSignature et al from call_structure.dart

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.dart';
 import '../common/names.dart' show Names;
-import '../elements/elements.dart';
-import '../tree/tree.dart';
+import '../elements/types.dart' show FunctionType;
 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 11 matching lines @@
 
   const CallStructure.unnamed(this.argumentCount);
 
   factory CallStructure(int argumentCount, [List<String> namedArguments]) {
     if (namedArguments == null || namedArguments.isEmpty) {
       return new CallStructure.unnamed(argumentCount);
     }
     return new NamedCallStructure(argumentCount, namedArguments);
   }
 
-  /// Creates the [CallStructure] corresponding to calling [signature] as
-  /// declared, that is, all named arguments are in the order of declaration.
-  factory CallStructure.fromSignature(FunctionSignature signature) {
-    List<String> namedParameters;
-    if (signature.optionalParametersAreNamed) {
-      namedParameters =
-          signature.optionalParameters.map((e) => e.name).toList();
-    }
-    return new CallStructure(signature.parameterCount, namedParameters);
-  }
-
   /// `true` if this call has named arguments.
   bool get isNamed => false;
 
   /// `true` if this call has no named arguments.
   bool get isUnnamed => true;
 
   /// The names of the named arguments in call-site order.
   List<String> get namedArguments => const <String>[];
 
   /// The names of the named arguments in canonicalized order.
@@ skipping 17 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(FunctionSignature parameters) {
-    if (argumentCount > parameters.parameterCount) return false;
-    int requiredParameterCount = parameters.requiredParameterCount;
-    int optionalParameterCount = parameters.optionalParameterCount;
+  bool signatureApplies(FunctionType type) {
+    int requiredParameterCount = type.parameterTypes.length;
+    int optionalParameterCount =
+        type.optionalParameterTypes.length + type.namedParameters.length;
+    int parameterCount = requiredParameterCount + optionalParameterCount;
+    if (argumentCount > parameterCount) return false;
     if (positionalArgumentCount < requiredParameterCount) return false;
 
-    if (!parameters.optionalParametersAreNamed) {
+    if (type.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 <= parameters.parameterCount);
+      assert(positionalArgumentCount <= parameterCount);
       return namedArguments.isEmpty;
     } else {
       if (positionalArgumentCount > requiredParameterCount) return false;
       assert(positionalArgumentCount == requiredParameterCount);
       if (namedArgumentCount > optionalParameterCount) return false;
-      Set<String> nameSet = new Set<String>();
-      parameters.optionalParameters.forEach((Element element) {
-        nameSet.add(element.name);
-      });
-      for (String name in namedArguments) {
-        if (!nameSet.contains(name)) return false;
-        // TODO(5213): By removing from the set we are checking
-        // that we are not passing the name twice. We should have this
-        // check in the resolver also.
-        nameSet.remove(name);
+
+      int nameIndex = 0;
+      List<String> namedParameters = type.namedParameters;
+      OUTER:
+      for (String name in getOrderedNamedArguments()) {
+        while (nameIndex < namedParameters.length) {
+          if (name == namedParameters[nameIndex]) {

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

Can we get here anymore with the duplicated names, or will the resolver prevent
us from reaching this point? If not, we could move the ++ here to ensure the
same semantics:
  if (name == namedParameters[nameIndex++])

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

We still create both function signatures/types and call structures with
duplicate names, but these are erroneous cases so what action we take here is
not that important. It's even preferable to allow calls with duplicate names to
methods with duplicate names...

+            continue OUTER;

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

I find the logic with `continue` a bit hard to follow. This has an extra check,
but might be more self explanatory:

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++; 
  }
  if (!found) return false;
}
return true;
    

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

Done.

+          }
+          nameIndex++;
+        }
+        return false;
       }
       return true;
     }
   }
 
-  /**
-   * Returns a `List` with the evaluated arguments in the normalized order.
-   *
-   * [compileDefaultValue] is a function that returns a compiled constant
-   * of an optional argument that is not in [compiledArguments].
-   *
-   * Precondition: `this.applies(element, world)`.
-   *
-   * Invariant: [element] must be the implementation element.
-   */
-  /*<T>*/ List/*<T>*/ makeArgumentsList(
-      Link<Node> arguments,
-      FunctionElement element,
-      /*T*/ compileArgument(Node argument),
-      /*T*/ compileDefaultValue(ParameterElement element)) {
-    assert(invariant(element, element.isImplementation));
-    List/*<T>*/ result = new List();
-
-    FunctionSignature parameters = element.functionSignature;
-    parameters.forEachRequiredParameter((ParameterElement element) {
-      result.add(compileArgument(arguments.head));
-      arguments = arguments.tail;
-    });
-
-    if (!parameters.optionalParametersAreNamed) {
-      parameters.forEachOptionalParameter((ParameterElement element) {
-        if (!arguments.isEmpty) {
-          result.add(compileArgument(arguments.head));
-          arguments = arguments.tail;
-        } else {
-          result.add(compileDefaultValue(element));
-        }
-      });
-    } else {
-      // Visit named arguments and add them into a temporary list.
-      List compiledNamedArguments = [];
-      for (; !arguments.isEmpty; arguments = arguments.tail) {
-        NamedArgument namedArgument = arguments.head;
-        compiledNamedArguments.add(compileArgument(namedArgument.expression));
-      }
-      // Iterate over the optional parameters of the signature, and try to
-      // find them in [compiledNamedArguments]. If found, we use the
-      // value in the temporary list, otherwise the default value.
-      parameters.orderedOptionalParameters.forEach((ParameterElement element) {
-        int foundIndex = namedArguments.indexOf(element.name);
-        if (foundIndex != -1) {
-          result.add(compiledNamedArguments[foundIndex]);
-        } else {
-          result.add(compileDefaultValue(element));
-        }
-      });
-    }
-    return result;
-  }
-
-  /**
-   * Fills [list] with the arguments in the order expected by
-   * [callee], and where [caller] is a synthesized element
-   *
-   * [compileArgument] is a function that returns a compiled version
-   * of a parameter of [callee].
-   *
-   * [compileConstant] is a function that returns a compiled constant
-   * of an optional argument that is not in the parameters of [callee].
-   *
-   * 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.isMalformed,
-        message: "Cannot compute arguments to malformed 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;
-        mapping[node] = element;
-        builder.addLast(node);
-      });
-      if (signature.optionalParametersAreNamed) {
-        signature.forEachOptionalParameter((ParameterElement element) {
-          mapping[element.initializer] = element;
-          builder.addLast(new NamedArgument(null, null, element.initializer));
-        });
-      } else {
-        signature.forEachOptionalParameter((ParameterElement element) {
-          Node node = element.node;
-          mapping[node] = element;
-          builder.addLast(node);
-        });
-      }
-      return builder.toLink();
-    }
-
-    /*T*/ internalCompileArgument(Node node) {
-      return compileArgument(mapping[node]);
-    }
-
-    Link<Node> nodes = computeCallNodesFromParameters();
-
-    // Synthesize a structure for the call.
-    // TODO(ngeoffray): Should the resolver do it instead?
-    CallStructure callStructure = new CallStructure.fromSignature(signature);
-    if (!callStructure.signatureApplies(signature)) {
-      return false;
-    }
-    list.addAll(callStructure.makeArgumentsList(
-        nodes, callee, internalCompileArgument, compileConstant));
-
-    return true;
-  }
-
   static bool sameNames(List<String> first, List<String> second) {
     for (int i = 0; i < first.length; i++) {
       if (first[i] != second[i]) return false;
     }
     return true;
   }
 }
 
 ///
 class NamedCallStructure extends CallStructure {
@@ skipping 26 matching lines @@
       return first.compareTo(second);
     });
     return _orderedNamedArguments;
   }
 
   @override
   String structureToString() {
     return 'arity=$argumentCount, named=[${namedArguments.join(', ')}]';
   }
 }