New analyzer snapshot.

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';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'utilities_collection.dart';
 import 'utilities_general.dart';
 import 'instrumentation.dart';
 import 'error.dart';
 import 'source.dart';
 import 'scanner.dart';
 import 'ast.dart';
 import 'parser.dart' show Parser, IncrementalParser;
 import 'sdk.dart' show DartSdk;
+import 'constant.dart';
 import 'element.dart';
 import 'resolver.dart';
 import 'html.dart' as ht;
-import 'package:analyzer/src/generated/constant.dart';
 
 /**
  * Instances of the class `AnalysisCache` implement an LRU cache of information related to
  * analysis.
  */
 class AnalysisCache {
   /**
    * An array containing the partitions of which this cache is comprised.
    */
   final List<CachePartition> _partitions;
@@ skipping 831 matching lines @@
   /**
    * An array containing sources whose AST structure is needed in order to resolve the next library
    * to be resolved.
    */
   Set<Source> _neededForResolution = null;
 
   /**
    * A table mapping sources to the change notices that are waiting to be returned related to that
    * source.
    */
-  Map<Source, ChangeNoticeImpl> _pendingNotices = new Map<Source, ChangeNoticeImpl>();
+  HashMap<Source, ChangeNoticeImpl> _pendingNotices = new HashMap<Source, ChangeNoticeImpl>();
 
   /**
    * A set containing information about the tasks that have been performed since the last change
    * notification. Used to detect infinite loops in [performAnalysisTask].
    */
   Set<String> _recentTasks = new Set<String>();
 
   /**
    * The object used to synchronize access to all of the caches. The rules related to the use of
    * this lock object are
@@ skipping 2733 matching lines @@
       }
     }
   }
 
   /**
    * Invalidate all of the resolution results computed by this context.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    */
   void _invalidateAllLocalResolutionInformation() {
-    Map<Source, List<Source>> oldPartMap = new Map<Source, List<Source>>();
+    HashMap<Source, List<Source>> oldPartMap = new HashMap<Source, List<Source>>();
     MapIterator<Source, SourceEntry> iterator = _privatePartition.iterator();
     while (iterator.moveNext()) {
       Source source = iterator.key;
       SourceEntry sourceEntry = iterator.value;
       if (sourceEntry is HtmlEntry) {
         HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
         htmlCopy.invalidateAllResolutionInformation();
         iterator.value = htmlCopy;
       } else if (sourceEntry is DartEntry) {
         DartEntry dartEntry = sourceEntry;
@@ skipping 390 matching lines @@
    * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry _recordGenerateDartHintsTask(GenerateDartHintsTask task) {
     Source librarySource = task.libraryElement.source;
     CaughtException thrownException = task.exception;
     DartEntry libraryEntry = null;
-    Map<Source, TimestampedData<List<AnalysisError>>> hintMap = task.hintMap;
+    HashMap<Source, TimestampedData<List<AnalysisError>>> hintMap = task.hintMap;
     if (hintMap == null) {
       // We don't have any information about which sources to mark as invalid other than the library
       // source.
       SourceEntry sourceEntry = _cache.get(librarySource);
       if (sourceEntry == null) {
         throw new ObsoleteSourceAnalysisException(librarySource);
       } else if (sourceEntry is! DartEntry) {
         // This shouldn't be possible because we should never have performed the task if the source
         // didn't represent a Dart file, but check to be safe.
         throw new AnalysisException("Internal error: attempting to generate hints for non-Dart file as a Dart file: ${librarySource.fullName}");
@@ skipping 890 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(Map<Source, List<Source>> oldPartMap) {
+  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();
       for (int i = 0; i < oldParts.length; i++) {
         Source partSource = oldParts[i];
         if (partSource != librarySource) {
           DartEntry partEntry = _getReadableDartEntry(partSource);
           if (partEntry != null) {
             DartEntryImpl partCopy = partEntry.writableCopy;
             partCopy.removeContainingLibrary(librarySource);
@@ skipping 291 matching lines @@
  * Instances of the class `CycleBuilder` are used to construct a list of the libraries that
  * must be resolved together in order to resolve any one of the libraries.
  */
 class AnalysisContextImpl_CycleBuilder {
   final AnalysisContextImpl AnalysisContextImpl_this;
 
   /**
    * A table mapping the sources of the defining compilation units of libraries to the
    * representation of the library that has the information needed to resolve the library.
    */
-  Map<Source, ResolvableLibrary> _libraryMap = new Map<Source, ResolvableLibrary>();
+  HashMap<Source, ResolvableLibrary> _libraryMap = new HashMap<Source, ResolvableLibrary>();
 
   /**
    * The dependency graph used to compute the libraries in the cycle.
    */
   DirectedGraph<ResolvableLibrary> _dependencyGraph;
 
   /**
    * A list containing the libraries that are ready to be resolved.
    */
   List<ResolvableLibrary> _librariesInCycle;
@@ skipping 502 matching lines @@
   /**
    * Return an array containing all of the sources in the cache.
    */
   List<Source> get sources;
 }
 
 /**
  * Implementation of the [AnalysisContextStatistics].
  */
 class AnalysisContextStatisticsImpl implements AnalysisContextStatistics {
-  Map<String, AnalysisContextStatistics_CacheRow> _dataMap = new Map<String, AnalysisContextStatistics_CacheRow>();
+  Map<String, AnalysisContextStatistics_CacheRow> _dataMap = new HashMap<String, AnalysisContextStatistics_CacheRow>();
 
   List<Source> _sources = new List<Source>();
 
   Set<CaughtException> _exceptions = new Set<CaughtException>();
 
   List<AnalysisContextStatistics_PartitionData> _partitionData;
 
   void addSource(Source source) {
     _sources.add(source);
   }
@@ skipping 160 matching lines @@
 }
 
 /**
  * Instances of the class `AnalysisDelta` indicate changes to the types of analysis that
  * should be performed.
  */
 class AnalysisDelta {
   /**
    * A mapping from source to what type of analysis should be performed on that source.
    */
-  Map<Source, AnalysisLevel> _analysisMap = new Map<Source, AnalysisLevel>();
+  HashMap<Source, AnalysisLevel> _analysisMap = new HashMap<Source, AnalysisLevel>();
 
   /**
    * Return a collection of the sources that have been added. This is equivalent to calling
    * [getAnalysisLevels] and collecting all sources that do not have an analysis level of
    * [AnalysisLevel#NONE].
    *
    * @return a collection of the sources
    */
   Iterable<Source> get addedSources {
     List<Source> result = new List<Source>();
@@ skipping 1659 matching lines @@
   Source _coreLibrarySource;
 
   /**
    * The object representing the core library.
    */
   ResolvableLibrary _coreLibrary;
 
   /**
    * A table mapping library sources to the information being maintained for those libraries.
    */
-  Map<Source, ResolvableLibrary> _libraryMap = new Map<Source, ResolvableLibrary>();
+  HashMap<Source, ResolvableLibrary> _libraryMap = new HashMap<Source, ResolvableLibrary>();
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param targetLibrary the library for which an element model was originally requested
    * @param librariesInCycle the libraries that are part of the cycle to be resolved
    */
   BuildDartElementModelTask(InternalAnalysisContext context, this.targetLibrary, this.librariesInCycle) : super(context) {
     this._errorListener = new RecordingErrorListener();
@@ skipping 93 matching lines @@
   /**
    * Every library now has a corresponding [LibraryElement], so it is now possible to resolve
    * the import and export directives.
    *
    * @throws AnalysisException if the defining compilation unit for any of the libraries could not
    *           be accessed
    */
   void _buildDirectiveModels() {
     AnalysisContext analysisContext = context;
     for (ResolvableLibrary library in librariesInCycle) {
-      Map<String, PrefixElementImpl> nameToPrefixMap = new Map<String, PrefixElementImpl>();
+      HashMap<String, PrefixElementImpl> nameToPrefixMap = new HashMap<String, PrefixElementImpl>();
       List<ImportElement> imports = new List<ImportElement>();
       List<ExportElement> exports = new List<ExportElement>();
       for (Directive directive in library.definingCompilationUnit.directives) {
         if (directive is ImportDirective) {
           ImportDirective importDirective = directive;
           String uriContent = importDirective.uriContent;
           if (DartUriResolver.isDartExtUri(uriContent)) {
             library.libraryElement.hasExtUri = true;
           }
           Source importedSource = importDirective.source;
@@ skipping 92 matching lines @@
       LibraryElementImpl libraryElement = builder.buildLibrary2(library);
       library.libraryElement = libraryElement;
     }
   }
 
   /**
    * Build a table mapping library sources to the resolvable libraries representing those libraries.
    *
    * @return the map that was built
    */
-  Map<Source, ResolvableLibrary> _buildLibraryMap() {
-    Map<Source, ResolvableLibrary> libraryMap = new Map<Source, ResolvableLibrary>();
+  HashMap<Source, ResolvableLibrary> _buildLibraryMap() {
+    HashMap<Source, ResolvableLibrary> libraryMap = new HashMap<Source, ResolvableLibrary>();
     int libraryCount = librariesInCycle.length;
     for (int i = 0; i < libraryCount; i++) {
       ResolvableLibrary library = librariesInCycle[i];
       library.errorListener = _errorListener;
       libraryMap[library.librarySource] = library;
       List<ResolvableLibrary> dependencies = library.importsAndExports;
       int dependencyCount = dependencies.length;
       for (int j = 0; j < dependencyCount; j++) {
         ResolvableLibrary dependency = dependencies[j];
         //dependency.setErrorListener(errorListener);
@@ skipping 42 matching lines @@
 }
 
 /**
  * Instances of the class `CachePartition` implement a single partition in an LRU cache of
  * information related to analysis.
  */
 abstract class CachePartition {
   /**
    * A table mapping the sources known to the context to the information known about the source.
    */
-  Map<Source, SourceEntry> _sourceMap = new Map<Source, SourceEntry>();
+  HashMap<Source, SourceEntry> _sourceMap = new HashMap<Source, SourceEntry>();
 
   /**
    * The maximum number of sources for which AST structures should be kept in the cache.
    */
   int _maxCacheSize = 0;
 
   /**
    * The policy used to determine which pieces of data to remove from the cache.
    */
   final CacheRetentionPolicy _retentionPolicy;
@@ skipping 401 matching lines @@
 
   /**
    * A list containing the sources that have been changed.
    */
   final List<Source> changedSources = new List<Source>();
 
   /**
    * A table mapping the sources whose content has been changed to the current content of those
    * sources.
    */
-  Map<Source, String> _changedContent = new Map<Source, String>();
+  HashMap<Source, String> _changedContent = new HashMap<Source, String>();
 
   /**
    * A table mapping the sources whose content has been changed within a single range to the current
    * content of those sources and information about the affected range.
    */
-  final Map<Source, ChangeSet_ContentChange> changedRanges = new Map<Source, ChangeSet_ContentChange>();
+  final HashMap<Source, ChangeSet_ContentChange> changedRanges = new HashMap<Source, ChangeSet_ContentChange>();
 
   /**
    * A list containing the sources that have been removed.
    */
   final List<Source> removedSources = new List<Source>();
 
   /**
    * A list containing the source containers specifying additional sources that have been removed.
    */
   final List<SourceContainer> removedContainers = new List<SourceContainer>();
@@ skipping 151 matching lines @@
   /**
    * Append the given sources to the given builder, prefixed with the given label and possibly a
    * separator.
    *
    * @param builder the builder to which the sources are to be appended
    * @param sources the sources to be appended
    * @param needsSeparator `true` if a separator is needed before the label
    * @param label the label used to prefix the sources
    * @return `true` if future lists of sources will need a separator
    */
-  bool _appendSources2(JavaStringBuilder builder, Map<Source, dynamic> sources, bool needsSeparator, String label) {
+  bool _appendSources2(JavaStringBuilder builder, HashMap<Source, dynamic> sources, bool needsSeparator, String label) {
     if (sources.isEmpty) {
       return needsSeparator;
     }
     if (needsSeparator) {
       builder.append("; ");
     }
     builder.append(label);
     String prefix = " ";
     for (Source source in sources.keys.toSet()) {
       builder.append(prefix);
@@ skipping 1921 matching lines @@
 
   /**
    * The element model for the library being analyzed.
    */
   final LibraryElement libraryElement;
 
   /**
    * A table mapping the sources that were analyzed to the hints that were generated for the
    * sources.
    */
-  Map<Source, TimestampedData<List<AnalysisError>>> _hintMap;
+  HashMap<Source, TimestampedData<List<AnalysisError>>> _hintMap;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param units the compilation units that comprise the library, with the defining compilation
    *          unit appearing first in the array
    * @param libraryElement the element model for the library being analyzed
    */
   GenerateDartHintsTask(InternalAnalysisContext context, this._units, this.libraryElement) : super(context);
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitGenerateDartHintsTask(this);
 
   /**
    * Return a table mapping the sources that were analyzed to the hints that were generated for the
    * sources, or `null` if the task has not been performed or if the analysis did not complete
    * normally.
    *
    * @return a table mapping the sources that were analyzed to the hints that were generated for the
    *         sources
    */
-  Map<Source, TimestampedData<List<AnalysisError>>> get hintMap => _hintMap;
+  HashMap<Source, TimestampedData<List<AnalysisError>>> get hintMap => _hintMap;
 
   @override
   String get taskDescription {
     Source librarySource = libraryElement.source;
     if (librarySource == null) {
       return "generate Dart hints for library without source";
     }
     return "generate Dart hints for ${librarySource.fullName}";
   }
 
   @override
   void internalPerform() {
     //
     // Gather the compilation units.
     //
     int unitCount = _units.length;
     List<CompilationUnit> compilationUnits = new List<CompilationUnit>(unitCount);
     for (int i = 0; i < unitCount; i++) {
       compilationUnits[i] = _units[i].data;
     }
     //
     // Analyze all of the units.
     //
     RecordingErrorListener errorListener = new RecordingErrorListener();
     HintGenerator hintGenerator = new HintGenerator(compilationUnits, context, errorListener);
     hintGenerator.generateForLibrary();
     //
     // Store the results.
     //
-    _hintMap = new Map<Source, TimestampedData<List<AnalysisError>>>();
+    _hintMap = new HashMap<Source, TimestampedData<List<AnalysisError>>>();
     for (int i = 0; i < unitCount; i++) {
       int modificationTime = _units[i].modificationTime;
       Source source = _units[i].data.element.source;
       List<AnalysisError> errors = errorListener.getErrorsForSource(source);
       _hintMap[source] = new TimestampedData<List<AnalysisError>>(modificationTime, errors);
     }
   }
 }
 
 /**
@@ skipping 2519 matching lines @@
 }
 
 /**
  * Instances of the class `PartitionManager` manage the partitions that can be shared between
  * analysis contexts.
  */
 class PartitionManager {
   /**
    * A table mapping SDK's to the partitions used for those SDK's.
    */
-  Map<DartSdk, SdkCachePartition> _sdkPartitions = new Map<DartSdk, SdkCachePartition>();
+  HashMap<DartSdk, SdkCachePartition> _sdkPartitions = new HashMap<DartSdk, SdkCachePartition>();
 
   /**
    * The default cache size for a Dart SDK partition.
    */
   static int _DEFAULT_SDK_CACHE_SIZE = 256;
 
   /**
    * Return the partition being used for the given SDK, creating the partition if necessary.
    *
    * @param sdk the SDK for which a partition is being requested
@@ skipping 562 matching lines @@
 
 /**
  * Instances of the class `RecordingErrorListener` implement an error listener that will
  * record the errors that are reported to it in a way that is appropriate for caching those errors
  * within an analysis context.
  */
 class RecordingErrorListener implements AnalysisErrorListener {
   /**
    * A HashMap of lists containing the errors that were collected, keyed by each [Source].
    */
-  Map<Source, Set<AnalysisError>> _errors = new Map<Source, Set<AnalysisError>>();
+  Map<Source, Set<AnalysisError>> _errors = new HashMap<Source, Set<AnalysisError>>();
 
   /**
    * Add all of the errors recorded by the given listener to this listener.
    *
    * @param listener the listener that has recorded the errors to be added
    */
   void addAll(RecordingErrorListener listener) {
     for (AnalysisError error in listener.errors) {
       onError(error);
     }
@@ skipping 1699 matching lines @@
     _index++;
     if (_index >= WorkManager_this._workQueues[_queueIndex].length) {
       _index = 0;
       _queueIndex++;
       while (_queueIndex < WorkManager_this._workQueues.length && WorkManager_this._workQueues[_queueIndex].isEmpty) {
         _queueIndex++;
       }
     }
   }
 }