Fix a stack overflow

pkg/analyzer/lib/src/generated/element.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.element;
 
 import 'dart:collection';
@@ skipping 69 matching lines @@
   bool get isBottom => true;
 
   @override
   bool operator ==(Object object) => identical(object, this);
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) =>
       identical(object, this);
 
   @override
+  int internalHashCode(List<DartType> visitedTypes) => hashCode;
+
+  @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic,
       Set<TypeImpl_TypePair> visitedTypePairs) =>
       true;
 
   @override
   bool internalIsSubtypeOf(DartType type,
       Set<TypeImpl_TypePair> visitedTypePairs) =>
       true;
 
   @override
@@ skipping 2072 matching lines @@
   bool get isDynamic => true;
 
   @override
   bool operator ==(Object object) => identical(object, this);
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) =>
       identical(object, this);
 
   @override
+  int internalHashCode(List<DartType> visitedTypes) => hashCode;
+
+  @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic,
       Set<TypeImpl_TypePair> visitedTypePairs) {
     // T is S
     if (identical(this, type)) {
       return true;
     }
     // else
     return withDynamic;
   }
 
@@ skipping 2592 matching lines @@
         buffer.write("null");
       } else {
         buffer.write(returnType.displayName);
       }
       name = buffer.toString();
     }
     return name;
   }
 
   @override
-  int get hashCode {
+  int get hashCode => internalHashCode(<DartType>[]);
+
+  @override
+  int internalHashCode(List<DartType> visitedTypes) {
     if (element == null) {
       return 0;
+    } else if (visitedTypes.contains(this)) {
+      return 3;
     }
+    visitedTypes.add(this);
     // Reference the arrays of parameters
     List<DartType> normalParameterTypes = this.normalParameterTypes;
     List<DartType> optionalParameterTypes = this.optionalParameterTypes;
     Iterable<DartType> namedParameterTypes = this.namedParameterTypes.values;
     // Generate the hashCode
-    int hashCode = returnType.hashCode;
+    int code = (returnType as TypeImpl).internalHashCode(visitedTypes);
     for (int i = 0; i < normalParameterTypes.length; i++) {
-      hashCode = (hashCode << 1) + normalParameterTypes[i].hashCode;
+      code = (code << 1) + (normalParameterTypes[i] as TypeImpl).internalHashCode(visitedTypes);
     }
     for (int i = 0; i < optionalParameterTypes.length; i++) {
-      hashCode = (hashCode << 1) + optionalParameterTypes[i].hashCode;
+      code = (code << 1) + (optionalParameterTypes[i] as TypeImpl).internalHashCode(visitedTypes);
     }
     for (DartType type in namedParameterTypes) {
-      hashCode = (hashCode << 1) + type.hashCode;
+      code = (code << 1) + (type as TypeImpl).internalHashCode(visitedTypes);
     }
-    return hashCode;
+    return code;
   }
 
   @override
   Map<String, DartType> get namedParameterTypes {
     LinkedHashMap<String, DartType> namedParameterTypes =
         new LinkedHashMap<String, DartType>();
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return namedParameterTypes;
     }
@@ skipping 104 matching lines @@
       return definingClass.typeParameters;
     }
     return TypeParameterElementImpl.EMPTY_ARRAY;
   }
 
   @override
   bool operator ==(Object object) =>
       internalEquals(object, new HashSet<ElementPair>());
 
   @override
-  void appendTo(StringBuffer buffer) {
+  void appendTo(StringBuffer buffer, Set<DartType> visitedTypes) {
+    if (!visitedTypes.add(this)) {
+      buffer.write(name == null ? '...' : name);
+      return;
+    }
     List<DartType> normalParameterTypes = this.normalParameterTypes;
     List<DartType> optionalParameterTypes = this.optionalParameterTypes;
     Map<String, DartType> namedParameterTypes = this.namedParameterTypes;
     DartType returnType = this.returnType;
     buffer.write("(");
     bool needsComma = false;
     if (normalParameterTypes.length > 0) {
       for (DartType type in normalParameterTypes) {
         if (needsComma) {
           buffer.write(", ");
         } else {
           needsComma = true;
         }
-        (type as TypeImpl).appendTo(buffer);
+        (type as TypeImpl).appendTo(buffer, visitedTypes);
       }
     }
     if (optionalParameterTypes.length > 0) {
       if (needsComma) {
         buffer.write(", ");
         needsComma = false;
       }
       buffer.write("[");
       for (DartType type in optionalParameterTypes) {
         if (needsComma) {
           buffer.write(", ");
         } else {
           needsComma = true;
         }
-        (type as TypeImpl).appendTo(buffer);
+        (type as TypeImpl).appendTo(buffer, visitedTypes);
       }
       buffer.write("]");
       needsComma = true;
     }
     if (namedParameterTypes.length > 0) {
       if (needsComma) {
         buffer.write(", ");
         needsComma = false;
       }
       buffer.write("{");
       namedParameterTypes.forEach((String name, DartType type) {
         if (needsComma) {
           buffer.write(", ");
         } else {
           needsComma = true;
         }
         buffer.write(name);
         buffer.write(": ");
-        (type as TypeImpl).appendTo(buffer);
+        (type as TypeImpl).appendTo(buffer, visitedTypes);
       });
       buffer.write("}");
       needsComma = true;
     }
     buffer.write(")");
     buffer.write(Element.RIGHT_ARROW);
     if (returnType == null) {
       buffer.write("null");
     } else {
-      (returnType as TypeImpl).appendTo(buffer);
+      (returnType as TypeImpl).appendTo(buffer, visitedTypes);
     }
   }
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) {
     if (object is! FunctionTypeImpl) {
       return false;
     }
     FunctionTypeImpl otherType = object as FunctionTypeImpl;
     // If the visitedTypePairs already has the pair (this, type),
@@ skipping 1242 matching lines @@
   @override
   int get hashCode {
     ClassElement element = this.element;
     if (element == null) {
       return 0;
     }
     return element.hashCode;
   }
 
   @override
+  int internalHashCode(List<DartType> visitedTypes) => hashCode;
+
+  @override
   List<InterfaceType> get interfaces {
     ClassElement classElement = element;
     List<InterfaceType> interfaces = classElement.interfaces;
     List<TypeParameterElement> typeParameters = classElement.typeParameters;
     List<DartType> parameterTypes = classElement.type.typeArguments;
     if (typeParameters.length == 0) {
       return interfaces;
     }
     int count = interfaces.length;
     List<InterfaceType> typedInterfaces = new List<InterfaceType>(count);
@@ skipping 59 matching lines @@
   }
 
   @override
   List<TypeParameterElement> get typeParameters => element.typeParameters;
 
   @override
   bool operator ==(Object object) =>
       internalEquals(object, new HashSet<ElementPair>());
 
   @override
-  void appendTo(StringBuffer buffer) {
+  void appendTo(StringBuffer buffer, Set<DartType> visitedTypes) {
+    if (!visitedTypes.add(this)) {
+      buffer.write(name == null ? '...' : name);
+      return;
+    }
     buffer.write(name);
     int argumentCount = typeArguments.length;
     if (argumentCount > 0) {
       buffer.write("<");
       for (int i = 0; i < argumentCount; i++) {
         if (i > 0) {
           buffer.write(", ");
         }
-        (typeArguments[i] as TypeImpl).appendTo(buffer);
+        (typeArguments[i] as TypeImpl).appendTo(buffer, visitedTypes);
       }
       buffer.write(">");
     }
   }
 
   @override
   PropertyAccessorElement getGetter(String getterName) =>
       PropertyAccessorMember.from(
           (element as ClassElementImpl).getGetter(getterName),
           this);
@@ skipping 3620 matching lines @@
   @override
   bool get isObject => false;
 
   @override
   bool get isUndefined => false;
 
   @override
   bool get isVoid => false;
 
   /**
-   * Append a textual representation of this type to the given [buffer].
+   * Append a textual representation of this type to the given [buffer]. The set
+   * of [visitedTypes] is used to prevent infinite recusion.
    */
-  void appendTo(StringBuffer buffer) {
+  void appendTo(StringBuffer buffer, Set<DartType> visitedTypes) {
+    if (!visitedTypes.add(this)) {
+      buffer.write(name == null ? '...' : name);
+      return;
+    }
     if (name == null) {
       buffer.write("<unnamed type>");
     } else {
       buffer.write(name);
     }
   }
 
   @override
   DartType getLeastUpperBound(DartType type) => null;
 
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs);
 
+  int internalHashCode(List<DartType> visitedTypes);
+
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic,
       Set<TypeImpl_TypePair> visitedTypePairs);
 
   bool internalIsSubtypeOf(DartType type,
       Set<TypeImpl_TypePair> visitedTypePairs);
 
   @override
   bool isAssignableTo(DartType type) =>
       isAssignableTo2(type, new HashSet<TypeImpl_TypePair>());
 
@@ skipping 107 matching lines @@
     visitedTypePairs.remove(typePair);
     return result;
   }
 
   @override
   bool isSupertypeOf(DartType type) => type.isSubtypeOf(this);
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
-    appendTo(buffer);
+    appendTo(buffer, new HashSet<DartType>());
     return buffer.toString();
   }
 
   /**
    * Return `true` if corresponding elements of the [first] and [second] lists
    * of type arguments are all equal. Use the set of [visitedElementPairs] to
    * prevent infinite loops when the types are recursively defined.
    */
   static bool equalArrays(List<DartType> first, List<DartType> second,
       Set<ElementPair> visitedElementPairs) {
@@ skipping 198 matching lines @@
 
   @override
   bool operator ==(Object object) =>
       object is TypeParameterTypeImpl && (element == object.element);
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) =>
       this == object;
 
   @override
