Check if signatures are compatible in a redirecting factory before synthesizing a call in the infer…

sdk/lib/_internal/compiler/implementation/elements/modelx.dart

 // Copyright (c) 2013, 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 elements.modelx;
 
 import 'dart:collection' show LinkedHashMap;
 
 import 'elements.dart';
 import '../../compiler.dart' as api;
@@ skipping 1171 matching lines @@
   }
 
   int get parameterCount => requiredParameterCount + optionalParameterCount;
 
   /**
    * Check whether a function with this signature can be used instead of a
    * function with signature [signature] without causing a `noSuchMethod`
    * exception/call.
    */
   bool isCompatibleWith(FunctionSignature signature) {
-    if (optionalParametersAreNamed != signature.optionalParametersAreNamed) {
-      return false;
-    }
     if (optionalParametersAreNamed) {
+      if (!signature.optionalParametersAreNamed) {
+        return requiredParameterCount == signature.parameterCount;
+      }
+      // If both signatures have named parameters, then they must have
+      // the same number of required parameters, and the names in
+      // [signature] must all be in [:this:].
       if (requiredParameterCount != signature.requiredParameterCount) {
         return false;
       }
+      Set<String> names = optionalParameters.toList().map(
+          (Element element) => element.name.slowToString()).toSet();
       for (Element namedParameter in signature.optionalParameters) {
-        if (!optionalParameters.contains(namedParameter)) {
+        if (!names.contains(namedParameter.name.slowToString())) {
           return false;
         }
       }
     } else {
+      if (signature.optionalParametersAreNamed) return false;
       // There must be at least as many arguments as in the other signature, but
       // this signature must not have more required parameters.  Having more
       // optional parameters is not a problem, they simply are never provided
       // by call sites of a call to a method with the other signature.
-      if (requiredParameterCount > signature.requiredParameterCount ||
-          requiredParameterCount < signature.parameterCount ||
-          parameterCount < signature.parameterCount) {
-        return false;
-      }
+      int otherTotalCount = signature.parameterCount;
+      return requiredParameterCount <= otherTotalCount
+          && parameterCount >= otherTotalCount;
     }
     return true;
   }
 }
 
 class FunctionElementX extends ElementX implements FunctionElement {
   FunctionExpression cachedNode;
   DartType type;
   final Modifiers modifiers;
 
@@ skipping 993 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }