New analyzer_experimental snapshot.

pkg/analyzer_experimental/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 'source.dart';
 import 'scanner.dart' show Keyword;
 import 'ast.dart' show Identifier, LibraryIdentifier;
 import 'sdk.dart' show DartSdk;
@@ skipping 750 matching lines @@
    */
   FunctionType get type;
 
   /**
    * Return an array containing all of the type variables defined for this type.
    * @return the type variables defined for this type
    */
   List<TypeVariableElement> get typeVariables;
 }
 /**
- * The interface {@code HideCombinator} defines the behavior of combinators that cause some of the
- * names in a namespace to be hidden when being imported.
+ * The interface {@code HideElementCombinator} defines the behavior of combinators that cause some
+ * of the names in a namespace to be hidden when being imported.
  * @coverage dart.engine.element
  */
-abstract class HideCombinator implements NamespaceCombinator {
+abstract class HideElementCombinator implements NamespaceCombinator {
 
   /**
    * Return an array containing the names that are not to be made visible in the importing library
    * even if they are defined in the imported library.
    * @return the names from the imported library that are hidden from the importing library
    */
   List<String> get hiddenNames;
 }
 /**
  * The interface {@code HtmlElement} defines the behavior of elements representing an HTML file.
@@ skipping 371 matching lines @@
   PropertyAccessorElement get setter;
 
   /**
    * Return {@code true} if this element is a static element. A static element is an element that is
    * not associated with a particular instance, but rather with an entire library or class.
    * @return {@code true} if this executable element is a static element
    */
   bool isStatic();
 }
 /**
- * The interface {@code ShowCombinator} defines the behavior of combinators that cause some of the
- * names in a namespace to be visible (and the rest hidden) when being imported.
+ * The interface {@code ShowElementCombinator} defines the behavior of combinators that cause some
+ * of the names in a namespace to be visible (and the rest hidden) when being imported.
  * @coverage dart.engine.element
  */
