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';
 import 'scanner.dart' show Keyword;
-import 'ast.dart' show Identifier, LibraryIdentifier;
+import 'ast.dart';
 import 'sdk.dart' show DartSdk;
 import 'html.dart' show XmlTagNode;
 import 'engine.dart' show AnalysisContext;
 import 'constant.dart' show EvaluationResultImpl;
 import 'utilities_dart.dart';
 
 /**
  * The interface `ClassElement` defines the behavior of elements that represent a class.
  *
  * @coverage dart.engine.element
@@ skipping 81 matching lines @@
   /**
    * Return the named constructor declared in this class with the given name, or `null` if
    * this class does not declare a named constructor with the given name.
    *
    * @param name the name of the constructor to be returned
    * @return the element representing the specified constructor
    */
   ConstructorElement getNamedConstructor(String name);
 
   /**
+   * Return the resolved [ClassDeclaration] node that declares this [ClassElement].
+   *
+   * This method is expensive, because resolved AST might be evicted from cache, so parsing and
+   * resolving will be performed.
+   *
+   * @return the resolved [ClassDeclaration], not `null`.
+   */
+  ClassDeclaration get node;
+
+  /**
    * Return the element representing the setter with the given name that is declared in this class,
    * or `null` if this class does not declare a setter with the given name.
    *
    * @param setterName the name of the getter to be returned
    * @return the setter declared in this class with the given name
    */
   PropertyAccessorElement getSetter(String setterName);
 
   /**
    * Return the superclass of this class, or `null` if the class represents the class
    * 'Object'. All other classes will have a non-`null` superclass. If the superclass was not
    * explicitly declared then the implicit superclass 'Object' will be returned.
    *
    * <b>Note:</b> Because the element model represents the state of the code, it is possible for it
    * to be semantically invalid. In particular, it is not safe to assume that the inheritance
    * structure of a class does not contain a cycle. Clients that traverse the inheritance structure
    * must explicitly guard against infinite loops.
    *
    * @return the superclass of this class
    */
   InterfaceType get supertype;
 
   /**
+   * Return an array containing all of the toolkit specific objects attached to this class.
+   *
+   * @return the toolkit objects attached to this class
+   */
+  List<ToolkitObjectElement> get toolkitObjects;
+
+  /**
    * Return the type defined by the class.
    *
    * @return the type defined by the class
    */
   InterfaceType get type;
 
   /**
    * Return an array containing all of the type parameters declared for this class.
    *
    * @return the type parameters declared for this class
@@ skipping 177 matching lines @@
   List<FunctionElement> get functions;
 
   /**
    * Return an array containing all of the function type aliases contained in this compilation unit.
    *
    * @return the function type aliases contained in this compilation unit
    */
   List<FunctionTypeAliasElement> get functionTypeAliases;
 
   /**
+   * Return the resolved [CompilationUnit] node that declares this element.
+   *
+   * This method is expensive, because resolved AST might be evicted from cache, so parsing and
+   * resolving will be performed.
+   *
+   * @return the resolved [CompilationUnit], not `null`.
+   */
+  CompilationUnit get node;
+
+  /**
    * Return an array containing all of the top-level variables contained in this compilation unit.
    *
    * @return the top-level variables contained in this compilation unit
    */
   List<TopLevelVariableElement> get topLevelVariables;
 
   /**
    * Return the class defined in this compilation unit that has the given name, or `null` if
    * this compilation unit does not define a class with the given name.
    *
@@ skipping 11 matching lines @@
 }
 
 /**
  * The interface `ConstructorElement` defines the behavior of elements representing a
  * constructor or a factory method defined within a type.
  *
  * @coverage dart.engine.element
  */
 abstract class ConstructorElement implements ClassMemberElement, ExecutableElement {
   /**
+   * Return the resolved [ConstructorDeclaration] node that declares this
+   * [ConstructorElement] .
+   *
+   * This method is expensive, because resolved AST might be evicted from cache, so parsing and
+   * resolving will be performed.
+   *
+   * @return the resolved [ConstructorDeclaration], not `null`.
+   */
+  ConstructorDeclaration get node;
+
+  /**
    * Return the constructor to which this constructor is redirecting.
    *
    * @return the constructor to which this constructor is redirecting
    */
   ConstructorElement get redirectedConstructor;
 
   /**
    * Return `true` if this constructor is a const constructor.
    *
    * @return `true` if this constructor is a const constructor
@@ skipping 146 matching lines @@
   /**
    * Return the offset of the name of this element in the file that contains the declaration of this
    * element, or `-1` if this element is synthetic, does not have a name, or otherwise does
    * not have an offset.
    *
    * @return the offset of the name of this element
    */
   int get nameOffset;
 
   /**
+   * Return the resolved [ASTNode] node that declares this [Element].
+   *
+   * This method is expensive, because resolved AST might be evicted from cache, so parsing and
+   * resolving will be performed.
+   *
+   * @return the resolved [ASTNode], maybe `null` if [Element] is synthetic or
+   *         isn't contained in a compilation unit, such as a [LibraryElement].
+   */
+  ASTNode get node;
+
+  /**
    * Return the source that contains this element, or `null` if this element is not contained
    * in a source.
    *
    * @return the source that contains this element
    */
   Source get source;
 
   /**
+   * Return the resolved [CompilationUnit] that declares this [Element].
+   *
+   * This method is expensive, because resolved AST might have been already evicted from cache, so
+   * parsing and resolving will be performed.
+   *
+   * @return the resolved [CompilationUnit], maybe `null` if synthetic [Element].
+   */
+  CompilationUnit get unit;
+
+  /**
    * Return `true` if this element, assuming that it is within scope, is accessible to code in
    * the given library. This is defined by the Dart Language Specification in section 3.2:
    * <blockquote> A declaration <i>m</i> is accessible to library <i>L</i> if <i>m</i> is declared
    * in <i>L</i> or if <i>m</i> is public. </blockquote>
    *
    * @param library the library in which a possible reference to this element would occur
    * @return `true` if this element is accessible to code in the given library
    */
   bool isAccessibleIn(LibraryElement library);
 
   /**
    * Return `true` if this element has an annotation of the form '@deprecated' or
    * '@Deprecated('..')'.
    *
    * @return `true` if this element is deprecated
    */
   bool get isDeprecated;
 
   /**
+   * Return `true` if this element is private. Private elements are visible only within the
+   * library in which they are declared.
+   *
+   * @return `true` if this element is private
+   */
+  bool get isPrivate;
+
+  /**
+   * Return `true` if this element is public. Public elements are visible within any library
+   * that imports the library in which they are declared.
+   *
+   * @return `true` if this element is public
+   */
+  bool get isPublic;
+
+  /**
    * Return `true` if this element is synthetic. A synthetic element is an element that is not
    * represented in the source code explicitly, but is implied by the source code, such as the
    * default constructor for a class that does not explicitly define any constructors.
    *
    * @return `true` if this element is synthetic
    */
   bool get isSynthetic;
 
   /**
    * Use the given visitor to visit all of the children of this element. There is no guarantee of
@@ skipping 372 matching lines @@
    */
   FieldElement get field;
 }
 
 /**
  * The interface `FunctionElement` defines the behavior of elements representing a function.
  *
  * @coverage dart.engine.element
  */
 abstract class FunctionElement implements ExecutableElement, LocalElement {
+  /**
+   * Return the resolved [FunctionDeclaration] node that declares this [FunctionElement]
+   * .
+   *
+   * This method is expensive, because resolved AST might be evicted from cache, so parsing and
+   * resolving will be performed.
+   *
+   * @return the resolved [FunctionDeclaration], not `null`.
+   */
+  FunctionDeclaration get node;
 }
 
 /**
  * The interface `FunctionTypeAliasElement` defines the behavior of elements representing a
  * function type alias (`typedef`).
  *
  * @coverage dart.engine.element
  */
 abstract class FunctionTypeAliasElement implements Element {
   /**
    * Return the compilation unit in which this type alias is defined.
    *
    * @return the compilation unit in which this type alias is defined
    */
   CompilationUnitElement get enclosingElement;
 
   /**
+   * Return the resolved [FunctionTypeAlias] node that declares this
+   * [FunctionTypeAliasElement] .
+   *
+   * This method is expensive, because resolved AST might be evicted from cache, so parsing and
+   * resolving will be performed.
+   *
+   * @return the resolved [FunctionTypeAlias], not `null`.
+   */
+  FunctionTypeAlias get node;
+
+  /**
    * Return an array containing all of the parameters defined by this type alias.
    *
    * @return the parameters defined by this type alias
    */
   List<ParameterElement> get parameters;
 
   /**
    * Return the return type defined by this type alias.
    *
    * @return the return type defined by this type alias
@@ skipping 198 matching lines @@
   /**
    * Return the class defined in this library that has the given name, or `null` if this
    * library does not define a class with the given name.
    *
    * @param className the name of the class to be returned
    * @return the class with the given name that is defined in this library
    */
   ClassElement getType(String className);
 
   /**
+   * Return an array containing all directly and indirectly imported libraries.
+   *
+   * @return all directly and indirectly imported libraries
+   */
+  List<LibraryElement> get visibleLibraries;
+
+  /**
    * Answer `true` if this library is an application that can be run in the browser.
    *
    * @return `true` if this library is an application that can be run in the browser
    */
   bool get isBrowserApplication;
 
   /**
    * Return `true` if this library is the dart:core library.
    *
    * @return `true` if this library is the dart:core library
@@ skipping 54 matching lines @@
 }
 
 /**
  * The interface `MethodElement` defines the behavior of elements that represent a method
  * defined within a type.
  *
  * @coverage dart.engine.element
  */
 abstract class MethodElement implements ClassMemberElement, ExecutableElement {
   /**
+   * Return the resolved [MethodDeclaration] node that declares this [MethodElement].
+   *
+   * This method is expensive, because resolved AST might be evicted from cache, so parsing and
+   * resolving will be performed.
+   *
+   * @return the resolved [MethodDeclaration], not `null`.
+   */
+  MethodDeclaration get node;
+
+  /**
    * Return `true` if this method is abstract. Methods are abstract if they are not external
    * and have no body.
    *
    * @return `true` if this method is abstract
    */
   bool get isAbstract;
 }
 
 /**
  * The interface `MultiplyDefinedElement` defines the behavior of pseudo-elements that
@@ skipping 232 matching lines @@
   /**
    * Return an array containing the names that are to be made visible in the importing library if
    * they are defined in the imported library.
    *
    * @return the names from the imported library that are visible in the importing library
    */
   List<String> get shownNames;
 }
 
 /**
+ * The interface `ToolkitObjectElement` defines the behavior of elements that represent a
+ * toolkit specific object, such as Angular controller or component. These elements are not based on
+ * the Dart syntax, but on some semantic agreement, such as a special annotation.
+ *
+ * @coverage dart.engine.element
+ */
+abstract class ToolkitObjectElement implements Element {
+  /**
+   * An empty array of toolkit object elements.
+   */
+  static final List<ToolkitObjectElement> EMPTY_ARRAY = new List<ToolkitObjectElement>(0);
+}
+
+/**
  * The interface `TopLevelVariableElement` defines the behavior of elements representing a
  * top-level variable.
  *
  * @coverage dart.engine.element
  */
 abstract class TopLevelVariableElement implements PropertyInducingElement {
 }
 
 /**
  * The interface `TypeParameterElement` defines the behavior of elements representing a type
@@ skipping 55 matching lines @@
   /**
    * Return a synthetic function representing this variable's initializer, or `null` if this
    * variable does not have an initializer. The function will have no parameters. The return type of
    * the function will be the compile-time type of the initialization expression.
    *
    * @return a synthetic function representing this variable's initializer
    */
   FunctionElement get initializer;
 
   /**
+   * Return the resolved [VariableDeclaration] node that declares this [VariableElement]
+   * .
+   *
+   * This method is expensive, because resolved AST might be evicted from cache, so parsing and
+   * resolving will be performed.
+   *
+   * @return the resolved [VariableDeclaration], not `null`.
+   */
+  VariableDeclaration get node;
+
+  /**
    * Return the declared type of this variable, or `null` if the variable did not have a
    * declared type (such as if it was declared using the keyword 'var').
    *
    * @return the declared type of this variable
    */
   Type2 get type;
 
   /**
    * Return `true` if this variable was declared with the 'const' modifier.
    *
    * @return `true` if this variable was declared with the 'const' modifier
    */
   bool get isConst;
 
   /**
    * Return `true` if this variable was declared with the 'final' modifier. Variables that are
    * declared with the 'const' modifier will return `false` even though they are implicitly
    * final.
    *
    * @return `true` if this variable was declared with the 'final' modifier
    */
   bool get isFinal;
 }
 
 /**
+ * The interface `AngularControllerElement` defines the Angular component described by
+ * <code>NgComponent</code> annotation.
+ *
+ * @coverage dart.engine.element
+ */
+abstract class AngularComponentElement implements AngularSelectorElement {
+  /**
+   * Return an array containing all of the properties declared by this component.
+   */
+  List<AngularPropertyElement> get properties;
+
+  /**
+   * Returns the CSS file URI.
+   */
+  String get styleUri;
+
+  /**
+   * Return the offset of the [getStyleUri] in the [getSource].
+   *
+   * @return the offset of the style URI
+   */
+  int get styleUriOffset;
+
+  /**
+   * Returns the HTML template URI.
+   */
+  String get templateUri;
+
+  /**
+   * Return the offset of the [getTemplateUri] in the [getSource].
+   *
+   * @return the offset of the template URI
+   */
+  int get templateUriOffset;
+}
+
+/**
+ * The interface `AngularControllerElement` defines the Angular controller described by
+ * <code>NgController</code> annotation.
+ *
+ * @coverage dart.engine.element
+ */
+abstract class AngularControllerElement implements AngularSelectorElement {
+}
+
+/**
+ * The interface `AngularElement` defines the behavior of objects representing information
+ * about an Angular specific element.
+ *
+ * @coverage dart.engine.element
+ */
+abstract class AngularElement implements ToolkitObjectElement {
+}
+
+/**
+ * The interface `AngularFilterElement` defines the Angular filter described by
+ * <code>NgFilter</code> annotation.
+ *
+ * @coverage dart.engine.element
+ */
+abstract class AngularFilterElement implements AngularElement {
+}
+
+/**
+ * The interface `AngularControllerElement` defines a single property in
+ * [AngularComponentElement].
+ *
+ * @coverage dart.engine.element
+ */
+abstract class AngularPropertyElement implements AngularElement {
+  /**
+   * Returns the field this property is mapped to.
+   *
+   * @return the field this property is mapped to.
+   */
+  FieldElement get field;
+
+  /**
+   * Return the offset of the field name of this property in the [getSource].
+   *
+   * @return the offset of the field name of this property
+   */
+  int get fieldNameOffset;
+
+  /**
+   * Returns the kind of this property.
+   *
+   * @return the kind of this property
+   */
+  AngularPropertyKind get propertyKind;
+}
+
+/**
+ * The enumeration `AngularPropertyKind` defines the different kinds of property bindings.
+ *
+ * @coverage dart.engine.element
+ */
+class AngularPropertyKind extends Enum<AngularPropertyKind> {
+  /**
+   * `@` - Map the DOM attribute string. The attribute string will be taken literally or
+   * interpolated if it contains binding {{}} syntax and assigned to the expression. (cost: 0
+   * watches)
+   */
+  static final AngularPropertyKind ATTR = new AngularPropertyKind('ATTR', 0);
+
+  /**
+   * `&` - Treat the DOM attribute value as an expression. Assign a closure function into the field.
+   * This allows the component to control the invocation of the closure. This is useful for passing
+   * expressions into controllers which act like callbacks. (cost: 0 watches)
+   */
+  static final AngularPropertyKind CALLBACK = new AngularPropertyKind('CALLBACK', 1);
+
+  /**
+   * `=>` - Treat the DOM attribute value as an expression. Set up a watch, which will read the
+   * expression in the attribute and assign the value to destination expression. (cost: 1 watch)
+   */
+  static final AngularPropertyKind ONE_WAY = new AngularPropertyKind('ONE_WAY', 2);
+
+  /**
+   * `=>!` - Treat the DOM attribute value as an expression. Set up a one time watch on expression.
+   * Once the expression turns not null it will no longer update. (cost: 1 watches until not null,
+   * then 0 watches)
+   */
+  static final AngularPropertyKind ONE_WAY_ONE_TIME = new AngularPropertyKind('ONE_WAY_ONE_TIME', 3);
+
+  /**
+   * `<=>` - Treat the DOM attribute value as an expression. Set up a watch on both outside as well
+   * as component scope to keep the source and destination in sync. (cost: 2 watches)
+   */
+  static final AngularPropertyKind TWO_WAY = new AngularPropertyKind('TWO_WAY', 4);
+
+  static final List<AngularPropertyKind> values = [ATTR, CALLBACK, ONE_WAY, ONE_WAY_ONE_TIME, TWO_WAY];
+
+  AngularPropertyKind(String name, int ordinal) : super(name, ordinal);
+}
+
+/**
+ * [AngularSelector] is used to decide when Angular object should be applied.
+ */
+abstract class AngularSelector {
+  /**
+   * Checks if the given [XmlTagNode] matches this selector.
+   *
+   * @param node the [XmlTagNode] to check
+   * @return `true` if the given [XmlTagNode] matches, or `false` otherwise
+   */
+  bool apply(XmlTagNode node);
+}
+
+/**
+ * The interface `AngularElement` defines the behavior of objects representing information
+ * about an Angular element which is applied conditionally using some [AngularSelector].
+ *
+ * @coverage dart.engine.element
+ */
+abstract class AngularSelectorElement implements AngularElement {
+  /**
+   * Returns the selector specified for this element.
+   *
+   * @return the [AngularSelector] specified for this element
+   */
+  AngularSelector get selector;
+}
+
+/**
  * Instances of the class `GeneralizingElementVisitor` implement an element visitor that will
  * recursively visit all of the elements in an element model (like instances of the class
  * [RecursiveElementVisitor]). In addition, when an element of a specific type is visited not
  * only will the visit method for that specific type of element be invoked, but additional methods
  * for the supertypes of that element will also be invoked. For example, using an instance of this
  * class to visit a [MethodElement] will cause the method
  * [visitMethodElement] to be invoked but will also cause the methods
  * [visitExecutableElement] and [visitElement] to be
  * subsequently invoked. This allows visitors to be written that visit all executable elements
  * without needing to override the visit method for each of the specific subclasses of
@@ skipping 356 matching lines @@
    * An array containing all of the methods contained in this class.
    */
   List<MethodElement> _methods = MethodElementImpl.EMPTY_ARRAY;
 
   /**
    * The superclass of the class, or `null` if the class does not have an explicit superclass.
    */
   InterfaceType supertype;
 
   /**
+   * An array containing all of the toolkit objects attached to this class.
+   */
+  List<ToolkitObjectElement> _toolkitObjects = ToolkitObjectElement.EMPTY_ARRAY;
+
+  /**
    * The type defined by the class.
    */
   InterfaceType type;
 
   /**
    * An array containing all of the type parameters defined for this class.
    */
   List<TypeParameterElement> _typeParameters = TypeParameterElementImpl.EMPTY_ARRAY;
 
   /**
@@ skipping 92 matching lines @@
   ConstructorElement getNamedConstructor(String name) {
     for (ConstructorElement element in constructors) {
       String elementName = element.name;
       if (elementName != null && elementName == name) {
         return element;
       }
     }
     return null;
   }
 
+  ClassDeclaration get node => getNode2(ClassDeclaration);
+
   PropertyAccessorElement getSetter(String setterName) {
     if (!setterName.endsWith("=")) {
       setterName += '=';
     }
     for (PropertyAccessorElement accessor in _accessors) {
       if (accessor.isSetter && accessor.name == setterName) {
         return accessor;
       }
     }
     return null;
   }
 
+  List<ToolkitObjectElement> get toolkitObjects => _toolkitObjects;
+
   List<TypeParameterElement> get typeParameters => _typeParameters;
 
   ConstructorElement get unnamedConstructor {
     for (ConstructorElement element in constructors) {
       String name = element.displayName;
       if (name == null || name.isEmpty) {
         return element;
       }
     }
     return null;
@@ skipping 185 matching lines @@
    * @param methods the methods contained in this class
    */
   void set methods(List<MethodElement> methods) {
     for (MethodElement method in methods) {
       (method as MethodElementImpl).enclosingElement = this;
     }
     this._methods = methods;
   }
 
   /**
+   * Set the toolkit specific information objects attached to this class.
+   *
+   * @param toolkitObjects the toolkit objects attached to this class
+   */
+  void set toolkitObjects(List<ToolkitObjectElement> toolkitObjects) {
+    for (ToolkitObjectElement toolkitObject in toolkitObjects) {
+      (toolkitObject as ToolkitObjectElementImpl).enclosingElement = this;
+    }
+    this._toolkitObjects = toolkitObjects;
+  }
+
+  /**
    * Set whether this class is defined by a typedef construct to correspond to the given value.
    *
    * @param isTypedef `true` if the class is defined by a typedef construct
    */
   void set typedef(bool isTypedef) {
     setModifier(Modifier.TYPEDEF, isTypedef);
   }
 
   /**
    * Set the type parameters defined for this class to the given type parameters.
@@ skipping 15 matching lines @@
   void set validMixin(bool isValidMixin) {
     setModifier(Modifier.MIXIN, isValidMixin);
   }
 
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_accessors, visitor);
     safelyVisitChildren(_constructors, visitor);
     safelyVisitChildren(_fields, visitor);
     safelyVisitChildren(_methods, visitor);
+    safelyVisitChildren(_toolkitObjects, visitor);
     safelyVisitChildren(_typeParameters, visitor);
   }
 
   void appendTo(JavaStringBuilder builder) {
     String name = displayName;
     if (name == null) {
       builder.append("{unnamed class}");
     } else {
       builder.append(name);
     }
@@ skipping 46 matching lines @@
  *
  * @coverage dart.engine.element
  */
 class CompilationUnitElementImpl extends ElementImpl implements CompilationUnitElement {
   /**
    * An empty array of compilation unit elements.
    */
   static List<CompilationUnitElement> EMPTY_ARRAY = new List<CompilationUnitElement>(0);
 
   /**
+   * The source that corresponds to this compilation unit.
+   */
+  Source source;
+
+  /**
    * An array containing all of the top-level accessors (getters and setters) contained in this
    * compilation unit.
    */
   List<PropertyAccessorElement> _accessors = PropertyAccessorElementImpl.EMPTY_ARRAY;
 
   /**
    * An array containing all of the top-level functions contained in this compilation unit.
    */
   List<FunctionElement> _functions = FunctionElementImpl.EMPTY_ARRAY;
 
   /**
-   * An array containing all of the variables contained in this compilation unit.
-   */
-  List<TopLevelVariableElement> _variables = TopLevelVariableElementImpl.EMPTY_ARRAY;
-
-  /**
-   * The source that corresponds to this compilation unit.
-   */
-  Source source;
-
-  /**
    * An array containing all of the function type aliases contained in this compilation unit.
    */
   List<FunctionTypeAliasElement> _typeAliases = FunctionTypeAliasElementImpl.EMPTY_ARRAY;
 
   /**
    * An array containing all of the types contained in this compilation unit.
    */
   List<ClassElement> _types = ClassElementImpl.EMPTY_ARRAY;
 
   /**
+   * An array containing all of the variables contained in this compilation unit.
+   */
+  List<TopLevelVariableElement> _variables = TopLevelVariableElementImpl.EMPTY_ARRAY;
+
+  /**
    * The URI that is specified by the "part" directive in the enclosing library, or `null` if
    * this is the defining compilation unit of a library.
    */
   String uri;
 
   /**
    * Initialize a newly created compilation unit element to have the given name.
    *
    * @param name the name of this element
    */
@@ skipping 35 matching lines @@
   }
 
   LibraryElement get enclosingElement => super.enclosingElement as LibraryElement;
 
   List<FunctionElement> get functions => _functions;
 
   List<FunctionTypeAliasElement> get functionTypeAliases => _typeAliases;
 
   ElementKind get kind => ElementKind.COMPILATION_UNIT;
 
+  CompilationUnit get node => unit;
+
   List<TopLevelVariableElement> get topLevelVariables => _variables;
 
   ClassElement getType(String className) {
     for (ClassElement type in _types) {
       if (type.name == className) {
         return type;
       }
     }
     return null;
   }
@@ skipping 179 matching lines @@
    * @param name the name of this element
    */
   ConstructorElementImpl(Identifier name) : super.con1(name);
 
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
 
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
 
   ElementKind get kind => ElementKind.CONSTRUCTOR;
 
+  ConstructorDeclaration get node => getNode2(ConstructorDeclaration);
+
   bool get isConst => hasModifier(Modifier.CONST);
 
   bool get isDefaultConstructor {
     String name = this.name;
     if (name != null && name.length != 0) {
       return false;
     }
     for (ParameterElement parameter in parameters) {
       if (identical(parameter.parameterKind, ParameterKind.REQUIRED)) {
         return false;
@@ skipping 311 matching lines @@
   String get displayName => _name;
 
   Element get enclosingElement => _enclosingElement;
 
   LibraryElement get library => getAncestor(LibraryElement);
 
   ElementLocation get location => new ElementLocationImpl.con1(this);
 
   String get name => _name;
 
+  ASTNode get node => getNode2(ASTNode);
+
   Source get source {
     if (_enclosingElement == null) {
       return null;
     }
     return _enclosingElement.source;
   }
 
+  CompilationUnit get unit => context.resolveCompilationUnit(source, library);
+
   int get hashCode {
     if (_cachedHashCode == 0) {
       _cachedHashCode = location.hashCode;
     }
     return _cachedHashCode;
   }
 
   bool isAccessibleIn(LibraryElement library) {
     if (Identifier.isPrivateName(_name)) {
       return library == this.library;
     }
     return true;
   }
 
   bool get isDeprecated {
     for (ElementAnnotation annotation in metadata) {
       if (annotation.isDeprecated) {
         return true;
       }
     }
     return false;
   }
 
+  bool get isPrivate {
+    String name = displayName;
+    if (name == null) {
+      return true;
+    }
+    return Identifier.isPrivateName(name);
+  }
+
+  bool get isPublic => !isPrivate;
+
   bool get isSynthetic => hasModifier(Modifier.SYNTHETIC);
 
   /**
    * Set whether this element is synthetic to correspond to the given value.
    *
    * @param isSynthetic `true` if the element is synthetic
    */
   void set synthetic(bool isSynthetic) {
     setModifier(Modifier.SYNTHETIC, isSynthetic);
   }
@@ skipping 24 matching lines @@
 
   /**
    * Return an identifier that uniquely identifies this element among the children of this element's
    * parent.
    *
    * @return an identifier that uniquely identifies this element relative to its parent
    */
   String get identifier => name;
 
   /**
+   * Return the resolved [ASTNode] of the given type enclosing [getNameOffset].
+   */
+  ASTNode getNode2(Type clazz) {
+    CompilationUnit unit = this.unit;
+    if (unit == null) {
+      return null;
+    }
+    int offset = nameOffset;
+    ASTNode node = new NodeLocator.con1(offset).searchWithin(unit);
+    if (node == null) {
+      return null;
+    }
+    return node.getAncestor(clazz);
+  }
+
+  /**
    * Return `true` if this element has the given modifier associated with it.
    *
    * @param modifier the modifier being tested for
    * @return `true` if this element has the given modifier associated with it
    */
   bool hasModifier(Modifier modifier) => BooleanArray.get(_modifiers, modifier);
 
   /**
    * If the given child is not `null`, use the given visitor to visit it.
    *
@@ skipping 226 matching lines @@
    */
   int hashSourceComponent(String sourceComponent) {
     if (sourceComponent.length <= 1) {
       return sourceComponent.hashCode;
     }
     return sourceComponent.substring(1).hashCode;
   }
 }
 
 /**
+ * The class `ElementPair` is a pair of [Element]s. [Object#equals] and
+ * [Object#hashCode] so this class can be used in hashed data structures.
+ */
+class ElementPair {
+  /**
+   * The first [Element]
+   */
+  Element _first;
+
+  /**
+   * The second [Element]
+   */
+  Element _second;
+
+  /**
+   * The sole constructor for this class, taking two [Element]s.
+   *
+   * @param first the first element
+   * @param second the second element
+   */
+  ElementPair(Element first, Element second) {
+    this._first = first;
+    this._second = second;
+  }
+
+  bool operator ==(Object object) {
+    if (identical(object, this)) {
+      return true;
+    }
+    if (object is ElementPair) {
+      ElementPair elementPair = object as ElementPair;
+      return (_first == elementPair._first) && (_second == elementPair._second);
+    }
+    return false;
+  }
+
+  /**
+   * Return the first element.
+   *
+   * @return the first element
+   */
+  Element get firstElt => _first;
+
+  /**
+   * Return the second element
+   *
+   * @return the second element
+   */
+  Element get secondElt => _second;
+
+  int get hashCode => ObjectUtilities.combineHashCodes(_first.hashCode, _second.hashCode);
+}
+
+/**
  * Instances of the class `EmbeddedHtmlScriptElementImpl` implement an
  * [EmbeddedHtmlScriptElement].
  *
  * @coverage dart.engine.element
  */
 class EmbeddedHtmlScriptElementImpl extends HtmlScriptElementImpl implements EmbeddedHtmlScriptElement {
   /**
    * The library defined by the script tag's content.
    */
   LibraryElement _scriptLibrary;
@@ skipping 357 matching lines @@
    *
    * @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);
 
   ElementKind get kind => ElementKind.FUNCTION;
 
+  FunctionDeclaration get node => getNode2(FunctionDeclaration);
+
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   bool get isStatic => enclosingElement is CompilationUnitElement;
 
   /**
@@ skipping 72 matching lines @@
         return typeParameter as TypeParameterElementImpl;
       }
     }
     return null;
   }
 
   CompilationUnitElement get enclosingElement => super.enclosingElement as CompilationUnitElement;
 
   ElementKind get kind => ElementKind.FUNCTION_TYPE_ALIAS;
 
+  FunctionTypeAlias get node => getNode2(FunctionTypeAlias);
+
   List<ParameterElement> get parameters => _parameters;
 
   List<TypeParameterElement> get typeParameters => _typeParameters;
 
   /**
    * Set the parameters defined by this type alias to the given parameters.
    *
    * @param parameters the parameters defined by this type alias
    */
   void set parameters(List<ParameterElement> parameters) {
@@ skipping 194 matching lines @@
   HtmlScriptElementImpl(XmlTagNode node) : super.con2(node.tag.lexeme, node.tag.offset);
 }
 
 /**
  * Instances of the class `ImportElementImpl` implement an [ImportElement].
  *
  * @coverage dart.engine.element
  */
 class ImportElementImpl extends ElementImpl implements ImportElement {
   /**
-   * The offset of this directive, may be `-1` if synthetic.
-   */
-  int _offset = -1;
-
-  /**
    * The offset of the character immediately following the last character of this node's URI, may be
    * `-1` if synthetic.
    */
   int uriEnd = -1;
 
   /**
    * The offset of the prefix of this import in the file that contains the this import directive, or
    * `-1` if this import is synthetic.
    */
   int prefixOffset = 0;
@@ skipping 15 matching lines @@
   List<NamespaceCombinator> combinators = NamespaceCombinator.EMPTY_ARRAY;
 
   /**
    * The prefix that was specified as part of the import directive, or `null` if there was no
    * prefix specified.
    */
   PrefixElement prefix;
 
   /**
    * Initialize a newly created import element.
+   *
+   * @param offset the directive offset, may be `-1` if synthetic.
    */
-  ImportElementImpl() : super.con1(null);
+  ImportElementImpl(int offset) : super.con2(null, offset);
 
   accept(ElementVisitor visitor) => visitor.visitImportElement(this);
 
   ElementKind get kind => ElementKind.IMPORT;
 
-  /**
-   * Set the offset of this directive.
-   */
-  void set offset(int offset) {
-    this._offset = offset;
-  }
-
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(prefix, visitor);
   }
 
   void appendTo(JavaStringBuilder builder) {
     builder.append("import ");
     (importedLibrary as LibraryElementImpl).appendTo(builder);
   }
 
-  String get identifier => "${(importedLibrary as LibraryElementImpl).identifier}@${_offset}";
+  String get identifier => "${(importedLibrary as LibraryElementImpl).identifier}@${nameOffset}";
 }
 
 /**
  * Instances of the class `LabelElementImpl` implement a `LabelElement`.
  *
  * @coverage dart.engine.element
  */
 class LabelElementImpl extends ElementImpl implements LabelElement {
   /**
    * A flag indicating whether this label is associated with a `switch` statement.
@@ skipping 213 matching lines @@
     }
     for (CompilationUnitElement part in _parts) {
       type = part.getType(className);
       if (type != null) {
         return type;
       }
     }
     return null;
   }
 
+  List<LibraryElement> get visibleLibraries {
+    Set<LibraryElement> visibleLibraries = new Set();
+    addVisibleLibraries(visibleLibraries, false);
+    return new List.from(visibleLibraries);
+  }
+
   int get hashCode => _definingCompilationUnit.hashCode;
 
   bool get isBrowserApplication => entryPoint != null && isOrImportsBrowserLibrary;
 
   bool get isDartCore => name == "dart.core";
 
   bool get isInSdk => name.startsWith("dart.");
 
   bool isUpToDate2(int timeStamp) {
     Set<LibraryElement> visitedLibraries = new Set();
@@ skipping 55 matching lines @@
     super.visitChildren(visitor);
     safelyVisitChild(_definingCompilationUnit, visitor);
     safelyVisitChildren(_exports, visitor);
     safelyVisitChildren(_imports, visitor);
     safelyVisitChildren(_parts, visitor);
   }
 
   String get identifier => _definingCompilationUnit.source.encoding;
 
   /**
+   * Recursively fills set of visible libraries for [getVisibleElementsLibraries].
+   */
+  void addVisibleLibraries(Set<LibraryElement> visibleLibraries, bool includeExports) {
+    if (!visibleLibraries.add(this)) {
+      return;
+    }
+    for (ImportElement importElement in _imports) {
+      LibraryElement importedLibrary = importElement.importedLibrary;
+      if (importedLibrary != null) {
+        (importedLibrary as LibraryElementImpl).addVisibleLibraries(visibleLibraries, true);
+      }
+    }
+    if (includeExports) {
+      for (ExportElement exportElement in _exports) {
+        LibraryElement exportedLibrary = exportElement.exportedLibrary;
+        if (exportedLibrary != null) {
+          (exportedLibrary as LibraryElementImpl).addVisibleLibraries(visibleLibraries, true);
+        }
+      }
+    }
+  }
+
+  /**
    * Answer `true` if the receiver directly or indirectly imports the dart:html libraries.
    *
    * @return `true` if the receiver directly or indirectly imports the dart:html libraries
    */
   bool get isOrImportsBrowserLibrary {
     List<LibraryElement> visited = new List<LibraryElement>();
     Source htmlLibSource = context.sourceFactory.forUri(DartSdk.DART_HTML);
     visited.add(this);
     for (int index = 0; index < visited.length; index++) {
       LibraryElement library = visited[index];
@@ skipping 142 matching lines @@
   String get name {
     String name = super.name;
     if (isOperator && name == "-") {
       if (parameters.length == 0) {
         return "unary-";
       }
     }
     return super.name;
   }
 
+  MethodDeclaration get node => getNode2(MethodDeclaration);
+
   bool get isAbstract => hasModifier(Modifier.ABSTRACT);
 
   bool get isOperator {
     String name = displayName;
     if (name.isEmpty) {
       return false;
     }
     int first = name.codeUnitAt(0);
     return !((0x61 <= first && first <= 0x7A) || (0x41 <= first && first <= 0x5A) || first == 0x5F || first == 0x24);
   }
@@ skipping 169 matching lines @@
   LibraryElement get library => null;
 
   ElementLocation get location => null;
 
   List<ElementAnnotation> get metadata => ElementAnnotationImpl.EMPTY_ARRAY;
 
   String get name => _name;
 
   int get nameOffset => -1;
 
+  ASTNode get node => null;
+
   Source get source => null;
 
   Type2 get type => DynamicTypeImpl.instance;
 
+  CompilationUnit get unit => null;
+
   bool isAccessibleIn(LibraryElement library) {
     for (Element element in conflictingElements) {
       if (element.isAccessibleIn(library)) {
         return true;
       }
     }
     return false;
   }
 
   bool get isDeprecated => false;
 
+  bool get isPrivate {
+    String name = displayName;
+    if (name == null) {
+      return false;
+    }
+    return Identifier.isPrivateName(name);
+  }
+
+  bool get isPublic => !isPrivate;
+
   bool get isSynthetic => true;
 
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append("[");
     int count = conflictingElements.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
         builder.append(", ");
       }
@@ skipping 292 matching lines @@
     return ElementKind.SETTER;
   }
 
   String get name {
     if (isSetter) {
       return "${super.name}=";
     }
     return super.name;
   }
 
+  ASTNode get node {
+    if (isSynthetic) {
+      return null;
+    }
+    if (enclosingElement is ClassElement) {
+      return getNode2(MethodDeclaration);
+    }
+    if (enclosingElement is CompilationUnitElement) {
+      return getNode2(FunctionDeclaration);
+    }
+    return null;
+  }
+
   int get hashCode => ObjectUtilities.combineHashCodes(super.hashCode, isGetter ? 1 : 2);
 
   bool get isAbstract => hasModifier(Modifier.ABSTRACT);
 
   bool get isGetter => hasModifier(Modifier.GETTER);
 
   bool get isSetter => hasModifier(Modifier.SETTER);
 
   bool get isStatic => hasModifier(Modifier.STATIC);
 
@@ skipping 111 matching lines @@
       if (i > 0) {
         builder.append(", ");
       }
       builder.append(shownNames[i]);
     }
     return builder.toString();
   }
 }
 
 /**
+ * Instances of the class `ToolkitObjectElementImpl` implement a `ToolkitObjectElement`.
+ *
+ * @coverage dart.engine.element
+ */
+abstract class ToolkitObjectElementImpl extends ElementImpl implements ToolkitObjectElement {
+  /**
+   * Initialize a newly created toolkit object element to have the given name.
+   *
+   * @param name the name of this element
+   * @param nameOffset the offset of the name of this element in the file that contains the
+   *          declaration of this element
+   */
+  ToolkitObjectElementImpl(String name, int nameOffset) : super.con2(name, nameOffset);
+}
+
+/**
  * Instances of the class `TopLevelVariableElementImpl` implement a
  * `TopLevelVariableElement`.
  *
  * @coverage dart.engine.element
  */
 class TopLevelVariableElementImpl extends PropertyInducingElementImpl implements TopLevelVariableElement {
   /**
    * An empty array of top-level variable elements.
    */
   static List<TopLevelVariableElement> EMPTY_ARRAY = new List<TopLevelVariableElement>(0);
@@ skipping 103 matching lines @@
    * Return the result of evaluating this variable's initializer as a compile-time constant
    * expression, or `null` if this variable is not a 'const' variable or does not have an
    * initializer.
    *
    * @return the result of evaluating this variable's initializer
    */
   EvaluationResultImpl get evaluationResult => null;
 
   FunctionElement get initializer => _initializer;
 
+  VariableDeclaration get node => getNode2(VariableDeclaration);
+
   bool get isConst => hasModifier(Modifier.CONST);
 
   bool get isFinal => hasModifier(Modifier.FINAL);
 
   /**
    * Return `true` if this variable is potentially mutated somewhere in closure. This
    * information is only available for local variables (including parameters).
    *
    * @return `true` if this variable is potentially mutated somewhere in closure
    */
@@ skipping 99 matching lines @@
    * @param definingType the type in which the element is defined
    */
   ConstructorMember(ConstructorElement baseElement, InterfaceType definingType) : super(baseElement, definingType);
 
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
 
   ConstructorElement get baseElement => super.baseElement as ConstructorElement;
 
   ClassElement get enclosingElement => baseElement.enclosingElement;
 
+  ConstructorDeclaration get node => baseElement.node;
+
   ConstructorElement get redirectedConstructor => from(baseElement.redirectedConstructor, definingType);
 
   bool get isConst => baseElement.isConst;
 
   bool get isDefaultConstructor => baseElement.isDefaultConstructor;
 
   bool get isFactory => baseElement.isFactory;
 
   String toString() {
     ConstructorElement baseElement = this.baseElement;
@@ skipping 202 matching lines @@
   LibraryElement get library => _baseElement.library;
 
   ElementLocation get location => _baseElement.location;
 
   List<ElementAnnotation> get metadata => _baseElement.metadata;
 
   String get name => _baseElement.name;
 
   int get nameOffset => _baseElement.nameOffset;
 
+  ASTNode get node => _baseElement.node;
+
   Source get source => _baseElement.source;
 
+  CompilationUnit get unit => _baseElement.unit;
+
   bool isAccessibleIn(LibraryElement library) => _baseElement.isAccessibleIn(library);
 
   bool get isDeprecated => _baseElement.isDeprecated;
 
+  bool get isPrivate => _baseElement.isPrivate;
+
+  bool get isPublic => _baseElement.isPublic;
+
   bool get isSynthetic => _baseElement.isSynthetic;
 
   void visitChildren(ElementVisitor visitor) {
   }
 
   /**
    * Return the type in which the element is defined.
    *
    * @return the type in which the element is defined
    */
@@ skipping 92 matching lines @@
    * @param definingType the type in which the element is defined
    */
   MethodMember(MethodElement baseElement, InterfaceType definingType) : super(baseElement, definingType);
 
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
 
   MethodElement get baseElement => super.baseElement as MethodElement;
 
   ClassElement get enclosingElement => baseElement.enclosingElement;
 
+  MethodDeclaration get node => baseElement.node;
+
   bool get isAbstract => baseElement.isAbstract;
 
   String toString() {
     MethodElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
     FunctionType type = this.type;
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append(baseElement.enclosingElement.displayName);
     builder.append(".");
     builder.append(baseElement.displayName);
@@ skipping 239 matching lines @@
    * @param definingType the type in which the element is defined
    */
   VariableMember(VariableElement baseElement, ParameterizedType definingType) : super(baseElement, definingType);
 
   VariableElement get baseElement => super.baseElement as VariableElement;
 
   FunctionElement get initializer {
     throw new UnsupportedOperationException();
   }
 
+  VariableDeclaration get node => baseElement.node;
+
   Type2 get type => substituteFor(baseElement.type);
 
   bool get isConst => baseElement.isConst;
 
   bool get isFinal => baseElement.isFinal;
 
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(baseElement.initializer, visitor);
   }
@@ skipping 25 matching lines @@
   bool operator ==(Object object) => identical(object, this);
 
   int get hashCode => 0;
 
   bool get isBottom => true;
 
   bool isSupertypeOf(Type2 type) => false;
 
   BottomTypeImpl substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) => this;
 
+  bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) => identical(object, 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
  */
@@ skipping 28 matching lines @@
   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 internalEquals(Object object, Set<ElementPair> visitedElementPairs) => identical(object, 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 {
   /**
    * Return `true` if all of the name/type pairs in the first map are equal to the
    * corresponding name/type pairs in the second map. The maps are expected to iterate over their
    * entries in the same order in which those entries were added to the map.
    *
    * @param firstTypes the first map of name/type pairs being compared
    * @param secondTypes the second map of name/type pairs being compared
+   * @param visitedElementPairs a set of visited element pairs
    * @return `true` if all of the name/type pairs in the first map are equal to the
    *         corresponding name/type pairs in the second map
    */
-  static bool equals2(Map<String, Type2> firstTypes, Map<String, Type2> secondTypes) {
+  static bool equals2(Map<String, Type2> firstTypes, Map<String, Type2> secondTypes, Set<ElementPair> visitedElementPairs) {
     if (secondTypes.length != firstTypes.length) {
       return false;
     }
     JavaIterator<MapEntry<String, Type2>> firstIterator = new JavaIterator(getMapEntrySet(firstTypes));
     JavaIterator<MapEntry<String, Type2>> secondIterator = new JavaIterator(getMapEntrySet(secondTypes));
     while (firstIterator.hasNext) {
       MapEntry<String, Type2> firstEntry = firstIterator.next();
       MapEntry<String, Type2> secondEntry = secondIterator.next();
-      if (firstEntry.getKey() != secondEntry.getKey() || firstEntry.getValue() != secondEntry.getValue()) {
+      if (firstEntry.getKey() != secondEntry.getKey() || !(firstEntry.getValue() as TypeImpl).internalEquals(secondEntry.getValue(), visitedElementPairs)) {
         return false;
       }
     }
     return true;
   }
 
   /**
    * An array containing the actual types of the type arguments.
    */
   List<Type2> typeArguments = TypeImpl.EMPTY_ARRAY;
 
   /**
    * Initialize a newly created function type to be declared by the given element and to have the
    * given name.
    *
    * @param element the element representing the declaration of the function type
    */
   FunctionTypeImpl.con1(ExecutableElement element) : super(element, element == null ? null : element.name);
 
   /**
    * Initialize a newly created function type to be declared by the given element and to have the
    * given name.
    *
    * @param element the element representing the declaration of the function type
    */
   FunctionTypeImpl.con2(FunctionTypeAliasElement element) : super(element, element == null ? null : element.name);
 
-  bool operator ==(Object object) {
-    if (object is! FunctionTypeImpl) {
-      return false;
-    }
-    FunctionTypeImpl otherType = object as FunctionTypeImpl;
-    return (element == otherType.element) && JavaArrays.equals(normalParameterTypes, otherType.normalParameterTypes) && JavaArrays.equals(optionalParameterTypes, otherType.optionalParameterTypes) && equals2(namedParameterTypes, otherType.namedParameterTypes) && (returnType == otherType.returnType);
-  }
+  bool operator ==(Object object) => internalEquals(object, new Set<ElementPair>());
 
   String get displayName {
     String name = this.name;
     if (name == null || name.length == 0) {
       List<Type2> normalParameterTypes = this.normalParameterTypes;
       List<Type2> optionalParameterTypes = this.optionalParameterTypes;
       Map<String, Type2> namedParameterTypes = this.namedParameterTypes;
       Type2 returnType = this.returnType;
       JavaStringBuilder builder = new JavaStringBuilder();
       builder.append("(");
@@ skipping 128 matching lines @@
       return (element as FunctionTypeAliasElement).typeParameters;
     }
     ClassElement definingClass = element.getAncestor(ClassElement);
     if (definingClass != null) {
       return definingClass.typeParameters;
     }
     return TypeParameterElementImpl.EMPTY_ARRAY;
   }
 
   int get hashCode {
-    Element element = this.element;
     if (element == null) {
       return 0;
     }
-    return element.hashCode;
+    List<Type2> normalParameterTypes = this.normalParameterTypes;
+    List<Type2> optionalParameterTypes = this.optionalParameterTypes;
+    Iterable<Type2> namedParameterTypes = this.namedParameterTypes.values;
+    int hashCode = returnType.hashCode;
+    for (int i = 0; i < normalParameterTypes.length; i++) {
+      hashCode = (hashCode << 1) + normalParameterTypes[i].hashCode;
+    }
+    for (int i = 0; i < optionalParameterTypes.length; i++) {
+      hashCode = (hashCode << 1) + optionalParameterTypes[i].hashCode;
+    }
+    for (Type2 type in namedParameterTypes) {
+      hashCode = (hashCode << 1) + type.hashCode;
+    }
+    return hashCode;
   }
 
   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) {
@@ skipping 159 matching lines @@
    */
   List<ParameterElement> get baseParameters {
     Element element = this.element;
     if (element is ExecutableElement) {
       return (element as ExecutableElement).parameters;
     } else {
       return (element as FunctionTypeAliasElement).parameters;
     }
   }
 
+  bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) {
+    if (object is! FunctionTypeImpl) {
+      return false;
+    }
+    FunctionTypeImpl otherType = object as FunctionTypeImpl;
+    ElementPair elementPair = new ElementPair(element, otherType.element);
+    if (!visitedElementPairs.add(elementPair)) {
+      return elementPair.firstElt == elementPair.secondElt;
+    }
+    bool result = TypeImpl.equalArrays(normalParameterTypes, otherType.normalParameterTypes, visitedElementPairs) && TypeImpl.equalArrays(optionalParameterTypes, otherType.optionalParameterTypes, visitedElementPairs) && equals2(namedParameterTypes, otherType.namedParameterTypes, visitedElementPairs) && (returnType as TypeImpl).internalEquals(otherType.returnType, visitedElementPairs);
+    visitedElementPairs.remove(elementPair);
+    return result;
+  }
+
   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;
     }
@@ skipping 265 matching lines @@
   InterfaceTypeImpl.con1(ClassElement element) : super(element, element.displayName);
 
   /**
    * Initialize a newly created type to have the given name. This constructor should only be used in
    * cases where there is no declaration of the type.
    *
    * @param name the name of the type
    */
   InterfaceTypeImpl.con2(String name) : super(null, name);
 
-  bool operator ==(Object object) {
-    if (object is! InterfaceTypeImpl) {
-      return false;
-    }
-    InterfaceTypeImpl otherType = object as InterfaceTypeImpl;
-    return (element == otherType.element) && JavaArrays.equals(typeArguments, otherType.typeArguments);
-  }
+  bool operator ==(Object object) => internalEquals(object, new Set<ElementPair>());
 
   List<PropertyAccessorElement> get accessors {
     List<PropertyAccessorElement> accessors = element.accessors;
     List<PropertyAccessorElement> members = new List<PropertyAccessorElement>(accessors.length);
     for (int i = 0; i < accessors.length; i++) {
       members[i] = PropertyAccessorMember.from(accessors[i], this);
     }
     return members;
   }
 
@@ skipping 320 matching lines @@
       for (int i = 0; i < argumentCount; i++) {
         if (i > 0) {
           builder.append(", ");
         }
         (typeArguments[i] as TypeImpl).appendTo(builder);
       }
       builder.append(">");
     }
   }
 
+  bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) {
+    if (object is! InterfaceTypeImpl) {
+      return false;
+    }
+    InterfaceTypeImpl otherType = object as InterfaceTypeImpl;
+    return (element == otherType.element) && TypeImpl.equalArrays(typeArguments, otherType.typeArguments, visitedElementPairs);
+  }
+
   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) {
@@ skipping 105 matching lines @@
   }
 }
 
 /**
  * The abstract class `TypeImpl` implements the behavior common to objects representing the
  * declared type of elements in the element model.
  *
  * @coverage dart.engine.type
  */
 abstract class TypeImpl implements Type2 {
+  static bool equalArrays(List<Type2> typeArgs1, List<Type2> typeArgs2, Set<ElementPair> visitedElementPairs) {
+    if (typeArgs1.length != typeArgs2.length) {
+      return false;
+    }
+    for (int i = 0; i < typeArgs1.length; i++) {
+      if (!(typeArgs1[i] as TypeImpl).internalEquals(typeArgs2[i], visitedElementPairs)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   /**
    * Return an array containing the results of using the given argument types and parameter types to
    * perform a substitution on all of the given types.
    *
    * @param types the types on which a substitution is to be performed
    * @param argumentTypes the argument types for the substitution
    * @param parameterTypes the parameter types for the substitution
    * @return the result of performing the substitution on each of the types
    */
   static List<Type2> substitute(List<Type2> types, List<Type2> argumentTypes, List<Type2> parameterTypes) {
@@ skipping 128 matching lines @@
    * @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 internalEquals(Object object, Set<ElementPair> visitedElementPairs);
+
   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;
 
@@ skipping 75 matching lines @@
   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 internalEquals(Object object, Set<ElementPair> visitedElementPairs) => this == object;
+
   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;
     }
@@ skipping 49 matching lines @@
   VoidTypeImpl() : super(null, Keyword.VOID.syntax);
 
   bool operator ==(Object object) => identical(object, this);
 
   int get hashCode => 2;
 
   bool get isVoid => true;
 
   VoidTypeImpl substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) => this;
 
+  bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) => identical(object, 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
@@ skipping 601 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);
 }