Check cycles in redirecting factories.

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 1257 matching lines @@
       : 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
-        // open to track this.
-        throw new SpannableAssertionFailure(
-            target, 'redirecting factory leads to cycle');
-      }
-    }
-    return target;
+  /// This field is set by the post process queue when checking for cycles.
+  FunctionElement internalRedirectionTarget;
+  set redirectionTarget(FunctionElement constructor) {
+    assert(constructor != null && internalRedirectionTarget == null);
+    internalRedirectionTarget = constructor;
+  }
+  get redirectionTarget {
+    return internalRedirectionTarget != null ? internalRedirectionTarget
+                                             : defaultImplementation;

[ngeoffray, 2013/09/18 11:19:23]

This looks weird. Depending on the current stage of the compiler the element
model could return you something different? Can't you just return
internalRedirectionTarget and have the callers deal if it's null?

[karlklose, 2013/09/18 12:30:39]

Actually I can decide which of them to return independent of their value.

internalRedirectionTarget still changes during post-processing, but the getter
is only called in the backend.

   }
 
   InterfaceType computeTargetType(Compiler compiler,
                                   InterfaceType newType) {
     if (!isRedirectingFactory) return newType;
     ClassElement targetClass = getEnclosingClass();
     TreeElements treeElements =
         compiler.enqueuer.resolution.getCachedElements(
             declaration);
     FunctionExpression functionNode = parseNode(compiler);
@@ skipping 913 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }