First step to resolving simple API changes.

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.element;
 
 import 'dart:collection';
@@ skipping 3086 matching lines @@
   /**
    * Return the element that either physically or logically encloses this element. This will be
    * `null` if this element is a library because libraries are the top-level elements in the
    * model.
    *
    * @return the element that encloses this element
    */
   Element get enclosingElement;
 
   /**
+   * The unique integer identifier of this element.
+   */
+  int get id;
+
+  /**
    * 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 has an annotation of the form '@override'.
    *
@@ skipping 100 matching lines @@
    * 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;
 
   /**
+   * Identifies of the elements that use this elements.
+   */
+  IntSet get users;

[Brian Wilkerson, 2014/12/05 23:05:57]

I'm concerned about keeping around unnecessary empty sets. It would be good to
measure to see what percentage of elements have empty sets and consider storing
'null' in place of empty sets if there would be a reasonable space savings from
doing so. (But not before this CL lands.)

[scheglov, 2014/12/05 23:49:05]

Acknowledged.

+
+  /**
    * 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
    */
   accept(ElementVisitor visitor);
 
   /**
+   * Remember the given [element] as a user of this element.
+   */
+  void addUser(Element element);
+
+  /**
    * Return the documentation comment for this element as it appears in the original source
    * (complete with the beginning and ending delimiters), or `null` if this element does not
    * have a documentation comment associated with it. This can be a long-running operation if the
    * information needed to access the comment is not cached.
    *
    * @return this element's documentation comment
    * @throws AnalysisException if the documentation comment could not be determined because the
    *           analysis could not be performed
    */
   String computeDocumentationComment();
@@ skipping 177 matching lines @@
 
   @override
   String toString() => '@$element';
 }
 
 /**
  * The abstract class `ElementImpl` implements the behavior common to objects that implement
  * an [Element].
  */
 abstract class ElementImpl implements Element {
+  static int _NEXT_ID = 0;
+
+  final int id = _NEXT_ID++;
+
   /**
    * The enclosing element of this element, or `null` if this element is at the root of the
    * element structure.
    */
   ElementImpl _enclosingElement;
 
   /**
    * The name of this element.
    */
   String _name;
@@ skipping 18 matching lines @@
    * A cached copy of the calculated hashCode for this element.
    */
   int _cachedHashCode;
 
   /**
    * A cached copy of the calculated location for this element.
    */
   ElementLocation _cachedLocation;
 
   /**
+   * Identifies of the elements that use this elements.
+   */
+  final IntSet users = new IntSet();
+
+  /**
    * Initialize a newly created 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
    */
   ElementImpl(String name, this.nameOffset) {
     this._name = StringUtilities.intern(name);
   }
 
@@ skipping 19 matching lines @@
   @override
   Element get enclosingElement => _enclosingElement;
 
   /**
    * Set the enclosing element of this element to the given element.
    *
    * @param element the enclosing element of this element
    */
   void set enclosingElement(Element element) {
     _enclosingElement = element as ElementImpl;
+    _cachedLocation = null;
+    _cachedHashCode = null;
   }
 
   @override
   int get hashCode {
     // TODO: We might want to re-visit this optimization in the future.
     // We cache the hash code value as this is a very frequently called method.
     if (_cachedHashCode == null) {
       int hashIdentifier = identifier.hashCode;
       Element enclosing = enclosingElement;
       if (enclosing != null) {
@@ skipping 97 matching lines @@
     if (identical(this, object)) {
       return true;
     }
     if (object == null || hashCode != object.hashCode) {
       return false;
     }
     return object.runtimeType == runtimeType &&
         (object as Element).location == location;
   }
 
+  @override
+  void addUser(Element element) {
+    users.add(element.id);
+  }
+
   /**
    * Append a textual representation of this element to the given [buffer].
    */
   void appendTo(StringBuffer buffer) {
     if (_name == null) {
       buffer.write("<unnamed ");
       buffer.write(runtimeType.toString());
       buffer.write(">");
     } else {
       buffer.write(_name);
@@ skipping 5309 matching lines @@
   /**
    * Return the type in which the element is defined.
    *
    * @return the type in which the element is defined
    */
   ParameterizedType get definingType => _definingType;
 
   @override
   String get displayName => _baseElement.displayName;
 
+  int get id => _baseElement.id;
+
   @override
   bool get isDeprecated => _baseElement.isDeprecated;
 
   @override
   bool get isOverride => _baseElement.isOverride;
 
   @override
   bool get isPrivate => _baseElement.isPrivate;
 
   @override
@@ skipping 22 matching lines @@
 
   @override
   AstNode get node => _baseElement.node;
 
   @override
   Source get source => _baseElement.source;
 
   @override
   CompilationUnit get unit => _baseElement.unit;
 
+  IntSet get users => _baseElement.users;
+
+  @override
+  void addUser(Element element) {
+    _baseElement.addUser(element);
+  }
+
   @override
   String computeDocumentationComment() =>
       _baseElement.computeDocumentationComment();
 
   @override
   Element getAncestor(Predicate<Element> predicate) =>
       baseElement.getAncestor(predicate);
 
   @override
   String getExtendedDisplayName(String shortName) =>
@@ skipping 438 matching lines @@
    */
   DartType get type;
 }
 
 /**
  * Instances of the class `MultiplyDefinedElementImpl` represent a collection of elements that
  * have the same name within the same scope.
  */
 class MultiplyDefinedElementImpl implements MultiplyDefinedElement {
   /**
+   * The unique integer identifier of this element.
+   */
+  final int id = ElementImpl._NEXT_ID++;
+
+  /**
    * The analysis context in which the multiply defined elements are defined.
    */
   final AnalysisContext context;
 
   /**
    * The name of the conflicting elements.
    */
   String _name;
 
   /**
@@ skipping 62 matching lines @@
   @override
   Source get source => null;
 
   @override
   DartType get type => DynamicTypeImpl.instance;
 
   @override
   CompilationUnit get unit => null;
 
   @override
+  IntSet get users => new IntSet();
+
+  @override
   accept(ElementVisitor visitor) => visitor.visitMultiplyDefinedElement(this);
 
+  void addUser(Element element) {
+  }
+
   @override
   String computeDocumentationComment() => null;
 
   @override
   Element getAncestor(Predicate<Element> predicate) => null;
 
   @override
   String getExtendedDisplayName(String shortName) {
     if (shortName != null) {
       return shortName;
@@ skipping 2961 matching lines @@
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 
   @override
   VoidTypeImpl substitute2(List<DartType> argumentTypes,
       List<DartType> parameterTypes) =>
       this;
 }