Implement redirecting constructors.

dart/sdk/lib/_internal/compiler/implementation/elements/elements.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 elements;
 
 import 'dart:uri';
 
 // TODO(ahe): Rename prefix to 'api' when VM bug is fixed.
 import '../../compiler.dart' as api_e;
@@ skipping 407 matching lines @@
   get patch => unsupported();
   get origin => unsupported();
   get defaultImplementation => unsupported();
   bool get isPatched => unsupported();
   bool get isPatch => unsupported();
   setPatch(patch) => unsupported();
   computeSignature(compiler) => unsupported();
   requiredParameterCount(compiler) => unsupported();
   optionalParameterCount(compiler) => unsupported();
   parameterCount(copmiler) => unsupported();
+
+  get redirectionTarget => this;
 }
 
 /**
  * An ambiguous element represent multiple elements accessible by the same name.
  *
  * Ambiguous elements are created during handling of import/export scopes. If an
  * ambiguous element is encountered during resolution a warning/error should be
  * reported.
  */
 class AmbiguousElement extends Element {
@@ skipping 696 matching lines @@
   /**
    * A function declaration that should be parsed instead of the current one.
    * The patch should be parsed as if it was in the current scope. Its
    * signature must match this function's signature.
    */
   // TODO(lrn): Consider using [defaultImplementation] to store the patch.
   FunctionElement patch = null;
   FunctionElement origin = null;
 
   /**
-   * If this is an interface constructor, [defaultImplementation] will
-   * changed by the resolver to point to the default
-   * implementation. Otherwise, [:defaultImplementation === this:].
+   * If this is a redirecting factory, [defaultImplementation] will be
+   * changed by the resolver to point to the redirection target.  If
+   * this is an interface constructor, [defaultImplementation] will be
+   * changed by the resolver to point to the default implementation.
+   * Otherwise, [:defaultImplementation === this:].
    */
+  // TODO(ahe): Rename this field to redirectionTarget and remove
+  // mention of interface constructors above.
   FunctionElement defaultImplementation;
 
   FunctionElement(SourceString name,
                   ElementKind kind,
                   Modifiers modifiers,
                   Element enclosing)
       : this.tooMuchOverloading(name, null, kind, modifiers, enclosing, null);
 
   FunctionElement.node(SourceString name,
                        FunctionExpression node,
@@ skipping 16 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;
 
+  FunctionElement get redirectionTarget {
+    if (this == defaultImplementation) return this;
+    Element 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
+        // open to track this.
+        throw new SpannableAssertionFailure(
+            target, 'redirecting factory leads to cycle');
+      }
+    }
+    return target;
+  }
+
   /**
    * Applies a patch function to this function. The patch function's body
    * is used as replacement when parsing this function's body.
    * This method must not be called after the function has been parsed,
    * and it must be called at most once.
    */
   void setPatch(FunctionElement patchElement) {
     // Sanity checks. The caller must check these things before calling.
     assert(patch == null);
     this.patch = patchElement;
@@ skipping 802 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }