New analyzer snapshot.

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 3849 matching lines @@
 
   /**
    * The name of the top-level variable used to mark a method as being expected to override an
    * inherited method.
    */
   static String _OVERRIDE_VARIABLE_NAME = "override";
 
   /**
    * The name of the top-level variable used to mark a class as implementing a proxy object.
    */
-  static String _PROXY_VARIABLE_NAME = "proxy";
+  static String PROXY_VARIABLE_NAME = "proxy";
 
   /**
    * Initialize a newly created annotation.
    *
    * @param element the element representing the field, variable, or constructor being used as an
    *          annotation
    */
   ElementAnnotationImpl(this.element);
 
   @override
@@ skipping 25 matching lines @@
       }
     }
     return false;
   }
 
   @override
   bool get isProxy {
     if (element != null) {
       LibraryElement library = element.library;
       if (library != null && library.isDartCore) {
-        if (element is PropertyAccessorElement && element.name == _PROXY_VARIABLE_NAME) {
+        if (element is PropertyAccessorElement && element.name == PROXY_VARIABLE_NAME) {
           return true;
         }
       }
     }
     return false;
   }
 
   @override
   String toString() => "@${element.toString()}";
 }
@@ skipping 1967 matching lines @@
    * @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
    */
   MethodElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
 
   @override
+  String get displayName {
+    String displayName = super.displayName;
+    if ("unary-" == displayName) {
+      return "-";
+    }
+    return displayName;
+  }
+
+  @override
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
 
   @override
   ElementKind get kind => ElementKind.METHOD;
 
   @override
   String get name {
     String name = super.name;
     if (isOperator && name == "-") {
       if (parameters.length == 0) {
@@ skipping 2574 matching lines @@
    * @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 _equals(Map<String, DartType> firstTypes, Map<String, DartType> secondTypes, Set<ElementPair> visitedElementPairs) {
     if (secondTypes.length != firstTypes.length) {
       return false;
     }
-    MapIterator<String, DartType> firstIterator = SingleMapIterator.forMap(firstTypes);
-    MapIterator<String, DartType> secondIterator = SingleMapIterator.forMap(secondTypes);
-    while (firstIterator.moveNext() && secondIterator.moveNext()) {
-      if (firstIterator.key != secondIterator.key || !(firstIterator.value as TypeImpl).internalEquals(secondIterator.value, visitedElementPairs)) {
+    JavaIterator<MapEntry<String, DartType>> firstIterator = new JavaIterator(getMapEntrySet(firstTypes));
+    JavaIterator<MapEntry<String, DartType>> secondIterator = new JavaIterator(getMapEntrySet(secondTypes));
+    while (firstIterator.hasNext) {
+      MapEntry<String, DartType> firstEntry = firstIterator.next();
+      MapEntry<String, DartType> secondEntry = secondIterator.next();
+      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<DartType> typeArguments = TypeImpl.EMPTY_ARRAY;
@@ skipping 55 matching lines @@
         }
         builder.append("]");
         needsComma = true;
       }
       if (namedParameterTypes.length > 0) {
         if (needsComma) {
           builder.append(", ");
           needsComma = false;
         }
         builder.append("{");
-        for (MapIterator<String, DartType> iter = SingleMapIterator.forMap(namedParameterTypes); iter.moveNext();) {
+        for (MapEntry<String, DartType> entry in getMapEntrySet(namedParameterTypes)) {
           if (needsComma) {
             builder.append(", ");
           } else {
             needsComma = true;
           }
-          builder.append(iter.key);
+          builder.append(entry.getKey());
           builder.append(": ");
-          builder.append(iter.value.displayName);
+          builder.append(entry.getValue().displayName);
         }
         builder.append("}");
         needsComma = true;
       }
       builder.append(")");
       builder.append(Element.RIGHT_ARROW);
       if (returnType == null) {
         builder.append("null");
       } else {
         builder.append(returnType.displayName);
@@ skipping 150 matching lines @@
         }
       }
       Map<String, DartType> namedTypesT = t.namedParameterTypes;
       Map<String, DartType> namedTypesS = s.namedParameterTypes;
       // if k >= m is false, return false: the passed function type has more named parameter types than this
       if (namedTypesT.length < namedTypesS.length) {
         return false;
       }
       // Loop through each element in S verifying that T has a matching parameter name and that the
       // corresponding type is more specific then the type in S.
-      MapIterator<String, DartType> iteratorS = SingleMapIterator.forMap(namedTypesS);
-      while (iteratorS.moveNext()) {
-        DartType typeT = namedTypesT[iteratorS.key];
+      JavaIterator<MapEntry<String, DartType>> iteratorS = new JavaIterator(getMapEntrySet(namedTypesS));
+      while (iteratorS.hasNext) {
+        MapEntry<String, DartType> entryS = iteratorS.next();
+        DartType typeT = namedTypesT[entryS.getKey()];
         if (typeT == null) {
           return false;
         }
-        if (!(typeT as TypeImpl).isMoreSpecificThan2(iteratorS.value, withDynamic, visitedTypePairs)) {
+        if (!(typeT as TypeImpl).isMoreSpecificThan2(entryS.getValue(), withDynamic, visitedTypePairs)) {
           return false;
         }
       }
     } else if (s.namedParameterTypes.length > 0) {
       return false;
     } else {
       // positional parameter case
       int tArgLength = tTypes.length + tOpTypes.length;
       int sArgLength = sTypes.length + sOpTypes.length;
       // Check that the total number of parameters in t is greater than or equal to the number of
@@ skipping 92 matching lines @@
       }
       builder.append("]");
       needsComma = true;
     }
     if (namedParameterTypes.length > 0) {
       if (needsComma) {
         builder.append(", ");
         needsComma = false;
       }
       builder.append("{");
-      for (MapIterator<String, DartType> iter = SingleMapIterator.forMap(namedParameterTypes); iter.moveNext();) {
+      for (MapEntry<String, DartType> entry in getMapEntrySet(namedParameterTypes)) {
         if (needsComma) {
           builder.append(", ");
         } else {
           needsComma = true;
         }
-        builder.append(iter.key);
+        builder.append(entry.getKey());
         builder.append(": ");
-        (iter.value as TypeImpl).appendTo(builder);
+        (entry.getValue() as TypeImpl).appendTo(builder);
       }
       builder.append("}");
       needsComma = true;
     }
     builder.append(")");
     builder.append(Element.RIGHT_ARROW);
     if (returnType == null) {
       builder.append("null");
     } else {
       (returnType as TypeImpl).appendTo(builder);
@@ skipping 67 matching lines @@
         }
       }
       Map<String, DartType> namedTypesT = t.namedParameterTypes;
       Map<String, DartType> namedTypesS = s.namedParameterTypes;
       // if k >= m is false, return false: the passed function type has more named parameter types than this
       if (namedTypesT.length < namedTypesS.length) {
         return false;
       }
       // Loop through each element in S verifying that T has a matching parameter name and that the
       // corresponding type is assignable to the type in S.
-      MapIterator<String, DartType> iteratorS = SingleMapIterator.forMap(namedTypesS);
-      while (iteratorS.moveNext()) {
-        DartType typeT = namedTypesT[iteratorS.key];
+      JavaIterator<MapEntry<String, DartType>> iteratorS = new JavaIterator(getMapEntrySet(namedTypesS));
+      while (iteratorS.hasNext) {
+        MapEntry<String, DartType> entryS = iteratorS.next();
+        DartType typeT = namedTypesT[entryS.getKey()];
         if (typeT == null) {
           return false;
         }
-        if (!(typeT as TypeImpl).isAssignableTo2(iteratorS.value, visitedTypePairs)) {
+        if (!(typeT as TypeImpl).isAssignableTo2(entryS.getValue(), visitedTypePairs)) {
           return false;
         }
       }
     } else if (s.namedParameterTypes.length > 0) {
       return false;
     } else {
       // positional parameter case
       int tArgLength = tTypes.length + tOpTypes.length;
       int sArgLength = sTypes.length + sOpTypes.length;
       // Check that the total number of parameters in t is greater than or equal to the number of
@@ skipping 135 matching lines @@
    * callers should call the public [computeSuperinterfaceSet].
    *
    * @param type the [Type] to compute the set of superinterfaces of
    * @param set a [HashSet] used recursively by this method
    * @return the [Set] of superinterfaces of the passed [Type]
    * @see #computeSuperinterfaceSet(Type)
    * @see #getLeastUpperBound(Type)
    */
   static Set<InterfaceType> _computeSuperinterfaceSet(InterfaceType type, Set<InterfaceType> set) {
     Element element = type.element;
-    if (element != null && element is ClassElement) {
-      ClassElement classElement = element;
-      List<InterfaceType> superinterfaces = classElement.interfaces;
+    if (element != null) {
+      List<InterfaceType> superinterfaces = type.interfaces;
       for (InterfaceType superinterface in superinterfaces) {
         if (set.add(superinterface)) {
           _computeSuperinterfaceSet(superinterface, set);
         }
       }
-      InterfaceType supertype = classElement.supertype;
+      InterfaceType supertype = type.superclass;
       if (supertype != null) {
         if (set.add(supertype)) {
           _computeSuperinterfaceSet(supertype, set);
         }
       }
     }
     return set;
   }
 
   /**
    * Return the intersection of the given sets of types, where intersection is based on the equality
-   * of the elements of the types rather than on the equality of the types themselves. In cases
-   * where two non-equal types have equal elements, which only happens when the class is
-   * parameterized, the type that is added to the intersection is the base type with type arguments
-   * that are the least upper bound of the type arguments of the two types.
+   * of the types themselves.
    *
    * @param first the first set of types to be intersected
    * @param second the second set of types to be intersected
    * @return the intersection of the given sets of types
    */
   static List<InterfaceType> _intersection(Set<InterfaceType> first, Set<InterfaceType> second) {
-    Map<ClassElement, InterfaceType> firstMap = new Map<ClassElement, InterfaceType>();
-    for (InterfaceType firstType in first) {
-      firstMap[firstType.element] = firstType;
-    }
-    Set<InterfaceType> result = new Set<InterfaceType>();
-    for (InterfaceType secondType in second) {
-      InterfaceType firstType = firstMap[secondType.element];
-      if (firstType != null) {
-        result.add(_leastUpperBound(firstType, secondType));
-      }
-    }
+    Set<InterfaceType> result = new Set<InterfaceType>.from(first);
+    result.retainAll(second);
     return new List.from(result);
   }
 
   /**
    * Return the "least upper bound" of the given types under the assumption that the types have the
    * same element and differ only in terms of the type arguments. The resulting type is composed by
    * comparing the corresponding type arguments, keeping those that are the same, and using
    * 'dynamic' for those that are different.
    *
    * @param firstType the first type
@@ skipping 1582 matching lines @@
 }
 
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type
  * `void`.
  */
 abstract class VoidType implements DartType {
   @override
   VoidType substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes);
 }