Issue 3968. Report error if cycle in redirecting factory constructors

compiler/java/com/google/dart/compiler/resolver/Resolver.java

 // 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.
 
 package com.google.dart.compiler.resolver;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import com.google.dart.compiler.DartCompilationPhase;
@@ skipping 216 matching lines @@
     @Override
     public Element visitUnit(DartUnit unit) {
       for (DartDirective directive : unit.getDirectives()) {
         if (directive instanceof DartPartOfDirective) {
           directive.accept(this);
         }
       }
       for (DartNode node : unit.getTopLevelNodes()) {
         node.accept(this);
       }
+      checkRedirectingFactoryConstructorsCycle(unit);
       return null;
     }
 
+    private void checkRedirectingFactoryConstructorsCycle(DartUnit unit) {
+      unit.accept(new ASTVisitor<Void>() {
+        @Override
+        public Void visitMethodDefinition(DartMethodDefinition node) {
+          MethodNodeElement element = node.getElement();
+          if (ElementKind.of(element) == ElementKind.CONSTRUCTOR) {
+            ConstructorElement constructor = (ConstructorElement) element;
+            if (hasRedirectingFactoryConstructorCycle(constructor)) {
+              onError(constructor.getNameLocation(),
+                  ResolverErrorCode.REDIRECTION_CONSTRUCTOR_CYCLE);
+            }
+          }
+          return super.visitMethodDefinition(node);
+        }
+      });
+    }
+    
+    private boolean hasRedirectingFactoryConstructorCycle(ConstructorElement element) {
+      Set<ConstructorElement> constructors = Sets.newHashSet();
+      while (element != null) {
+        if (constructors.contains(element)) {
+          return true;
+        }
+        constructors.add(element);
+        element = element.getRedirectingFactoryConstructor();
+      }
+      return false;
+    }
+    
     @Override
     public Element visitFunctionTypeAlias(DartFunctionTypeAlias alias) {
       alias.getMetadata().accept(this);
       getContext().pushFunctionAliasScope(alias);
       resolveFunctionAlias(alias);
 
       getContext().pushScope("<parameters>");
       try {
         List<DartParameter> parameters = alias.getParameters();
         for (DartParameter parameter : parameters) {
@@ skipping 442 matching lines @@
       }
 
       // resolve redirecting factory constructor
       {
         DartTypeNode rcTypeName = node.getRedirectedTypeName();
         if (rcTypeName != null) {
           Type rcType = resolveType(rcTypeName, true, true, false,
               TypeErrorCode.NO_SUCH_TYPE, ResolverErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS);
           switch (TypeKind.of(rcType)) {
             case INTERFACE:
+              ConstructorElement targetConstructor = null;
               Element element = recordType(rcTypeName, rcType);
               DartIdentifier rcName = node.getRedirectedConstructorName();
               if (rcName != null) {
                 element = ((ClassElement) element).lookupConstructor(rcName.getName());
                 switch (ElementKind.of(element)) {
                   case CONSTRUCTOR:
+                    targetConstructor = (ConstructorElement) element;
                     recordElement(rcName, element);
                     if (member.getModifiers().isConstant() && !element.getModifiers().isConstant()) {
                       onError(rcName,
                           ResolverErrorCode.REDIRECTION_CONSTRUCTOR_TARGET_MUST_BE_CONST);
                     }
                     break;
                 }
+              } else {
+                targetConstructor = ((ClassElement) element).lookupConstructor(element.getName());
               }
+              Elements.setRedirectingFactoryConstructor(((ConstructorElement) member),
+                  targetConstructor);
               break;
             default:
               onError(rcTypeName, ResolverErrorCode.REDIRECTION_CONSTRUCTOR_TARGET_TYPE);
           }
         }
       }
 
       context = previousContext;
       innermostFunction = currentMethod = null;
       enclosingElement = previousEnclosingElement;
@@ skipping 1657 matching lines @@
           ClassElement currentClass = (ClassElement) constructor.getEnclosingElement();
           if (nextClass == currentClass) {
             return (ConstructorNodeElement) nextConstructorElement;
           }
         }
       }
     }
     return null;
   }
 }