New analyzer snapshot.

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

 // 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';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'utilities_collection.dart';
 import 'source.dart';
@@ skipping 164 matching lines @@
   /**
    * Return `true` if this class is abstract. A class is abstract if it has an explicit
    * `abstract` modifier. Note, that this definition of <i>abstract</i> is different from
    * <i>has unimplemented members</i>.
    *
    * @return `true` if this class is abstract
    */
   bool get isAbstract;
 
   /**
+   * Return `true` if this element has an annotation of the form '@proxy'.
+   *
+   * @return `true` if this element defines a proxy
+   */
+  bool get isProxy;
+
+  /**
    * Return `true` if this class is defined by a typedef construct.
    *
    * @return `true` if this class is defined by a typedef construct
    */
   bool get isTypedef;
 
   /**
    * Return `true` if this class can validly be used as a mixin when defining another class.
    * The behavior of this method is defined by the Dart Language Specification in section 9:
    * <blockquote>It is a compile-time error if a declared or derived mixin refers to super. It is a
@@ skipping 206 matching lines @@
  *
  *
  * Second, there are elements in the element model that do not have a name. These correspond to
  * unnamed functions and exist in order to more accurately represent the semantic structure of the
  * program.
  *
  * @coverage dart.engine.element
  */
 abstract class Element {
   /**
+   * An Unicode right arrow.
+   */
+  static final String RIGHT_ARROW = " \u2192 ";
+
+  /**
    * A comparator that can be used to sort elements by their name offset. Elements with a smaller
    * offset will be sorted to be before elements with a larger name offset.
    */
   static final Comparator<Element> SORT_BY_OFFSET = (Element firstElement, Element secondElement) => firstElement.nameOffset - secondElement.nameOffset;
 
   /**
    * Use the given visitor to visit this element.
    *
    * @param visitor the visitor that will visit this element
    * @return the value returned by the visitor as a result of visiting this element
@@ skipping 146 matching lines @@
  * @coverage dart.engine.element
  */
 abstract class ElementAnnotation {
   /**
    * Return the element representing the field, variable, or const constructor being used as an
    * annotation.
    *
    * @return the field, variable, or constructor being used as an annotation
    */
   Element get element;
+
+  /**
+   * Return `true` if this annotation marks the associated element as being deprecated.
+   *
+   * @return `true` if this annotation marks the associated element as being deprecated
+   */
+  bool get isDeprecated;
+
+  /**
+   * Return `true` if this annotation marks the associated method as being expected to
+   * override an inherited method.
+   *
+   * @return `true` if this annotation marks the associated method as overriding another
+   *         method
+   */
+  bool get isOverride;
+
+  /**
+   * Return `true` if this annotation marks the associated class as implementing a proxy
+   * object.
+   *
+   * @return `true` if this annotation marks the associated class as implementing a proxy
+   *         object
+   */
+  bool get isProxy;
 }
 
 /**
  * The enumeration `ElementKind` defines the various kinds of elements in the element model.
  *
  * @coverage dart.engine.element
  */
 class ElementKind extends Enum<ElementKind> {
   static final ElementKind CLASS = new ElementKind('CLASS', 0, "class");
 
@@ skipping 1508 matching lines @@
     }
     return null;
   }
 
   bool hasNonFinalField() {
     List<ClassElement> classesToVisit = new List<ClassElement>();
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     classesToVisit.add(this);
     while (!classesToVisit.isEmpty) {
       ClassElement currentElement = classesToVisit.removeAt(0);
-      if (javaSetAdd(visitedClasses, currentElement)) {
+      if (visitedClasses.add(currentElement)) {
         for (FieldElement field in currentElement.fields) {
           if (!field.isFinal && !field.isConst && !field.isStatic && !field.isSynthetic) {
             return true;
           }
         }
         for (InterfaceType mixinType in currentElement.mixins) {
           ClassElement mixinElement = mixinType.element;
           classesToVisit.add(mixinElement);
         }
         InterfaceType supertype = currentElement.supertype;
         if (supertype != null) {
           ClassElement superElement = supertype.element;
           if (superElement != null) {
             classesToVisit.add(superElement);
           }
         }
       }
     }
     return false;
   }
 
   bool hasReferenceToSuper() => hasModifier(Modifier.REFERENCES_SUPER);
 
   bool get isAbstract => hasModifier(Modifier.ABSTRACT);
 
+  bool get isProxy {
+    for (ElementAnnotation annotation in metadata) {
+      if (annotation.isProxy) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   bool get isTypedef => hasModifier(Modifier.TYPEDEF);
 
   bool get isValidMixin => hasModifier(Modifier.MIXIN);
 
   PropertyAccessorElement lookUpGetter(String getterName, LibraryElement library) {
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     ClassElement currentElement = this;
     while (currentElement != null && !visitedClasses.contains(currentElement)) {
-      javaSetAdd(visitedClasses, currentElement);
+      visitedClasses.add(currentElement);
       PropertyAccessorElement element = currentElement.getGetter(getterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
       for (InterfaceType mixin in currentElement.mixins) {
         ClassElement mixinElement = mixin.element;
         if (mixinElement != null) {
           element = mixinElement.getGetter(getterName);
           if (element != null && element.isAccessibleIn(library)) {
             return element;
           }
         }
       }
       InterfaceType supertype = currentElement.supertype;
       if (supertype == null) {
         return null;
       }
       currentElement = supertype.element;
     }
     return null;
   }
 
   MethodElement lookUpMethod(String methodName, LibraryElement library) {
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     ClassElement currentElement = this;
     while (currentElement != null && !visitedClasses.contains(currentElement)) {
-      javaSetAdd(visitedClasses, currentElement);
+      visitedClasses.add(currentElement);
       MethodElement element = currentElement.getMethod(methodName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
       for (InterfaceType mixin in currentElement.mixins) {
         ClassElement mixinElement = mixin.element;
         if (mixinElement != null) {
           element = mixinElement.getMethod(methodName);
           if (element != null && element.isAccessibleIn(library)) {
             return element;
           }
         }
       }
       InterfaceType supertype = currentElement.supertype;
       if (supertype == null) {
         return null;
       }
       currentElement = supertype.element;
     }
     return null;
   }
 
   PropertyAccessorElement lookUpSetter(String setterName, LibraryElement library) {
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     ClassElement currentElement = this;
     while (currentElement != null && !visitedClasses.contains(currentElement)) {
-      javaSetAdd(visitedClasses, currentElement);
+      visitedClasses.add(currentElement);
       PropertyAccessorElement element = currentElement.getSetter(setterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
       for (InterfaceType mixin in currentElement.mixins) {
         ClassElement mixinElement = mixin.element;
         if (mixinElement != null) {
           element = mixinElement.getSetter(setterName);
           if (element != null && element.isAccessibleIn(library)) {
             return element;
@@ skipping 675 matching lines @@
    * The element representing the field, variable, or constructor being used as an annotation.
    */
   Element _element;
 
   /**
    * An empty array of annotations.
    */
   static List<ElementAnnotationImpl> EMPTY_ARRAY = new List<ElementAnnotationImpl>(0);
 
   /**
+   * The name of the class used to mark an element as being deprecated.
+   */
+  static String _DEPRECATED_CLASS_NAME = "Deprecated";
+
+  /**
+   * The name of the top-level variable used to mark an element as being deprecated.
+   */
+  static String _DEPRECATED_VARIABLE_NAME = "deprecated";
+
+  /**
+   * The name of the top-level variable used to mark a method as being expected to override an
+   * inherited method.
+   */
+  static String _OVERRIDE_VARIABLE_NAME = "override";
+
+  /**
+   * The name of the top-level variable used to mark a class as implementing a proxy object.
+   */
+  static String _PROXY_VARIABLE_NAME = "proxy";
+
+  /**
    * Initialize a newly created annotation.
    *
    * @param element the element representing the field, variable, or constructor being used as an
    *          annotation
    */
   ElementAnnotationImpl(Element element) {
     this._element = element;
   }
 
   Element get element => _element;
 
+  bool get isDeprecated {
+    if (_element != null) {
+      LibraryElement library = _element.library;
+      if (library != null && library.isDartCore) {
+        if (_element is ConstructorElement) {
+          ConstructorElement constructorElement = _element as ConstructorElement;
+          if (constructorElement.enclosingElement.name == _DEPRECATED_CLASS_NAME) {
+            return true;
+          }
+        } else if (_element is PropertyAccessorElement && _element.name == _DEPRECATED_VARIABLE_NAME) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  bool get isOverride {
+    if (_element != null) {
+      LibraryElement library = _element.library;
+      if (library != null && library.isDartCore) {
+        if (_element is PropertyAccessorElement && _element.name == _OVERRIDE_VARIABLE_NAME) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  bool get isProxy {
+    if (_element != null) {
+      LibraryElement library = _element.library;
+      if (library != null && library.isDartCore) {
+        if (_element is PropertyAccessorElement && _element.name == _PROXY_VARIABLE_NAME) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
   String toString() => "@${_element.toString()}";
 }
 
 /**
  * The abstract class `ElementImpl` implements the behavior common to objects that implement
  * an [Element].
  *
  * @coverage dart.engine.element
  */
 abstract class ElementImpl implements Element {
@@ skipping 120 matching lines @@
 
   bool isAccessibleIn(LibraryElement library) {
     if (Identifier.isPrivateName(_name)) {
       return library == this.library;
     }
     return true;
   }
 
   bool get isDeprecated {
     for (ElementAnnotation annotation in _metadata) {
-      Element element = annotation.element;
-      if (element != null) {
-        LibraryElement lib = element.library;
-        if (lib != null && lib.isDartCore) {
-          if (element is ConstructorElement) {
-            ConstructorElement constructorElement = element as ConstructorElement;
-            if (constructorElement.enclosingElement.name == "Deprecated") {
-              return true;
-            }
-          } else if (element is PropertyAccessorElement && element.name == "deprecated") {
-            return true;
-          }
-        }
+      if (annotation.isDeprecated) {
+        return true;
       }
     }
     return false;
   }
 
   bool get isSynthetic => hasModifier(Modifier.SYNTHETIC);
 
   /**
    * Set the metadata associate with this element to the given array of annotations.
    *
@@ skipping 508 matching lines @@
     builder.append("(");
     int parameterCount = _parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
         builder.append(", ");
       }
       (_parameters[i] as ParameterElementImpl).appendTo(builder);
     }
     builder.append(")");
     if (_type != null) {
-      builder.append(" -> ");
+      builder.append(Element.RIGHT_ARROW);
       builder.append(_type.returnType);
     }
   }
 }
 
 /**
  * Instances of the class `ExportElementImpl` implement an [ExportElement].
  *
  * @coverage dart.engine.element
  */
@@ skipping 220 matching lines @@
    * Initialize a newly created function element to have no name and the given offset. This is used
    * for function expressions, which have no name.
    *
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   FunctionElementImpl.con2(int nameOffset) : super.con2("", nameOffset);
 
   accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
 
+  /**
+   * Treating the set of arrays defined in [ExecutableElementImpl] as one long array, this
+   * returns the index position of the passed child in this [FunctionElement]. This gives a
+   * unique integer for each element, this is provided primarily for function elements that do not
+   * have a name (closures), which cannot use [Element#getNameOffset]. If there is no such
+   * element, `-1` is returned.
+   *
+   * @param element the element to find and return an integer for, if there is no such element,
+   *          `-1` is returned
+   */
+  int getIndexPosition(Element element) {
+    List<FunctionElement> functions = this.functions;
+    List<LabelElement> labels = this.labels;
+    List<LocalVariableElement> localVariables = this.localVariables;
+    List<ParameterElement> parameters = this.parameters;
+    int count = 0;
+    for (int i = 0; i < functions.length; i++, count++) {
+      if (identical(element, functions[i])) {
+        return count;
+      }
+    }
+    for (int i = 0; i < labels.length; i++, count++) {
+      if (identical(element, labels[i])) {
+        return count;
+      }
+    }
+    for (int i = 0; i < localVariables.length; i++, count++) {
+      if (identical(element, localVariables[i])) {
+        return count;
+      }
+    }
+    for (int i = 0; i < parameters.length; i++, count++) {
+      if (identical(element, parameters[i])) {
+        return count;
+      }
+    }
+    return -1;
+  }
+
   ElementKind get kind => ElementKind.FUNCTION;
 
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   bool get isStatic => enclosingElement is CompilationUnitElement;
@@ skipping 178 matching lines @@
     builder.append("(");
     int parameterCount = _parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
         builder.append(", ");
       }
       (_parameters[i] as ParameterElementImpl).appendTo(builder);
     }
     builder.append(")");
     if (_type != null) {
-      builder.append(" -> ");
+      builder.append(Element.RIGHT_ARROW);
       builder.append(_type.returnType);
     }
   }
 }
 
 /**
  * Instances of the class `HideElementCombinatorImpl` implement a
  * [HideElementCombinator].
  *
  * @coverage dart.engine.element
@@ skipping 333 matching lines @@
 
   /**
    * Determine if the given library is up to date with respect to the given time stamp.
    *
    * @param library the library to process
    * @param timeStamp the time stamp to check against
    * @param visitedLibraries the set of visited libraries
    */
   static bool isUpToDate(LibraryElement library, int timeStamp, Set<LibraryElement> visitedLibraries) {
     if (!visitedLibraries.contains(library)) {
-      javaSetAdd(visitedLibraries, library);
+      visitedLibraries.add(library);
       if (timeStamp < library.definingCompilationUnit.source.modificationStamp) {
         return false;
       }
       for (CompilationUnitElement element in library.parts) {
         if (timeStamp < element.source.modificationStamp) {
           return false;
         }
       }
       for (LibraryElement importedLibrary in library.importedLibraries) {
         if (!isUpToDate(importedLibrary, timeStamp, visitedLibraries)) {
@@ skipping 80 matching lines @@
 
   CompilationUnitElement get definingCompilationUnit => _definingCompilationUnit;
 
   FunctionElement get entryPoint => _entryPoint;
 
   List<LibraryElement> get exportedLibraries {
     Set<LibraryElement> libraries = new Set<LibraryElement>();
     for (ExportElement element in _exports) {
       LibraryElement library = element.exportedLibrary;
       if (library != null) {
-        javaSetAdd(libraries, library);
+        libraries.add(library);
       }
     }
     return new List.from(libraries);
   }
 
   List<ExportElement> get exports => _exports;
 
   List<LibraryElement> get importedLibraries {
     Set<LibraryElement> libraries = new Set<LibraryElement>();
     for (ImportElement element in _imports) {
       LibraryElement library = element.importedLibrary;
       if (library != null) {
-        javaSetAdd(libraries, library);
+        libraries.add(library);
       }
     }
     return new List.from(libraries);
   }
 
   List<ImportElement> get imports => _imports;
 
   ElementKind get kind => ElementKind.LIBRARY;
 
   LibraryElement get library => this;
 
   List<CompilationUnitElement> get parts => _parts;
 
   List<PrefixElement> get prefixes {
     Set<PrefixElement> prefixes = new Set<PrefixElement>();
     for (ImportElement element in _imports) {
       PrefixElement prefix = element.prefix;
       if (prefix != null) {
-        javaSetAdd(prefixes, prefix);
+        prefixes.add(prefix);
       }
     }
     return new List.from(prefixes);
   }
 
   Source get source {
     if (_definingCompilationUnit == null) {
       return null;
     }
     return _definingCompilationUnit.source;
@@ skipping 371 matching lines @@
   /**
    * Add the given element to the list of elements. If the element is a multiply-defined element,
    * add all of the conflicting elements that it represents.
    *
    * @param elements the list to which the element(s) are to be added
    * @param element the element(s) to be added
    */
   static void add(Set<Element> elements, Element element) {
     if (element is MultiplyDefinedElementImpl) {
       for (Element conflictingElement in (element as MultiplyDefinedElementImpl)._conflictingElements) {
-        javaSetAdd(elements, conflictingElement);
+        elements.add(conflictingElement);
       }
     } else {
-      javaSetAdd(elements, element);
+      elements.add(element);
     }
   }
 
   /**
    * Use the given elements to construct an array of conflicting elements. If either of the given
    * elements are multiply-defined elements then the conflicting elements they represent will be
    * included in the array. Otherwise, the element itself will be included.
    *
    * @param firstElement the first element to be included
    * @param secondElement the second element to be included
@@ skipping 886 matching lines @@
     builder.append("(");
     int parameterCount = parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
         builder.append(", ");
       }
       builder.append(parameters[i]).toString();
     }
     builder.append(")");
     if (type != null) {
-      builder.append(" -> ");
+      builder.append(Element.RIGHT_ARROW);
       builder.append(type.returnType);
     }
     return builder.toString();
   }
 
   InterfaceType get definingType => super.definingType as InterfaceType;
 }
 
 /**
  * The abstract class `ExecutableMember` defines the behavior common to members that represent
@@ skipping 46 matching lines @@
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(baseElement.functions, visitor);
     safelyVisitChildren(labels, visitor);
     safelyVisitChildren(baseElement.localVariables, visitor);
     safelyVisitChildren(parameters, visitor);
   }
 }
 
 /**
+ * Instances of the class `FieldFormalParameterMember` represent a parameter element defined
+ * in a parameterized type where the values of the type parameters are known.
+ */
+class FieldFormalParameterMember extends ParameterMember implements FieldFormalParameterElement {
+  /**
+   * Initialize a newly created element to represent a parameter of the given parameterized type.
+   *
+   * @param baseElement the element on which the parameterized element was created
+   * @param definingType the type in which the element is defined
+   */
+  FieldFormalParameterMember(FieldFormalParameterElement baseElement, ParameterizedType definingType) : super(baseElement, definingType);
+
+  accept(ElementVisitor visitor) => visitor.visitFieldFormalParameterElement(this);
+
+  FieldElement get field => (baseElement as FieldFormalParameterElement).field;
+}
+
+/**
  * Instances of the class `FieldMember` represent a field element defined in a parameterized
  * type where the values of the type parameters are known.
  */
 class FieldMember extends VariableMember implements FieldElement {
   /**
    * If the given field's type is different when any type parameters from the defining type's
    * declaration are replaced with the actual type arguments from the defining type, create a field
    * member representing the given field. Return the member that was created, or the base field if
    * no member was created.
    *
@@ skipping 226 matching lines @@
     builder.append("(");
     int parameterCount = parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
         builder.append(", ");
       }
       builder.append(parameters[i]).toString();
     }
     builder.append(")");
     if (type != null) {
-      builder.append(" -> ");
+      builder.append(Element.RIGHT_ARROW);
       builder.append(type.returnType);
     }
     return builder.toString();
   }
 }
 
 /**
  * Instances of the class `ParameterMember` represent a parameter element defined in a
  * parameterized type where the values of the type parameters are known.
  */
 class ParameterMember extends VariableMember implements ParameterElement {
   /**
    * If the given parameter's type is different when any type parameters from the defining type's
    * declaration are replaced with the actual type arguments from the defining type, create a
    * parameter member representing the given parameter. Return the member that was created, or the
    * base parameter if no member was created.
    *
    * @param baseParameter the base parameter for which a member might be created
    * @param definingType the type defining the parameters and arguments to be used in the
    *          substitution
    * @return the parameter element that will return the correctly substituted types
    */
   static ParameterElement from(ParameterElement baseParameter, ParameterizedType definingType) {
     if (baseParameter == null || definingType.typeArguments.length == 0) {
       return baseParameter;
     }
-    if (baseParameter is! FieldFormalParameterElement) {
+    bool isFieldFormal = baseParameter is FieldFormalParameterElement;
+    if (!isFieldFormal) {
       Type2 baseType = baseParameter.type;
       List<Type2> argumentTypes = definingType.typeArguments;
       List<Type2> parameterTypes = TypeParameterTypeImpl.getTypes(definingType.typeParameters);
       Type2 substitutedType = baseType.substitute2(argumentTypes, parameterTypes);
       if (baseType == substitutedType) {
         return baseParameter;
       }
     }
+    if (isFieldFormal) {
+      return new FieldFormalParameterMember(baseParameter as FieldFormalParameterElement, definingType);
+    }
     return new ParameterMember(baseParameter, definingType);
   }
 
   /**
    * Initialize a newly created element to represent a parameter of the given parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   ParameterMember(ParameterElement baseElement, ParameterizedType definingType) : super(baseElement, definingType);
@@ skipping 149 matching lines @@
     builder.append("(");
     int parameterCount = parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
         builder.append(", ");
       }
       builder.append(parameters[i]).toString();
     }
     builder.append(")");
     if (type != null) {
-      builder.append(" -> ");
+      builder.append(Element.RIGHT_ARROW);
       builder.append(type.returnType);
     }
     return builder.toString();
   }
 
   InterfaceType get definingType => super.definingType as InterfaceType;
 }
 
 /**
  * The abstract class `VariableMember` defines the behavior common to members that represent a
@@ skipping 41 matching lines @@
 
   /**
    * Prevent the creation of instances of this class.
    */
   BottomTypeImpl() : super(null, "<bottom>");
 
   bool operator ==(Object object) => identical(object, this);
 
   bool get isBottom => true;
 
-  bool isMoreSpecificThan3(Type2 type, bool withDynamic) => true;
-
-  bool isSubtypeOf(Type2 type) => true;
-
   bool isSupertypeOf(Type2 type) => false;
 
   BottomTypeImpl substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) => this;
+
+  bool internalIsMoreSpecificThan(Type2 type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) => true;
+
+  bool internalIsSubtypeOf(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) => true;
 }
 
 /**
  * The unique instance of the class `DynamicTypeImpl` implements the type `dynamic`.
  *
  * @coverage dart.engine.type
  */
 class DynamicTypeImpl extends TypeImpl {
   /**
    * The unique instance of this class.
    */
   static final DynamicTypeImpl instance = new DynamicTypeImpl();
 
   /**
    * Prevent the creation of instances of this class.
    */
   DynamicTypeImpl() : super(new DynamicElementImpl(), Keyword.DYNAMIC.syntax) {
     (element as DynamicElementImpl).type = this;
   }
 
   bool operator ==(Object object) => object is DynamicTypeImpl;
 
   bool get isDynamic => true;
 
-  bool isMoreSpecificThan3(Type2 type, bool withDynamic) {
-    if (identical(this, type)) {
-      return true;
-    }
-    return withDynamic;
-  }
-
-  bool isSubtypeOf(Type2 type) => true;
-
   bool isSupertypeOf(Type2 type) => true;
 
   Type2 substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) {
     int length = parameterTypes.length;
     for (int i = 0; i < length; i++) {
       if (parameterTypes[i] == this) {
         return argumentTypes[i];
       }
     }
     return this;
   }
+
+  bool internalIsMoreSpecificThan(Type2 type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
+    if (identical(this, type)) {
+      return true;
+    }
+    return withDynamic;
+  }
+
+  bool internalIsSubtypeOf(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) => true;
 }
 
 /**
  * Instances of the class `FunctionTypeImpl` defines the behavior common to objects
  * representing the type of a function, method, constructor, getter, or setter.
  *
  * @coverage dart.engine.type
  */
 class FunctionTypeImpl extends TypeImpl implements FunctionType {
   /**
@@ skipping 100 matching lines @@
           } else {
             needsComma = true;
           }
           builder.append(entry.getKey());
           builder.append(": ");
           builder.append(entry.getValue().displayName);
         }
         builder.append("}");
         needsComma = true;
       }
-      builder.append(") -> ");
+      builder.append(")");
+      builder.append(Element.RIGHT_ARROW);
       if (returnType == null) {
         builder.append("null");
       } else {
         builder.append(returnType.displayName);
       }
       name = builder.toString();
     }
     return name;
   }
 
@@ skipping 78 matching lines @@
   }
 
   int get hashCode {
     Element element = this.element;
     if (element == null) {
       return 0;
     }
     return element.hashCode;
   }
 
-  bool isAssignableTo(Type2 type) => this.isSubtypeOf(type);
-
-  bool isMoreSpecificThan3(Type2 type, bool withDynamic) {
+  bool internalIsMoreSpecificThan(Type2 type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     if (type == null) {
       return false;
     } else if (identical(this, type) || type.isDynamic || type.isDartCoreFunction || type.isObject) {
       return true;
     } else if (type is! FunctionType) {
       return false;
     } else if (this == type) {
       return true;
     }
     FunctionType t = this;
     FunctionType s = type as FunctionType;
     List<Type2> tTypes = t.normalParameterTypes;
     List<Type2> tOpTypes = t.optionalParameterTypes;
     List<Type2> sTypes = s.normalParameterTypes;
     List<Type2> sOpTypes = s.optionalParameterTypes;
     if ((sOpTypes.length > 0 && t.namedParameterTypes.length > 0) || (tOpTypes.length > 0 && s.namedParameterTypes.length > 0)) {
       return false;
     }
     if (t.namedParameterTypes.length > 0) {
       if (t.normalParameterTypes.length != s.normalParameterTypes.length) {
         return false;
       } else if (t.normalParameterTypes.length > 0) {
         for (int i = 0; i < tTypes.length; i++) {
-          if (!tTypes[i].isMoreSpecificThan3(sTypes[i], withDynamic)) {
+          if (!(tTypes[i] as TypeImpl).isMoreSpecificThan3(sTypes[i], withDynamic, visitedTypePairs)) {
             return false;
           }
         }
       }
       Map<String, Type2> namedTypesT = t.namedParameterTypes;
       Map<String, Type2> namedTypesS = s.namedParameterTypes;
       if (namedTypesT.length < namedTypesS.length) {
         return false;
       }
       JavaIterator<MapEntry<String, Type2>> iteratorS = new JavaIterator(getMapEntrySet(namedTypesS));
       while (iteratorS.hasNext) {
         MapEntry<String, Type2> entryS = iteratorS.next();
         Type2 typeT = namedTypesT[entryS.getKey()];
         if (typeT == null) {
           return false;
         }
-        if (!typeT.isMoreSpecificThan3(entryS.getValue(), withDynamic)) {
+        if (!(typeT as TypeImpl).isMoreSpecificThan3(entryS.getValue(), withDynamic, visitedTypePairs)) {
           return false;
         }
       }
     } else if (s.namedParameterTypes.length > 0) {
       return false;
     } else {
       int tArgLength = tTypes.length + tOpTypes.length;
       int sArgLength = sTypes.length + sOpTypes.length;
       if (tArgLength < sArgLength || sTypes.length < tTypes.length) {
         return false;
       }
       if (tOpTypes.length == 0 && sOpTypes.length == 0) {
         for (int i = 0; i < sTypes.length; i++) {
-          if (!tTypes[i].isMoreSpecificThan3(sTypes[i], withDynamic)) {
+          if (!(tTypes[i] as TypeImpl).isMoreSpecificThan3(sTypes[i], withDynamic, visitedTypePairs)) {
             return false;
           }
         }
       } else {
         List<Type2> tAllTypes = new List<Type2>(sArgLength);
         for (int i = 0; i < tTypes.length; i++) {
           tAllTypes[i] = tTypes[i];
         }
         for (int i = tTypes.length, j = 0; i < sArgLength; i++, j++) {
           tAllTypes[i] = tOpTypes[j];
         }
         List<Type2> sAllTypes = new List<Type2>(sArgLength);
         for (int i = 0; i < sTypes.length; i++) {
           sAllTypes[i] = sTypes[i];
         }
         for (int i = sTypes.length, j = 0; i < sArgLength; i++, j++) {
           sAllTypes[i] = sOpTypes[j];
         }
         for (int i = 0; i < sAllTypes.length; i++) {
-          if (!tAllTypes[i].isMoreSpecificThan3(sAllTypes[i], withDynamic)) {
+          if (!(tAllTypes[i] as TypeImpl).isMoreSpecificThan3(sAllTypes[i], withDynamic, visitedTypePairs)) {
             return false;
           }
         }
       }
     }
     Type2 tRetType = t.returnType;
     Type2 sRetType = s.returnType;
-    return sRetType.isVoid || tRetType.isMoreSpecificThan3(sRetType, withDynamic);
+    return sRetType.isVoid || (tRetType as TypeImpl).isMoreSpecificThan3(sRetType, withDynamic, visitedTypePairs);
   }
 
-  bool isSubtypeOf(Type2 type) {
-    if (type == null) {
-      return false;
-    } else if (identical(this, type) || type.isDynamic || type.isDartCoreFunction || type.isObject) {
-      return true;
-    } else if (type is! FunctionType) {
-      return false;
-    } else if (this == type) {
-      return true;
-    }
-    FunctionType t = this;
-    FunctionType s = type as FunctionType;
-    List<Type2> tTypes = t.normalParameterTypes;
-    List<Type2> tOpTypes = t.optionalParameterTypes;
-    List<Type2> sTypes = s.normalParameterTypes;
-    List<Type2> sOpTypes = s.optionalParameterTypes;
-    if ((sOpTypes.length > 0 && t.namedParameterTypes.length > 0) || (tOpTypes.length > 0 && s.namedParameterTypes.length > 0)) {
-      return false;
-    }
-    if (t.namedParameterTypes.length > 0) {
-      if (t.normalParameterTypes.length != s.normalParameterTypes.length) {
-        return false;
-      } else if (t.normalParameterTypes.length > 0) {
-        for (int i = 0; i < tTypes.length; i++) {
-          if (!tTypes[i].isAssignableTo(sTypes[i])) {
-            return false;
-          }
-        }
-      }
-      Map<String, Type2> namedTypesT = t.namedParameterTypes;
-      Map<String, Type2> namedTypesS = s.namedParameterTypes;
-      if (namedTypesT.length < namedTypesS.length) {
-        return false;
-      }
-      JavaIterator<MapEntry<String, Type2>> iteratorS = new JavaIterator(getMapEntrySet(namedTypesS));
-      while (iteratorS.hasNext) {
-        MapEntry<String, Type2> entryS = iteratorS.next();
-        Type2 typeT = namedTypesT[entryS.getKey()];
-        if (typeT == null) {
-          return false;
-        }
-        if (!typeT.isAssignableTo(entryS.getValue())) {
-          return false;
-        }
-      }
-    } else if (s.namedParameterTypes.length > 0) {
-      return false;
-    } else {
-      int tArgLength = tTypes.length + tOpTypes.length;
-      int sArgLength = sTypes.length + sOpTypes.length;
-      if (tArgLength < sArgLength || sTypes.length < tTypes.length) {
-        return false;
-      }
-      if (tOpTypes.length == 0 && sOpTypes.length == 0) {
-        for (int i = 0; i < sTypes.length; i++) {
-          if (!tTypes[i].isAssignableTo(sTypes[i])) {
-            return false;
-          }
-        }
-      } else {
-        List<Type2> tAllTypes = new List<Type2>(sArgLength);
-        for (int i = 0; i < tTypes.length; i++) {
-          tAllTypes[i] = tTypes[i];
-        }
-        for (int i = tTypes.length, j = 0; i < sArgLength; i++, j++) {
-          tAllTypes[i] = tOpTypes[j];
-        }
-        List<Type2> sAllTypes = new List<Type2>(sArgLength);
-        for (int i = 0; i < sTypes.length; i++) {
-          sAllTypes[i] = sTypes[i];
-        }
-        for (int i = sTypes.length, j = 0; i < sArgLength; i++, j++) {
-          sAllTypes[i] = sOpTypes[j];
-        }
-        for (int i = 0; i < sAllTypes.length; i++) {
-          if (!tAllTypes[i].isAssignableTo(sAllTypes[i])) {
-            return false;
-          }
-        }
-      }
-    }
-    Type2 tRetType = t.returnType;
-    Type2 sRetType = s.returnType;
-    return sRetType.isVoid || tRetType.isAssignableTo(sRetType);
-  }
+  bool isAssignableTo(Type2 type) => isSubtypeOf3(type, new Set<TypeImpl_TypePair>());
 
   /**
    * Set the actual types of the type arguments to the given types.
    *
    * @param typeArguments the actual types of the type arguments
    */
   void set typeArguments(List<Type2> typeArguments) {
     this._typeArguments = typeArguments;
   }
 
@@ skipping 58 matching lines @@
         } else {
           needsComma = true;
         }
         builder.append(entry.getKey());
         builder.append(": ");
         (entry.getValue() as TypeImpl).appendTo(builder);
       }
       builder.append("}");
       needsComma = true;
     }
-    builder.append(") -> ");
+    builder.append(")");
+    builder.append(Element.RIGHT_ARROW);
     if (returnType == null) {
       builder.append("null");
     } else {
       (returnType as TypeImpl).appendTo(builder);
     }
   }
 
   /**
    * @return the base parameter elements of this function element, not `null`.
    */
   List<ParameterElement> get baseParameters {
     Element element = this.element;
     if (element is ExecutableElement) {
       return (element as ExecutableElement).parameters;
     } else {
       return (element as FunctionTypeAliasElement).parameters;
     }
   }
 
+  bool internalIsSubtypeOf(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) {
+    if (type == null) {
+      return false;
+    } else if (identical(this, type) || type.isDynamic || type.isDartCoreFunction || type.isObject) {
+      return true;
+    } else if (type is! FunctionType) {
+      return false;
+    } else if (this == type) {
+      return true;
+    }
+    FunctionType t = this;
+    FunctionType s = type as FunctionType;
+    List<Type2> tTypes = t.normalParameterTypes;
+    List<Type2> tOpTypes = t.optionalParameterTypes;
+    List<Type2> sTypes = s.normalParameterTypes;
+    List<Type2> sOpTypes = s.optionalParameterTypes;
+    if ((sOpTypes.length > 0 && t.namedParameterTypes.length > 0) || (tOpTypes.length > 0 && s.namedParameterTypes.length > 0)) {
+      return false;
+    }
+    if (t.namedParameterTypes.length > 0) {
+      if (t.normalParameterTypes.length != s.normalParameterTypes.length) {
+        return false;
+      } else if (t.normalParameterTypes.length > 0) {
+        for (int i = 0; i < tTypes.length; i++) {
+          if (!(tTypes[i] as TypeImpl).isAssignableTo2(sTypes[i], visitedTypePairs)) {
+            return false;
+          }
+        }
+      }
+      Map<String, Type2> namedTypesT = t.namedParameterTypes;
+      Map<String, Type2> namedTypesS = s.namedParameterTypes;
+      if (namedTypesT.length < namedTypesS.length) {
+        return false;
+      }
+      JavaIterator<MapEntry<String, Type2>> iteratorS = new JavaIterator(getMapEntrySet(namedTypesS));
+      while (iteratorS.hasNext) {
+        MapEntry<String, Type2> entryS = iteratorS.next();
+        Type2 typeT = namedTypesT[entryS.getKey()];
+        if (typeT == null) {
+          return false;
+        }
+        if (!(typeT as TypeImpl).isAssignableTo2(entryS.getValue(), visitedTypePairs)) {
+          return false;
+        }
+      }
+    } else if (s.namedParameterTypes.length > 0) {
+      return false;
+    } else {
+      int tArgLength = tTypes.length + tOpTypes.length;
+      int sArgLength = sTypes.length + sOpTypes.length;
+      if (tArgLength < sArgLength || sTypes.length < tTypes.length) {
+        return false;
+      }
+      if (tOpTypes.length == 0 && sOpTypes.length == 0) {
+        for (int i = 0; i < sTypes.length; i++) {
+          if (!(tTypes[i] as TypeImpl).isAssignableTo2(sTypes[i], visitedTypePairs)) {
+            return false;
+          }
+        }
+      } else {
+        List<Type2> tAllTypes = new List<Type2>(sArgLength);
+        for (int i = 0; i < tTypes.length; i++) {
+          tAllTypes[i] = tTypes[i];
+        }
+        for (int i = tTypes.length, j = 0; i < sArgLength; i++, j++) {
+          tAllTypes[i] = tOpTypes[j];
+        }
+        List<Type2> sAllTypes = new List<Type2>(sArgLength);
+        for (int i = 0; i < sTypes.length; i++) {
+          sAllTypes[i] = sTypes[i];
+        }
+        for (int i = sTypes.length, j = 0; i < sArgLength; i++, j++) {
+          sAllTypes[i] = sOpTypes[j];
+        }
+        for (int i = 0; i < sAllTypes.length; i++) {
+          if (!(tAllTypes[i] as TypeImpl).isAssignableTo2(sAllTypes[i], visitedTypePairs)) {
+            return false;
+          }
+        }
+      }
+    }
+    Type2 tRetType = t.returnType;
+    Type2 sRetType = s.returnType;
+    return sRetType.isVoid || (tRetType as TypeImpl).isAssignableTo2(sRetType, visitedTypePairs);
+  }
+
   /**
    * Return the return type defined by this function's element.
    *
    * @return the return type defined by this function's element
    */
   Type2 get baseReturnType {
     Element element = this.element;
     if (element is ExecutableElement) {
       return (element as ExecutableElement).returnType;
     } else {
@@ skipping 47 matching lines @@
    * @see #computeLongestInheritancePathToObject(Type)
    * @see #getLeastUpperBound(Type)
    */
   static int computeLongestInheritancePathToObject2(InterfaceType type, int depth, Set<ClassElement> visitedClasses) {
     ClassElement classElement = type.element;
     if (classElement.supertype == null || visitedClasses.contains(classElement)) {
       return depth;
     }
     int longestPath = 1;
     try {
-      javaSetAdd(visitedClasses, classElement);
+      visitedClasses.add(classElement);
       List<InterfaceType> superinterfaces = classElement.interfaces;
       int pathLength;
       if (superinterfaces.length > 0) {
         for (InterfaceType superinterface in superinterfaces) {
           pathLength = computeLongestInheritancePathToObject2(superinterface, depth + 1, visitedClasses);
           if (pathLength > longestPath) {
             longestPath = pathLength;
           }
         }
       }
@@ skipping 17 matching lines @@
    * @return the [Set] of superinterfaces of the passed [Type]
    * @see #computeSuperinterfaceSet(Type)
    * @see #getLeastUpperBound(Type)
    */
   static Set<InterfaceType> computeSuperinterfaceSet2(InterfaceType type, Set<InterfaceType> set) {
     Element element = type.element;
     if (element != null && element is ClassElement) {
       ClassElement classElement = element as ClassElement;
       List<InterfaceType> superinterfaces = classElement.interfaces;
       for (InterfaceType superinterface in superinterfaces) {
-        if (javaSetAdd(set, superinterface)) {
+        if (set.add(superinterface)) {
           computeSuperinterfaceSet2(superinterface, set);
         }
       }
       InterfaceType supertype = classElement.supertype;
       if (supertype != null) {
-        if (javaSetAdd(set, supertype)) {
+        if (set.add(supertype)) {
           computeSuperinterfaceSet2(supertype, set);
         }
       }
     }
     return set;
   }
 
   /**
    * Return the intersection of the given sets of types, where intersection is based on the equality
    * of the elements of the types rather than on the equality of the types themselves. In cases
    * where two non-equal types have equal elements, which only happens when the class is
    * parameterized, the type that is added to the intersection is the base type with type arguments
    * that are the least upper bound of the type arguments of the two types.
    *
    * @param first the first set of types to be intersected
    * @param second the second set of types to be intersected
    * @return the intersection of the given sets of types
    */
   static List<InterfaceType> intersection(Set<InterfaceType> first, Set<InterfaceType> second) {
     Map<ClassElement, InterfaceType> firstMap = new Map<ClassElement, InterfaceType>();
     for (InterfaceType firstType in first) {
       firstMap[firstType.element] = firstType;
     }
     Set<InterfaceType> result = new Set<InterfaceType>();
     for (InterfaceType secondType in second) {
       InterfaceType firstType = firstMap[secondType.element];
       if (firstType != null) {
-        javaSetAdd(result, leastUpperBound(firstType, secondType));
+        result.add(leastUpperBound(firstType, secondType));
       }
     }
     return new List.from(result);
   }
 
   /**
    * Return the "least upper bound" of the given types under the assumption that the types have the
    * same element and differ only in terms of the type arguments. The resulting type is composed by
    * comparing the corresponding type arguments, keeping those that are the same, and using
    * 'dynamic' for those that are different.
@@ skipping 118 matching lines @@
     if (identical(this, dynamicType) || identical(type, dynamicType)) {
       return dynamicType;
     }
     if (type is! InterfaceType) {
       return null;
     }
     InterfaceType i = this;
     InterfaceType j = type as InterfaceType;
     Set<InterfaceType> si = computeSuperinterfaceSet(i);
     Set<InterfaceType> sj = computeSuperinterfaceSet(j);
-    javaSetAdd(si, i);
-    javaSetAdd(sj, j);
+    si.add(i);
+    sj.add(j);
     List<InterfaceType> s = intersection(si, sj);
     List<int> depths = new List<int>.filled(s.length, 0);
     int maxDepth = 0;
     for (int n = 0; n < s.length; n++) {
       depths[n] = computeLongestInheritancePathToObject(s[n]);
       if (depths[n] > maxDepth) {
         maxDepth = depths[n];
       }
     }
     for (; maxDepth >= 0; maxDepth--) {
@@ skipping 92 matching lines @@
     }
     for (InterfaceType mixinType in jElement.mixins) {
       mixinType = mixinType.substitute2(jArgs, jVars);
       if (mixinType == i) {
         return true;
       }
     }
     return false;
   }
 
-  bool isMoreSpecificThan3(Type2 type, bool withDynamic) {
-    if (identical(type, DynamicTypeImpl.instance)) {
-      return true;
-    } else if (type is! InterfaceType) {
-      return false;
-    }
-    return isMoreSpecificThan2(type as InterfaceType, new Set<ClassElement>(), withDynamic);
-  }
-
   bool get isObject => element.supertype == null;
 
-  bool isSubtypeOf(Type2 type) {
-    if (identical(type, DynamicTypeImpl.instance)) {
-      return true;
-    } else if (type is TypeParameterType) {
-      return true;
-    } else if (type is FunctionType) {
-      ClassElement element = this.element;
-      MethodElement callMethod = element.lookUpMethod("call", element.library);
-      if (callMethod != null) {
-        return callMethod.type.isSubtypeOf(type);
-      }
-      return false;
-    } else if (type is! InterfaceType) {
-      return false;
-    } else if (this == type) {
-      return true;
-    }
-    return isSubtypeOf2(type as InterfaceType, new Set<ClassElement>());
-  }
-
   ConstructorElement lookUpConstructor(String constructorName, LibraryElement library) {
     ConstructorElement constructorElement;
     if (constructorName == null) {
       constructorElement = element.unnamedConstructor;
     } else {
       constructorElement = element.getNamedConstructor(constructorName);
     }
     if (constructorElement == null || !constructorElement.isAccessibleIn(library)) {
       return null;
     }
@@ skipping 12 matching lines @@
     for (InterfaceType mixin in mixins) {
       PropertyAccessorElement element = mixin.getGetter(getterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     InterfaceType supertype = superclass;
     ClassElement supertypeElement = supertype == null ? null : supertype.element;
     while (supertype != null && !visitedClasses.contains(supertypeElement)) {
-      javaSetAdd(visitedClasses, supertypeElement);
+      visitedClasses.add(supertypeElement);
       PropertyAccessorElement element = supertype.getGetter(getterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
       for (InterfaceType mixin in supertype.mixins) {
         element = mixin.getGetter(getterName);
         if (element != null && element.isAccessibleIn(library)) {
           return element;
         }
       }
@@ skipping 15 matching lines @@
     for (InterfaceType mixin in mixins) {
       MethodElement element = mixin.getMethod(methodName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     InterfaceType supertype = superclass;
     ClassElement supertypeElement = supertype == null ? null : supertype.element;
     while (supertype != null && !visitedClasses.contains(supertypeElement)) {
-      javaSetAdd(visitedClasses, supertypeElement);
+      visitedClasses.add(supertypeElement);
       MethodElement element = supertype.getMethod(methodName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
       for (InterfaceType mixin in supertype.mixins) {
         element = mixin.getMethod(methodName);
         if (element != null && element.isAccessibleIn(library)) {
           return element;
         }
       }
@@ skipping 15 matching lines @@
     for (InterfaceType mixin in mixins) {
       PropertyAccessorElement element = mixin.getSetter(setterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     InterfaceType supertype = superclass;
     ClassElement supertypeElement = supertype == null ? null : supertype.element;
     while (supertype != null && !visitedClasses.contains(supertypeElement)) {
-      javaSetAdd(visitedClasses, supertypeElement);
+      visitedClasses.add(supertypeElement);
       PropertyAccessorElement element = supertype.getSetter(setterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
       for (InterfaceType mixin in supertype.mixins) {
         element = mixin.getSetter(setterName);
         if (element != null && element.isAccessibleIn(library)) {
           return element;
         }
       }
@@ skipping 38 matching lines @@
       for (int i = 0; i < argumentCount; i++) {
         if (i > 0) {
           builder.append(", ");
         }
         (_typeArguments[i] as TypeImpl).appendTo(builder);
       }
       builder.append(">");
     }
   }
 
-  bool isMoreSpecificThan2(InterfaceType s, Set<ClassElement> visitedClasses, bool withDynamic) {
+  bool internalIsMoreSpecificThan(Type2 type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
+    if (identical(type, DynamicTypeImpl.instance)) {
+      return true;
+    } else if (type is! InterfaceType) {
+      return false;
+    }
+    return isMoreSpecificThan2(type as InterfaceType, new Set<ClassElement>(), withDynamic, visitedTypePairs);
+  }
+
+  bool internalIsSubtypeOf(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) {
+    if (identical(type, DynamicTypeImpl.instance)) {
+      return true;
+    } else if (type is TypeParameterType) {
+      return true;
+    } else if (type is FunctionType) {
+      ClassElement element = this.element;
+      MethodElement callMethod = element.lookUpMethod("call", element.library);
+      if (callMethod != null) {
+        return callMethod.type.isSubtypeOf(type);
+      }
+      return false;
+    } else if (type is! InterfaceType) {
+      return false;
+    } else if (this == type) {
+      return true;
+    }
+    return isSubtypeOf2(type as InterfaceType, new Set<ClassElement>(), visitedTypePairs);
+  }
+
+  bool isMoreSpecificThan2(InterfaceType s, Set<ClassElement> visitedClasses, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     if (this == s) {
       return true;
     }
     if (s.isDirectSupertypeOf(this)) {
       return true;
     }
     ClassElement tElement = this.element;
     ClassElement sElement = s.element;
     if (tElement == sElement) {
       List<Type2> tArguments = typeArguments;
       List<Type2> sArguments = s.typeArguments;
       if (tArguments.length != sArguments.length) {
         return false;
       }
       for (int i = 0; i < tArguments.length; i++) {
-        if (!tArguments[i].isMoreSpecificThan3(sArguments[i], withDynamic)) {
+        if (!(tArguments[i] as TypeImpl).isMoreSpecificThan3(sArguments[i], withDynamic, visitedTypePairs)) {
           return false;
         }
       }
       return true;
     }
     ClassElement element = this.element;
     if (element == null || visitedClasses.contains(element)) {
       return false;
     }
-    javaSetAdd(visitedClasses, element);
+    visitedClasses.add(element);
     InterfaceType supertype = superclass;
-    if (supertype != null && (supertype as InterfaceTypeImpl).isMoreSpecificThan2(s, visitedClasses, withDynamic)) {
+    if (supertype != null && (supertype as InterfaceTypeImpl).isMoreSpecificThan2(s, visitedClasses, withDynamic, visitedTypePairs)) {
       return true;
     }
     for (InterfaceType interfaceType in interfaces) {
-      if ((interfaceType as InterfaceTypeImpl).isMoreSpecificThan2(s, visitedClasses, withDynamic)) {
+      if ((interfaceType as InterfaceTypeImpl).isMoreSpecificThan2(s, visitedClasses, withDynamic, visitedTypePairs)) {
         return true;
       }
     }
     for (InterfaceType mixinType in mixins) {
-      if ((mixinType as InterfaceTypeImpl).isMoreSpecificThan2(s, visitedClasses, withDynamic)) {
+      if ((mixinType as InterfaceTypeImpl).isMoreSpecificThan2(s, visitedClasses, withDynamic, visitedTypePairs)) {
         return true;
       }
     }
     return false;
   }
 
-  bool isSubtypeOf2(InterfaceType type, Set<ClassElement> visitedClasses) {
+  bool isSubtypeOf2(InterfaceType type, Set<ClassElement> visitedClasses, Set<TypeImpl_TypePair> visitedTypePairs) {
     InterfaceType typeT = this;
     InterfaceType typeS = type;
     ClassElement elementT = element;
     if (elementT == null || visitedClasses.contains(elementT)) {
       return false;
     }
-    javaSetAdd(visitedClasses, elementT);
+    visitedClasses.add(elementT);
     if (typeT == typeS) {
       return true;
     } else if (elementT == typeS.element) {
       List<Type2> typeTArgs = typeT.typeArguments;
       List<Type2> typeSArgs = typeS.typeArguments;
       if (typeTArgs.length != typeSArgs.length) {
         return false;
       }
       for (int i = 0; i < typeTArgs.length; i++) {
-        if (!typeTArgs[i].isSubtypeOf(typeSArgs[i])) {
+        if (!(typeTArgs[i] as TypeImpl).isSubtypeOf3(typeSArgs[i], visitedTypePairs)) {
           return false;
         }
       }
       return true;
     } else if (typeS.isDartCoreFunction && elementT.getMethod("call") != null) {
       return true;
     }
     InterfaceType supertype = superclass;
-    if (supertype != null && (supertype as InterfaceTypeImpl).isSubtypeOf2(typeS, visitedClasses)) {
+    if (supertype != null && (supertype as InterfaceTypeImpl).isSubtypeOf2(typeS, visitedClasses, visitedTypePairs)) {
       return true;
     }
     List<InterfaceType> interfaceTypes = interfaces;
     for (InterfaceType interfaceType in interfaceTypes) {
-      if ((interfaceType as InterfaceTypeImpl).isSubtypeOf2(typeS, visitedClasses)) {
+      if ((interfaceType as InterfaceTypeImpl).isSubtypeOf2(typeS, visitedClasses, visitedTypePairs)) {
         return true;
       }
     }
     List<InterfaceType> mixinTypes = mixins;
     for (InterfaceType mixinType in mixinTypes) {
-      if ((mixinType as InterfaceTypeImpl).isSubtypeOf2(typeS, visitedClasses)) {
+      if ((mixinType as InterfaceTypeImpl).isSubtypeOf2(typeS, visitedClasses, visitedTypePairs)) {
         return true;
       }
     }
     return false;
   }
 }
 
 /**
  * The abstract class `TypeImpl` implements the behavior common to objects representing the
  * declared type of elements in the element model.
@@ skipping 50 matching lines @@
   }
 
   String get displayName => name;
 
   Element get element => _element;
 
   Type2 getLeastUpperBound(Type2 type) => null;
 
   String get name => _name;
 
-  bool isAssignableTo(Type2 type) => this.isSubtypeOf(type) || type.isSubtypeOf(this);
+  bool isAssignableTo(Type2 type) => isAssignableTo2(type, new Set<TypeImpl_TypePair>());
+
+  /**
+   * Return `true` if this type is assignable to the given type. A type <i>T</i> may be
+   * assigned to a type <i>S</i>, written <i>T</i> &hArr; <i>S</i>, iff either <i>T</i> <: <i>S</i>
+   * or <i>S</i> <: <i>T</i>.
+   *
+   * The given set of pairs of types (T1, T2), where each pair indicates that we invoked this method
+   * because we are in the process of answering the question of whether T1 is a subtype of T2, is
+   * used to prevent infinite loops.
+   *
+   * @param type the type being compared with this type
+   * @param visitedPairs the set of pairs of types used to prevent infinite loops
+   * @return `true` if this type is assignable to the given type
+   */
+  bool isAssignableTo2(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) => isSubtypeOf3(type, visitedTypePairs) || (type as TypeImpl).isSubtypeOf3(this, visitedTypePairs);
 
   bool get isBottom => false;
 
   bool get isDartCoreFunction => false;
 
   bool get isDynamic => false;
 
-  bool isMoreSpecificThan(Type2 type) => isMoreSpecificThan3(type, false);
+  bool isMoreSpecificThan(Type2 type) => isMoreSpecificThan3(type, false, new Set<TypeImpl_TypePair>());
 
-  bool isMoreSpecificThan3(Type2 type, bool withDynamic) => false;
+  /**
+   * Return `true` if this type is more specific than the given type.
+   *
+   * The given set of pairs of types (T1, T2), where each pair indicates that we invoked this method
+   * because we are in the process of answering the question of whether T1 is a subtype of T2, is
+   * used to prevent infinite loops.
+   *
+   * @param type the type being compared with this type
+   * @param withDynamic `true` if "dynamic" should be considered as a subtype of any type
+   * @param visitedPairs the set of pairs of types used to prevent infinite loops
+   * @return `true` if this type is more specific than the given type
+   */
+  bool isMoreSpecificThan3(Type2 type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
+    TypeImpl_TypePair typePair = new TypeImpl_TypePair(this, type);
+    if (!visitedTypePairs.add(typePair)) {
+      return false;
+    }
+    bool result = internalIsMoreSpecificThan(type, withDynamic, visitedTypePairs);
+    visitedTypePairs.remove(typePair);
+    return result;
+  }
 
   bool get isObject => false;
 
+  bool isSubtypeOf(Type2 type) => isSubtypeOf3(type, new Set<TypeImpl_TypePair>());
+
+  /**
+   * Return `true` if this type is a subtype of the given type.
+   *
+   * The given set of pairs of types (T1, T2), where each pair indicates that we invoked this method
+   * because we are in the process of answering the question of whether T1 is a subtype of T2, is
+   * used to prevent infinite loops.
+   *
+   * @param type the type being compared with this type
+   * @param visitedPairs the set of pairs of types used to prevent infinite loops
+   * @return `true` if this type is a subtype of the given type
+   */
+  bool isSubtypeOf3(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) {
+    TypeImpl_TypePair typePair = new TypeImpl_TypePair(this, type);
+    if (!visitedTypePairs.add(typePair)) {
+      return false;
+    }
+    bool result = internalIsSubtypeOf(type, visitedTypePairs);
+    visitedTypePairs.remove(typePair);
+    return result;
+  }
+
   bool isSupertypeOf(Type2 type) => type.isSubtypeOf(this);
 
   bool get isVoid => false;
 
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     appendTo(builder);
     return builder.toString();
   }
 
   /**
    * Append a textual representation of this type to the given builder.
    *
    * @param builder the builder to which the text is to be appended
    */
   void appendTo(JavaStringBuilder builder) {
     if (_name == null) {
       builder.append("<unnamed type>");
     } else {
       builder.append(_name);
     }
   }
+
+  bool internalIsMoreSpecificThan(Type2 type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs);
+
+  bool internalIsSubtypeOf(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs);
+}
+
+class TypeImpl_TypePair {
+  Type2 _firstType;
+
+  Type2 _secondType;
+
+  TypeImpl_TypePair(Type2 firstType, Type2 secondType) {
+    this._firstType = firstType;
+    this._secondType = secondType;
+  }
+
+  bool operator ==(Object object) {
+    if (identical(object, this)) {
+      return true;
+    }
+    if (object is TypeImpl_TypePair) {
+      TypeImpl_TypePair typePair = object as TypeImpl_TypePair;
+      return _firstType == typePair._firstType && _secondType != null && _secondType == typePair._secondType;
+    }
+    return false;
+  }
+
+  int get hashCode {
+    int firstHashCode = 0;
+    if (_firstType != null) {
+      firstHashCode = _firstType.element == null ? 0 : _firstType.element.hashCode;
+    }
+    int secondHashCode = 0;
+    if (_secondType != null) {
+      secondHashCode = _secondType.element == null ? 0 : _secondType.element.hashCode;
+    }
+    return firstHashCode + secondHashCode;
+  }
 }
 
 /**
  * Instances of the class `TypeParameterTypeImpl` defines the behavior of objects representing
  * the type introduced by a type parameter.
  *
  * @coverage dart.engine.type
  */
 class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
   /**
@@ skipping 28 matching lines @@
    * @param element the element representing the declaration of the type parameter
    */
   TypeParameterTypeImpl(TypeParameterElement element) : super(element, element.name);
 
   bool operator ==(Object object) => object is TypeParameterTypeImpl && (element == (object as TypeParameterTypeImpl).element);
 
   TypeParameterElement get element => super.element as TypeParameterElement;
 
   int get hashCode => element.hashCode;
 
-  bool isMoreSpecificThan3(Type2 s, bool withDynamic) {
+  Type2 substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) {
+    int length = parameterTypes.length;
+    for (int i = 0; i < length; i++) {
+      if (parameterTypes[i] == this) {
+        return argumentTypes[i];
+      }
+    }
+    return this;
+  }
+
+  bool internalIsMoreSpecificThan(Type2 s, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     if (this == s) {
       return true;
     }
     if (s.isBottom) {
       return true;
     }
     if (s.isDynamic) {
       return true;
     }
-    return isMoreSpecificThan4(s, new Set<Type2>(), withDynamic);
+    return isMoreSpecificThan4(s, new Set<Type2>(), withDynamic, visitedTypePairs);
   }
 
-  bool isSubtypeOf(Type2 s) => isMoreSpecificThan3(s, true);
+  bool internalIsSubtypeOf(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) => isMoreSpecificThan3(type, true, new Set<TypeImpl_TypePair>());
 
-  Type2 substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) {
-    int length = parameterTypes.length;
-    for (int i = 0; i < length; i++) {
-      if (parameterTypes[i] == this) {
-        return argumentTypes[i];
-      }
-    }
-    return this;
-  }
-
-  bool isMoreSpecificThan4(Type2 s, Set<Type2> visitedTypes, bool withDynamic) {
+  bool isMoreSpecificThan4(Type2 s, Set<Type2> visitedTypes, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     Type2 bound = element.bound;
     if (s == bound) {
       return true;
     }
     if (s.isObject) {
       return true;
     }
     if (bound == null) {
       return false;
     }
     if (bound is TypeParameterTypeImpl) {
       TypeParameterTypeImpl boundTypeParameter = bound as TypeParameterTypeImpl;
       if (visitedTypes.contains(bound)) {
         return false;
       }
-      javaSetAdd(visitedTypes, bound);
-      return boundTypeParameter.isMoreSpecificThan4(s, visitedTypes, withDynamic);
+      visitedTypes.add(bound);
+      return boundTypeParameter.isMoreSpecificThan4(s, visitedTypes, withDynamic, visitedTypePairs);
     }
-    return bound.isMoreSpecificThan3(s, withDynamic);
+    return (bound as TypeImpl).isMoreSpecificThan3(s, withDynamic, visitedTypePairs);
   }
 }
 
 /**
  * The unique instance of the class `VoidTypeImpl` implements the type `void`.
  *
  * @coverage dart.engine.type
  */
 class VoidTypeImpl extends TypeImpl implements VoidType {
   /**
    * The unique instance of this class.
    */
   static final VoidTypeImpl instance = new VoidTypeImpl();
 
   /**
    * Prevent the creation of instances of this class.
    */
   VoidTypeImpl() : super(null, Keyword.VOID.syntax);
 
   bool operator ==(Object object) => identical(object, this);
 
-  bool isMoreSpecificThan3(Type2 type, bool withDynamic) => isSubtypeOf(type);
-
-  bool isSubtypeOf(Type2 type) => identical(type, this) || identical(type, DynamicTypeImpl.instance);
-
   bool get isVoid => true;
 
   VoidTypeImpl substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) => this;
+
+  bool internalIsMoreSpecificThan(Type2 type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) => isSubtypeOf(type);
+
+  bool internalIsSubtypeOf(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) => identical(type, this) || identical(type, DynamicTypeImpl.instance);
 }
 
 /**
  * The interface `FunctionType` defines the behavior common to objects representing the type
  * of a function, method, constructor, getter, or setter. Function types come in three variations:
  * <ol>
  * * The types of functions that only have required parameters. These have the general form
  * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>) &rarr; T</i>.
  * * The types of functions with optional positional parameters. These have the general form
  * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, [T<sub>n+1</sub>, &hellip;, T<sub>n+k</sub>]) &rarr;
@@ skipping 533 matching lines @@
 
   /**
    * Return `true` if this type is more specific than the given type.
    *
    * @param type the type being compared with this type
    * @return `true` if this type is more specific than the given type
    */
   bool isMoreSpecificThan(Type2 type);
 
   /**
-   * Return `true` if this type is more specific than the given type.
-   *
-   * @param type the type being compared with this type
-   * @param withDynamic `true` if "dynamic" should be considered as a subtype of any type
-   * @return `true` if this type is more specific than the given type
-   */
-  bool isMoreSpecificThan3(Type2 type, bool withDynamic);
-
-  /**
    * Return `true` if this type represents the type 'Object'.
    *
    * @return `true` if this type represents the type 'Object'
    */
   bool get isObject;
 
   /**
    * Return `true` if this type is a subtype of the given type.
    *
    * @param type the type being compared with this type
@@ skipping 45 matching lines @@
 
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type
  * `void`.
  *
  * @coverage dart.engine.type
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }