Avoid traversing classes when looking for circular references in typedefs.

pkg/analyzer/lib/src/generated/error_verifier.dart

 // Copyright (c) 2014, 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 engine.resolver.error_verifier;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'java_engine.dart';
@@ skipping 5170 matching lines @@
     return false;
   }
 
   /**
    * @return <code>true</code> if given [Element] has direct or indirect reference to itself
    *         from anywhere except [ClassElement] or type parameter bounds.
    */
   bool _hasTypedefSelfReference(Element target) {
     Set<Element> checked = new HashSet<Element>();
     List<Element> toCheck = new List<Element>();
+    GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference elementVisitor =
+        new GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference(toCheck);
     toCheck.add(target);
     bool firstIteration = true;
     while (true) {
       Element current;
       // get next element
       while (true) {
         // may be no more elements to check
         if (toCheck.isEmpty) {
           return false;
         }
         // try to get next element
         current = toCheck.removeAt(toCheck.length - 1);
         if (target == current) {
           if (firstIteration) {
             firstIteration = false;
             break;
           } else {
             return true;
           }
         }
         if (current != null && !checked.contains(current)) {
           break;
         }
       }
       // check current element
-      current.accept(new GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference(target, toCheck));
+      current.accept(elementVisitor);
       checked.add(current);
     }
   }
 
   bool _isFunctionType(DartType type) {
     if (type.isDynamic || type.isBottom) {
       return true;
     } else if (type is FunctionType || type.isDartCoreFunction) {
       return true;
     } else if (type is InterfaceType) {
@@ skipping 194 matching lines @@
       if (_safeCheckForRecursiveInterfaceInheritance(mixinType.element, path)) {
         return true;
       }
     }
     path.removeAt(path.length - 1);
     return false;
   }
 }
 
 class GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference extends GeneralizingElementVisitor<Object> {
-  Element target;
-
   List<Element> toCheck;
 
-  GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference(this.target, this.toCheck) : super();
-
-  bool _inClass = false;
+  GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference(
+      this.toCheck) : super();
 
   @override
   Object visitClassElement(ClassElement element) {
-    _addTypeToCheck(element.supertype);
-    for (InterfaceType mixin in element.mixins) {
-      _addTypeToCheck(mixin);
-    }
-    _inClass = !element.isTypedef;
-    try {
-      return super.visitClassElement(element);
-    } finally {
-      _inClass = false;
-    }
+    // Typedefs are allowed to reference themselves via classes.
+    return null;
   }
 
   @override
-  Object visitExecutableElement(ExecutableElement element) {
-    if (element.isSynthetic) {
-      return null;
-    }
-    _addTypeToCheck(element.returnType);
-    return super.visitExecutableElement(element);
-  }
-
-  @override
   Object visitFunctionTypeAliasElement(FunctionTypeAliasElement element) {
     _addTypeToCheck(element.returnType);
     return super.visitFunctionTypeAliasElement(element);
   }
 
   @override
   Object visitParameterElement(ParameterElement element) {
     _addTypeToCheck(element.type);
     return super.visitParameterElement(element);
   }
 
   @override
   Object visitTypeParameterElement(TypeParameterElement element) {
     _addTypeToCheck(element.bound);
     return super.visitTypeParameterElement(element);
   }
 
-  @override
-  Object visitVariableElement(VariableElement element) {
-    _addTypeToCheck(element.type);
-    return super.visitVariableElement(element);
-  }
-
   void _addTypeToCheck(DartType type) {
     if (type == null) {
       return;
     }
-    Element element = type.element;
-    // it is OK to reference target from class
-    if (_inClass && target == element) {
-      return;
-    }
     // schedule for checking
-    toCheck.add(element);
+    toCheck.add(type.element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (DartType typeArgument in interfaceType.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }