Rollback r41807.

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 2381 matching lines @@
         return type;
       }
     }
     return null;
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_accessors, visitor);
-    safelyVisitChildren(_enums, visitor);
     safelyVisitChildren(_functions, visitor);
     safelyVisitChildren(_typeAliases, visitor);
     safelyVisitChildren(_types, visitor);
     safelyVisitChildren(_variables, visitor);
     safelyVisitChildren(_angularViews, visitor);
   }
 
   /**
    * Returns the associated toolkit objects.
    *
@@ skipping 553 matching lines @@
    * of this class should be accessed through the method [getInstance].
    */
   DynamicElementImpl() : super(Keyword.DYNAMIC.syntax, -1) {
     setModifier(Modifier.SYNTHETIC, true);
   }
 
   @override
   ElementKind get kind => ElementKind.DYNAMIC;
 
   @override
-  ElementLocation get location {
-    return new DartElementLocation(null, null, nameOffset, kind);
-  }
-
-  @override
   accept(ElementVisitor visitor) => null;
 }
 
 /**
  * The unique instance of the class `DynamicTypeImpl` implements the type `dynamic`.
  */
 class DynamicTypeImpl extends TypeImpl {
   /**
    * The unique instance of this class.
    */
@@ skipping 567 matching lines @@
   bool get isPublic => !isPrivate;
 
   @override
   bool get isSynthetic => hasModifier(Modifier.SYNTHETIC);
 
   @override
   LibraryElement get library =>
       getAncestor((element) => element is LibraryElement);
 
   @override
-  ElementLocation get location {
-    // TODO(scheglov) add separate DartElementImpl
-    LibraryElement library = this.library;
-    if (library == null) {
-      return new DartElementLocation(null, null, nameOffset, kind);
-    }
-    String librarySourceEncoding = library.source.encoding;
-    String unitSourceEncoding = source.encoding;
-    return new DartElementLocation(
-        librarySourceEncoding,
-        unitSourceEncoding,
-        nameOffset,
-        kind);
-  }
+  ElementLocation get location => new ElementLocationImpl.con1(this);
 
   @override
   String get name => _name;
 
   @override
   AstNode get node => getNodeMatching((node) => node is AstNode);
 
   @override
   Source get source {
     if (_enclosingElement == null) {
@@ skipping 333 matching lines @@
    */
   static ElementKind of(Element element) {
     if (element == null) {
       return ERROR;
     }
     return element.kind;
   }
 }
 
 /**
- * The interface `ElementLocation` defines the behavior of objects that
- * represent the location of an element within the element model.
+ * The interface `ElementLocation` defines the behavior of objects that represent the location
+ * of an element within the element model.
  */
 abstract class ElementLocation {
+  /**
+   * Return the path to the element whose location is represented by this object. Clients must not
+   * modify the returned array.
+   *
+   * @return the path to the element whose location is represented by this object
+   */
+  List<String> get components;
+
+  /**
+   * Return an encoded representation of this location that can be used to create a location that is
+   * equal to this location.
+   *
+   * @return an encoded representation of this location
+   */
+  String get encoding;
 }
 
 /**
- * The interface `DartElementLocation` defines the behavior of objects that
- * represent the location of a Dart element within the element model.
+ * Instances of the class `ElementLocationImpl` implement an [ElementLocation].
  */
-class DartElementLocation implements ElementLocation {
+class ElementLocationImpl implements ElementLocation {
   /**
-   * An encoded representation of the library source that contains this element.
+   * The character used to separate components in the encoded form.
    */
-  final String librarySourceEncoding;
+  static int _SEPARATOR_CHAR = 0x3B;
 
   /**
-   * An encoded representation of the unit source that contains this element.
+   * The path to the element whose location is represented by this object.
    */
-  final String unitSourceEncoding;
+  List<String> _components;
 
   /**
-   * 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.
+   * Initialize a newly created location to represent the given element.
+   *
+   * @param element the element whose location is being represented
    */
-  final int nameOffset;
+  ElementLocationImpl.con1(Element element) {
+    List<String> components = new List<String>();
+    Element ancestor = element;
+    while (ancestor != null) {
+      components.insert(0, (ancestor as ElementImpl).identifier);
+      ancestor = ancestor.enclosingElement;
+    }
+    this._components = components;
+  }
 
   /**
-   * The kind of this element.
+   * Initialize a newly created location from the given encoded form.
+   *
+   * @param encoding the encoded form of a location
    */
-  final ElementKind kind;
+  ElementLocationImpl.con2(String encoding) {
+    this._components = _decode(encoding);
+  }
 
-  DartElementLocation(this.librarySourceEncoding, this.unitSourceEncoding,
-      this.nameOffset, this.kind);
+  /**
+   * Initialize a newly created location from the given components.
+   *
+   * @param components the components of a location
+   */
+  ElementLocationImpl.con3(List<String> components) {
+    this._components = components;
+  }
 
   @override
-  bool operator ==(Object other) {
-    if (other is DartElementLocation) {
-      return other.librarySourceEncoding == librarySourceEncoding &&
-          other.unitSourceEncoding == unitSourceEncoding &&
-          other.nameOffset == nameOffset &&
-          other.kind == kind;
+  List<String> get components => _components;
+
+  @override
+  String get encoding {
+    StringBuffer buffer = new StringBuffer();
+    int length = _components.length;
+    for (int i = 0; i < length; i++) {
+      if (i > 0) {
+        buffer.writeCharCode(_SEPARATOR_CHAR);
+      }
+      _encode(buffer, _components[i]);
     }
-    return false;
+    return buffer.toString();
+  }
+
+  @override
+  int get hashCode {
+    int result = 1;
+    for (int i = 0; i < _components.length; i++) {
+      String component = _components[i];
+      result = 31 * result + component.hashCode;
+    }
+    return result;
+  }
+
+  @override
+  bool operator ==(Object object) {
+    if (identical(this, object)) {
+      return true;
+    }
+    if (object is! ElementLocationImpl) {
+      return false;
+    }
+    ElementLocationImpl location = object as ElementLocationImpl;
+    List<String> otherComponents = location._components;
+    int length = _components.length;
+    if (otherComponents.length != length) {
+      return false;
+    }
+    for (int i = 0; i < length; i++) {
+      if (_components[i] != otherComponents[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  @override
+  String toString() => encoding;
+
+  /**
+   * Decode the encoded form of a location into an array of components.
+   *
+   * @param encoding the encoded form of a location
+   * @return the components that were encoded
+   */
+  List<String> _decode(String encoding) {
+    List<String> components = new List<String>();
+    StringBuffer buffer = new StringBuffer();
+    int index = 0;
+    int length = encoding.length;
+    while (index < length) {
+      int currentChar = encoding.codeUnitAt(index);
+      if (currentChar == _SEPARATOR_CHAR) {
+        if (index + 1 < length &&
+            encoding.codeUnitAt(index + 1) == _SEPARATOR_CHAR) {
+          buffer.writeCharCode(_SEPARATOR_CHAR);
+          index += 2;
+        } else {
+          components.add(buffer.toString());
+          buffer = new StringBuffer();
+          index++;
+        }
+      } else {
+        buffer.writeCharCode(currentChar);
+        index++;
+      }
+    }
+    components.add(buffer.toString());
+    return components;
+  }
+
+  /**
+   * Append an encoded form of the given component to the given builder.
+   *
+   * @param builder the builder to which the encoded component is to be appended
+   * @param component the component to be appended to the builder
+   */
+  void _encode(StringBuffer buffer, String component) {
+    int length = component.length;
+    for (int i = 0; i < length; i++) {
+      int currentChar = component.codeUnitAt(i);
+      if (currentChar == _SEPARATOR_CHAR) {
+        buffer.writeCharCode(_SEPARATOR_CHAR);
+      }
+      buffer.writeCharCode(currentChar);
+    }
   }
 }
 
 /**
  * The class `ElementPair` is a pair of [Element]s. [Object.==] and
  * [Object.hashCode] so this class can be used in hashed data structures.
  */
 class ElementPair {
   /**
    * The first [Element]
@@ skipping 4490 matching lines @@
       }
     }
     for (ExportElement exportElement in _exports) {
       if ((exportElement as ExportElementImpl).identifier == identifier) {
         return exportElement as ExportElementImpl;
       }
     }
     return null;
   }
 
-  /**
-   * Returns the child [Element] of this library.
-   *
-   * [unitSourceEncoding] - the encoding of the unit.
-   * [offset] - the name offset of the element.
-   * [kind] - the kind of the element.
-   */
-  ElementImpl getChildElement(String unitSourceEncoding, int offset,
-      ElementKind kind) {
-    for (CompilationUnitElement unit in units) {
-      if (unit.source.encoding == unitSourceEncoding) {
-        ElementImpl element = _findElementAt(unit, offset, kind);
-        if (element != null) {
-          return element;
-        }
-        break;
-      }
-    }
-    for (ImportElement importElement in _imports) {
-      if (importElement.nameOffset == offset) {
-        return importElement as ImportElementImpl;
-      }
-    }
-    for (ExportElement exportElement in _exports) {
-      if (exportElement.nameOffset == offset) {
-        return exportElement as ExportElementImpl;
-      }
-    }
-    return null;
-  }
-
-  ElementImpl _findElementAt(CompilationUnitElement unit, int offset,
-      ElementKind kind) {
-    if (offset == -1) {
-      return unit as ElementImpl;
-    }
-    _FindElementAt visitor = new _FindElementAt(offset, kind);
-    try {
-      unit.accept(visitor);
-    } on _FindElementAtDone catch (e) {
-      return visitor.result;
-    }
-    return null;
-  }
-
   @override
   List<ImportElement> getImportsWithPrefix(PrefixElement prefixElement) {
     int count = _imports.length;
     List<ImportElement> importList = new List<ImportElement>();
     for (int i = 0; i < count; i++) {
       if (identical(_imports[i].prefix, prefixElement)) {
         importList.add(_imports[i]);
       }
     }
     return importList;
@@ skipping 3861 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;
 }
-
-
-class _FindElementAt extends GeneralizingElementVisitor {
-  final int offset;
-  final ElementKind kind;
-  Element result;
-
-  _FindElementAt(this.offset, this.kind);
-
-  @override
-  visitElement(Element element) {
-    if (element.nameOffset == offset && element.kind == kind) {
-      result = element;
-      throw new _FindElementAtDone();
-    }
-    super.visitElement(element);
-  }
-}
-
-
-class _FindElementAtDone {
-}