Remove JavaIterator and MapEntry

pkg/analyzer/lib/src/generated/engine.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;
 
 import 'dart:collection';
@@ skipping 985 matching lines @@
   @override
   void addSourceInfo(Source source, SourceEntry info) {
     // This implementation assumes that the access to the cache does not need to be synchronized
     // because no other object can have access to this context while this method is being invoked.
     _cache.put(source, info);
   }
 
   @override
   void applyAnalysisDelta(AnalysisDelta delta) {
     ChangeSet changeSet = new ChangeSet();
-    for (MapEntry<Source, AnalysisLevel> entry in getMapEntrySet(delta.analysisLevels)) {
-      Source source = entry.getKey();
-      if (entry.getValue() == AnalysisLevel.NONE) {
+    delta.analysisLevels.forEach((Source source, AnalysisLevel level) {
+      if (level == AnalysisLevel.NONE) {
         changeSet.removedSource(source);
       } else {
         changeSet.addedSource(source);
       }
-    }
+    });
     applyChanges(changeSet);
   }
 
   @override
   void applyChanges(ChangeSet changeSet) {
     if (changeSet.isEmpty) {
       return;
     }
     //
     // First, compute the list of sources that have been removed.
@@ skipping 12 matching lines @@
       }
     }
     for (Source source in changeSet.changedSources) {
       if (_contentCache.getContents(source) != null) {
         // This source is overridden in the content cache, so the change will have no effect.
         // Just ignore it to avoid wasting time doing re-analysis.
         continue;
       }
       _sourceChanged(source);
     }
-    for (MapEntry<Source, String> entry in getMapEntrySet(changeSet.changedContents)) {
-      setContents(entry.getKey(), entry.getValue());
-    }
-    for (MapEntry<Source, ChangeSet_ContentChange> entry in getMapEntrySet(changeSet.changedRanges)) {
-      ChangeSet_ContentChange change = entry.getValue();
-      setChangedContents(entry.getKey(), change.contents, change.offset, change.oldLength, change.newLength);
-    }
+    changeSet.changedContents.forEach((Source key, String value) {
+      setContents(key, value);
+    });
+    changeSet.changedRanges.forEach((Source source, ChangeSet_ContentChange change) {
+      setChangedContents(
+          source,
+          change.contents,
+          change.offset,
+          change.oldLength,
+          change.newLength);
+    });
     for (Source source in changeSet.deletedSources) {
       _sourceDeleted(source);
     }
     for (Source source in removedSources) {
       _sourceRemoved(source);
     }
     if (addedDartSource) {
       // TODO(brianwilkerson) This is hugely inefficient, but we need to re-analyze any libraries
       // that might have been referencing the not-yet-existing source that was just added. Longer
       // term we need to keep track of which libraries are referencing non-existing sources and
@@ skipping 685 matching lines @@
       //        notifyResolvedHtml(source, notice.getHtmlUnit());
       //      }
       _notifyErrors(source, notice.errors, notice.lineInfo);
     }
     return new AnalysisResult(notices, getEnd - getStart, task.runtimeType.toString(), performEnd - performStart);
   }
 
   @override
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     Source htmlSource = _sourceFactory.forUri(DartSdk.DART_HTML);
-    for (MapEntry<Source, LibraryElement> entry in getMapEntrySet(elementMap)) {
-      Source librarySource = entry.getKey();
-      LibraryElement library = entry.getValue();
+    elementMap.forEach((Source librarySource, LibraryElement library) {
       //
       // Cache the element in the library's info.
       //
       DartEntry dartEntry = _getReadableDartEntry(librarySource);
       if (dartEntry != null) {
         _recordElementData(dartEntry, library, library.source, htmlSource);
         dartEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
         dartEntry.setValue(SourceEntry.LINE_INFO, new LineInfo(<int> [0]));
         dartEntry.setValue(DartEntry.ANGULAR_ERRORS, AnalysisError.NO_ERRORS);
         // DartEntry.ELEMENT - set in recordElementData
         dartEntry.setValue(DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
         dartEntry.setValue(DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
         dartEntry.setValue(DartEntry.INCLUDED_PARTS, Source.EMPTY_ARRAY);
         // DartEntry.IS_CLIENT - set in recordElementData
         // DartEntry.IS_LAUNCHABLE - set in recordElementData
         dartEntry.setValue(DartEntry.PARSE_ERRORS, AnalysisError.NO_ERRORS);
         dartEntry.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
         dartEntry.setState(DartEntry.PUBLIC_NAMESPACE, CacheState.FLUSHED);
         dartEntry.setValue(DartEntry.SCAN_ERRORS, AnalysisError.NO_ERRORS);
         dartEntry.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
         dartEntry.setState(DartEntry.TOKEN_STREAM, CacheState.FLUSHED);
         dartEntry.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource, AnalysisError.NO_ERRORS);
         dartEntry.setStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource, CacheState.FLUSHED);
         dartEntry.setValueInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, AnalysisError.NO_ERRORS);
         dartEntry.setValueInLibrary(DartEntry.HINTS, librarySource, AnalysisError.NO_ERRORS);
       }
-    }
+    });
   }
 
   @override
   void removeListener(AnalysisListener listener) {
     _listeners.remove(listener);
   }
 
   @override
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library) {
     if (library == null) {
@@ skipping 2425 matching lines @@
 
   /**
    * Remove the given libraries that are keys in the given map from the list of containing libraries
    * for each of the parts in the corresponding value.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param oldPartMap the table containing the parts associated with each library
    */
   void _removeFromPartsUsingMap(HashMap<Source, List<Source>> oldPartMap) {
-    for (MapEntry<Source, List<Source>> entry in getMapEntrySet(oldPartMap)) {
-      Source librarySource = entry.getKey();
-      List<Source> oldParts = entry.getValue();
+    oldPartMap.forEach((Source librarySource, List<Source> oldParts) {
       for (int i = 0; i < oldParts.length; i++) {
         Source partSource = oldParts[i];
         if (partSource != librarySource) {
           DartEntry partEntry = _getReadableDartEntry(partSource);
           if (partEntry != null) {
             partEntry.removeContainingLibrary(librarySource);
             if (partEntry.containingLibraries.length == 0 && !exists(partSource)) {
               _cache.remove(partSource);
             }
           }
         }
       }
-    }
+    });
   }
 
   /**
    * Remove the given source from the priority order if it is in the list.
    *
    * @param source the source to be removed
    */
   void _removeFromPriorityOrder(Source source) {
     int count = _priorityOrder.length;
     List<Source> newOrder = new List<Source>();
@@ skipping 1054 matching lines @@
     _appendSources(buffer, needsSeparator, AnalysisLevel.NONE);
     return buffer.toString();
   }
 
   /**
    * Appendto the given [builder] all sources with the given analysis [level],
    * prefixed with a label and a separator if [needsSeparator] is `true`.
    */
   bool _appendSources(StringBuffer buffer, bool needsSeparator, AnalysisLevel level) {
     bool first = true;
-    for (MapEntry<Source, AnalysisLevel> entry in getMapEntrySet(_analysisMap)) {
-      if (entry.getValue() == level) {
+    _analysisMap.forEach((Source source, AnalysisLevel sourceLevel) {
+      if (sourceLevel == level) {
         if (first) {
           first = false;
           if (needsSeparator) {
             buffer.write("; ");
           }
           buffer.write(level);
           buffer.write(" ");
         } else {
           buffer.write(", ");
         }
-        buffer.write(entry.getKey().fullName);
+        buffer.write(source.fullName);
       }
-    }
+    });
     return needsSeparator || !first;
   }
 }
 
 /**
  * The unique instance of the class `AnalysisEngine` serves as the entry point for the
  * functionality provided by the analysis engine.
  */
 class AnalysisEngine {
   /**
@@ skipping 6275 matching lines @@
       onError(error);
     }
   }
 
   /**
    * Answer the errors collected by the listener.
    *
    * @return an array of errors (not `null`, contains no `null`s)
    */
   List<AnalysisError> get errors {
-    Iterable<MapEntry<Source, HashSet<AnalysisError>>> entrySet = getMapEntrySet(_errors);
-    int numEntries = entrySet.length;
+    int numEntries = _errors.length;
     if (numEntries == 0) {
       return AnalysisError.NO_ERRORS;
     }
     List<AnalysisError> resultList = new List<AnalysisError>();
-    for (MapEntry<Source, HashSet<AnalysisError>> entry in entrySet) {
-      resultList.addAll(entry.getValue());
+    for (HashSet<AnalysisError> errors in _errors.values) {
+      resultList.addAll(errors);
     }
     return new List.from(resultList);
   }
 
   /**
    * Answer the errors collected by the listener for some passed [Source].
    *
    * @param source some [Source] for which the caller wants the set of [AnalysisError]s
    *          collected by this listener
    * @return the errors collected by the listener for the passed [Source]
@@ skipping 1824 matching lines @@
     _index++;
     if (_index >= _manager._workQueues[_queueIndex].length) {
       _index = 0;
       _queueIndex++;
       while (_queueIndex < _manager._workQueues.length && _manager._workQueues[_queueIndex].isEmpty) {
         _queueIndex++;
       }
     }
   }
 }