+  int internalHashCode(List<DartType> visitedTypes) => hashCode;
+
+  @override
   bool internalIsMoreSpecificThan(DartType s, bool withDynamic,
       Set<TypeImpl_TypePair> visitedTypePairs) {
     //
     // A type T is more specific than a type S, written T << S,
     // if one of the following conditions is met:
     //
     // Reflexivity: T is S.
     //
     if (this == s) {
       return true;
@@ skipping 137 matching lines @@
   bool get isUndefined => true;
 
   @override
   bool operator ==(Object object) => identical(object, this);
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) =>
       identical(object, this);
 
   @override
+  int internalHashCode(List<DartType> visitedTypes) => hashCode;
+
+  @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic,
       Set<TypeImpl_TypePair> visitedTypePairs) {
     // T is S
     if (identical(this, type)) {
       return true;
     }
     // else
     return withDynamic;
   }
 
@@ skipping 60 matching lines @@
     return buffer.toString();
   }
 
   @override
   Set<DartType> get elements => _types;
 
   @override
   int get hashCode => _types.hashCode;
 
   @override
+  int internalHashCode(List<DartType> visitedTypes) => hashCode;
+
+  @override
   bool operator ==(Object other) {
     if (other == null || other is! UnionType) {
       return false;
     } else if (identical(this, other)) {
       return true;
     } else {
       return javaSetEquals(_types, (other as UnionType).elements);
     }
   }
 
   @override
-  void appendTo(StringBuffer buffer) {
+  void appendTo(StringBuffer buffer, Set<DartType> visitedTypes) {
+    if (!visitedTypes.add(this)) {
+      buffer.write(name == null ? '...' : name);
+      return;
+    }
     String prefix = "{";
     for (DartType type in _types) {
       buffer.write(prefix);
-      (type as TypeImpl).appendTo(buffer);
+      (type as TypeImpl).appendTo(buffer, visitedTypes);
       prefix = ",";
     }
     buffer.write("}");
   }
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) =>
       this == object;
 
   @override
@@ skipping 468 matching lines @@
 
   /**
    * Prevent the creation of instances of this class.
    */
   VoidTypeImpl() : super(null, Keyword.VOID.syntax);
 
   @override
   int get hashCode => 2;
 
   @override
+  int internalHashCode(List<DartType> visitedTypes) => hashCode;
+
+  @override
   bool get isVoid => true;
 
   @override
   bool operator ==(Object object) => identical(object, this);
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) =>
       identical(object, this);
 
   @override
@@ skipping 14 matching lines @@
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 
   @override
   VoidTypeImpl substitute2(List<DartType> argumentTypes,
       List<DartType> parameterTypes) =>
       this;
 }