-abstract class ShowCombinator implements NamespaceCombinator {
+abstract class ShowElementCombinator implements NamespaceCombinator {
 
   /**
    * 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 {@code TopLevelVariableElement} defines the behavior of elements representing a
@@ skipping 1443 matching lines @@
     _jtd_constructor_197_impl(encoding);
   }
   _jtd_constructor_197_impl(String encoding) {
     this._components = decode(encoding);
   }
   bool operator ==(Object object) {
     if (object is! ElementLocationImpl) {
       return false;
     }
     ElementLocationImpl location = object as ElementLocationImpl;
-    return JavaArrays.equals(_components, location._components);
+    List<String> otherComponents = location._components;
+    int length = _components.length;
+    if (otherComponents.length != length) {
+      return false;
+    }
+    if (length > 0 && !equalSourceComponents(_components[0], otherComponents[0])) {
+      return false;
+    }
+    if (length > 1 && !equalSourceComponents(_components[1], otherComponents[1])) {
+      return false;
+    }
+    for (int i = 2; i < length; i++) {
+      if (_components[i] != otherComponents[i]) {
+        return false;
+      }
+    }
+    return true;
   }
 
   /**
    * Return the path to the element whose location is represented by this object.
    * @return the path to the element whose location is represented by this object
    */
   List<String> get components => _components;
   String get encoding {
     JavaStringBuilder builder = new JavaStringBuilder();
     int length = _components.length;
@@ skipping 48 matching lines @@
   void encode(JavaStringBuilder builder, String component) {
     int length = component.length;
     for (int i = 0; i < length; i++) {
       int currentChar = component.codeUnitAt(i);
       if (currentChar == _SEPARATOR_CHAR) {
         builder.appendChar(_SEPARATOR_CHAR);
       }
       builder.appendChar(currentChar);
     }
   }
+
+  /**
+   * Return {@code true} if the given components, when interpreted to be encoded sources with a
+   * leading source type indicator, are equal when the source type's are ignored.
+   * @param left the left component being compared
+   * @param right the right component being compared
+   * @return {@code true} if the given components are equal when the source type's are ignored
+   */
+  bool equalSourceComponents(String left, String right) {
+    if (left == null) {
+      return right == null;
+    } else if (right == null) {
+      return false;
+    }
+    if (left.length <= 1 || right.length <= 1) {
+      return left == right;
+    }
+    return left.substring(1) == right.substring(1);
+  }
 }
 /**
  * Instances of the class {@code EmbeddedHtmlScriptElementImpl} implement an{@link EmbeddedHtmlScriptElement}.
  * @coverage dart.engine.element
  */
 class EmbeddedHtmlScriptElementImpl extends HtmlScriptElementImpl implements EmbeddedHtmlScriptElement {
 
   /**
    * The library defined by the script tag's content.
    */
@@ skipping 394 matching lines @@
    * 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) {
     _jtd_constructor_208_impl(nameOffset);
   }
   _jtd_constructor_208_impl(int nameOffset) {
   }
   accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
-  String get identifier => name;
+  String get identifier => "${name}@${nameOffset}";
   ElementKind get kind => ElementKind.FUNCTION;
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
   bool isStatic() => enclosingElement is CompilationUnitElement;
 
   /**
@@ skipping 126 matching lines @@
       ((_parameters[i] as ParameterElementImpl)).appendTo(builder);
     }
     builder.append(")");
     if (_type != null) {
       builder.append(" -> ");
       builder.append(_type.returnType);
     }
   }
 }
 /**
- * Instances of the class {@code ShowCombinatorImpl} implement a {@link ShowCombinator}.
+ * Instances of the class {@code HideElementCombinatorImpl} implement a{@link HideElementCombinator}.
  * @coverage dart.engine.element
  */
-class HideCombinatorImpl implements HideCombinator {
+class HideElementCombinatorImpl implements HideElementCombinator {
 
   /**
    * The names that are not to be made visible in the importing library even if they are defined in
    * the imported library.
    */
   List<String> _hiddenNames = StringUtilities.EMPTY_ARRAY;
   List<String> get hiddenNames => _hiddenNames;
 
   /**
    * Set the names that are not to be made visible in the importing library even if they are defined
@@ skipping 543 matching lines @@
    */
   void setVisibleRange(int offset, int length) {
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append(type);
     builder.append(" ");
     builder.append(displayName);
   }
+  String get identifier => "${super.identifier}@${nameOffset}";
 }
 /**
  * Instances of the class {@code MethodElementImpl} implement a {@code MethodElement}.
  * @coverage dart.engine.element
  */
 class MethodElementImpl extends ExecutableElementImpl implements MethodElement {
 
   /**
    * An empty array of method elements.
    */
@@ skipping 542 matching lines @@
 
   /**
    * Set the setter associated with this element to the given accessor.
    * @param setter the setter associated with this element
    */
   void set setter(PropertyAccessorElement setter2) {
     this._setter = setter2;
   }
 }
 /**
- * Instances of the class {@code ShowCombinatorImpl} implement a {@link ShowCombinator}.
+ * Instances of the class {@code ShowElementCombinatorImpl} implement a{@link ShowElementCombinator}.
  * @coverage dart.engine.element
  */
-class ShowCombinatorImpl implements ShowCombinator {
+class ShowElementCombinatorImpl implements ShowElementCombinator {
 
   /**
    * The names that are to be made visible in the importing library if they are defined in the
    * imported library.
    */
   List<String> _shownNames = StringUtilities.EMPTY_ARRAY;
   List<String> get shownNames => _shownNames;
 
   /**
    * Set the names that are to be made visible in the importing library if they are defined in the
@@ skipping 824 matching lines @@
    * @param firstTypes the first map of name/type pairs being compared
    * @param secondTypes the second map of name/type pairs being compared
    * @return {@code 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) {
     if (secondTypes.length != firstTypes.length) {
       return false;
     }
     JavaIterator<MapEntry<String, Type2>> firstIterator = new JavaIterator(getMapEntrySet(firstTypes));
-    JavaIterator<MapEntry<String, Type2>> secondIterator = 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()) {
         return false;
       }
     }
     return true;
   }
 
@@ skipping 1634 matching lines @@
 abstract class TypeVariableType implements Type2 {
   TypeVariableElement get element;
 }
 /**
  * The interface {@code VoidType} defines the behavior of the unique object representing the type{@code void}.
  * @coverage dart.engine.type
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }