Remove JavaIterator and MapEntry

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 5263 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;
     }
-    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)) {
+    Iterator<String> firstKeys = firstTypes.keys.iterator;
+    Iterator<String> secondKeys = secondTypes.keys.iterator;
+    while (firstKeys.moveNext() && secondKeys.moveNext()) {
+      String firstKey = firstKeys.current;
+      String secondKey = secondKeys.current;
+      TypeImpl firstType = firstTypes[firstKey];
+      TypeImpl secondType = secondTypes[secondKey];
+      if (firstKey != secondKey
+          || !firstType.internalEquals(secondType, visitedElementPairs)) {
         return false;
       }
     }
     return true;
   }
 
   /**
    * An array containing the actual types of the type arguments.
    */
   List<DartType> typeArguments = TypeImpl.EMPTY_ARRAY;
@@ skipping 56 matching lines @@
         }
         buffer.write("]");
         needsComma = true;
       }
       if (namedParameterTypes.length > 0) {
         if (needsComma) {
           buffer.write(", ");
           needsComma = false;
         }
         buffer.write("{");
-        for (MapEntry<String, DartType> entry in getMapEntrySet(namedParameterTypes)) {
+        namedParameterTypes.forEach((String name, DartType type) {
           if (needsComma) {
             buffer.write(", ");
           } else {
             needsComma = true;
           }
-          buffer.write(entry.getKey());
+          buffer.write(name);
           buffer.write(": ");
-          buffer.write(entry.getValue().displayName);
-        }
+          buffer.write(type.displayName);
+        });
         buffer.write("}");
         needsComma = true;
       }
       buffer.write(")");
       buffer.write(Element.RIGHT_ARROW);
       if (returnType == null) {
         buffer.write("null");
       } else {
         buffer.write(returnType.displayName);
       }
@@ skipping 166 matching lines @@
             return false;
           }
         }
       }
       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.
-      JavaIterator<MapEntry<String, DartType>> iteratorS = new JavaIterator(getMapEntrySet(namedTypesS));
-      while (iteratorS.hasNext) {
-        MapEntry<String, DartType> entryS = iteratorS.next();
-        DartType typeT = namedTypesT[entryS.getKey()];
+      // 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.
+      for (String keyS in namedTypesS.keys) {
+        DartType typeT = namedTypesT[keyS];
         if (typeT == null) {
           return false;
         }
-        if (!(typeT as TypeImpl).isMoreSpecificThan2(entryS.getValue(), withDynamic, visitedTypePairs)) {
+        if (!(typeT as TypeImpl).isMoreSpecificThan2(namedTypesS[keyS], 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 102 matching lines @@
       }
       buffer.write("]");
       needsComma = true;
     }
     if (namedParameterTypes.length > 0) {
       if (needsComma) {
         buffer.write(", ");
         needsComma = false;
       }
       buffer.write("{");
-      for (MapEntry<String, DartType> entry in getMapEntrySet(namedParameterTypes)) {
+      namedParameterTypes.forEach((String name, DartType type) {
         if (needsComma) {
           buffer.write(", ");
         } else {
           needsComma = true;
         }
-        buffer.write(entry.getKey());
+        buffer.write(name);
         buffer.write(": ");
-        (entry.getValue() as TypeImpl).appendTo(buffer);
-      }
+        (type as TypeImpl).appendTo(buffer);
+      });
       buffer.write("}");
       needsComma = true;
     }
     buffer.write(")");
     buffer.write(Element.RIGHT_ARROW);
     if (returnType == null) {
       buffer.write("null");
     } else {
       (returnType as TypeImpl).appendTo(buffer);
     }
@@ skipping 66 matching lines @@
             return false;
           }
         }
       }
       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.
-      JavaIterator<MapEntry<String, DartType>> iteratorS = new JavaIterator(getMapEntrySet(namedTypesS));
-      while (iteratorS.hasNext) {
-        MapEntry<String, DartType> entryS = iteratorS.next();
-        DartType typeT = namedTypesT[entryS.getKey()];
+      // 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.
+      for (String keyS in namedTypesS.keys) {
+        DartType typeT = namedTypesT[keyS];
         if (typeT == null) {
           return false;
         }
-        if (!(typeT as TypeImpl).isAssignableTo2(entryS.getValue(), visitedTypePairs)) {
+        if (!(typeT as TypeImpl).isAssignableTo2(namedTypesS[keyS], 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 5437 matching lines @@
       }
     }
     if (set.length == 0) {
       // TODO(collinsn): better to return [null] here? The use case is e.g.
       //
       //   union(null, null) ==> null;
       //
       // instead of raising an exception.
       throw new IllegalArgumentException("No known use case for empty unions.");
     } else if (set.length == 1) {
-      return new JavaIterator(set).next();
+      return set.first;
     } else {
       return new UnionTypeImpl(set);
     }
   }
 
   /**
    * The types in this union.
    */
   final Set<DartType> _types;
 
@@ skipping 490 matching lines @@
     if (type is UnionType) {
       return (type as UnionTypeImpl).internalUnionTypeIsSuperTypeOf(this, visitedTypePairs);
     }
     // The only subtype relations that pertain to void are therefore:
     // void <: void (by reflexivity)
     // 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;
   }
 }