Support type variables on redirecting factory constructors.

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 299 matching lines @@
   }
 
   Link<MetadataAnnotation> get metadata => unsupported();
   get type => unsupported();
   get cachedNode => unsupported();
   get functionSignature => unsupported();
   get patch => unsupported();
   get origin => unsupported();
   get defaultImplementation => unsupported();
 
+  bool get isRedirectingFactory => unsupported();
   bool get isPatched => unsupported();
   bool get isPatch => unsupported();
 
   setPatch(patch) => unsupported();
   computeSignature(compiler) => unsupported();
   requiredParameterCount(compiler) => unsupported();
   optionalParameterCount(compiler) => unsupported();
   parameterCount(compiler) => unsupported();
 
   // TODO(kasperl): These seem unnecessary.
@@ skipping 756 matching lines @@
     forEachRequiredParameter(function);
     forEachOptionalParameter(function);
   }
 
   void orderedForEachParameter(void function(Element parameter)) {
     forEachRequiredParameter(function);
     orderedOptionalParameters.forEach(function);
   }
 
   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 (requiredParameterCount != signature.requiredParameterCount) {
+        return false;
+      }
+      for (Element namedParameter in signature.optionalParameters) {
+        if (!optionalParameters.contains(namedParameter)) {
+          return false;
+        }
+      }
+    } else {
+      // There must be at least as many arguments as in the other signature, but
+      // this signature must not have more required paramters.  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;
+      }
+    }
+    return true;
+  }
 }
 
 class FunctionElementX extends ElementX implements FunctionElement {
   FunctionExpression cachedNode;
   DartType type;
   final Modifiers modifiers;
 
   FunctionSignature functionSignature;
 
   /**
@@ skipping 39 matching lines @@
                                       Element enclosing,
                                       FunctionSignature this.functionSignature)
       : super(name, kind, enclosing) {
     assert(modifiers != null);
     defaultImplementation = this;
   }
 
   bool get isPatched => patch != null;
   bool get isPatch => origin != null;
 
+  bool get isRedirectingFactory => defaultImplementation != this;
+
   FunctionElement get redirectionTarget {
     if (this == defaultImplementation) return this;
     var target = defaultImplementation;
     Set<Element> seen = new Set<Element>();
     seen.add(target);
     while (!target.isErroneous() && target != target.defaultImplementation) {
       target = target.defaultImplementation;
       if (seen.contains(target)) {
         // TODO(ahe): This is expedient for now, but it should be
         // checked by the resolver.  Keeping http://dartbug.com/3970
@@ skipping 933 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }