Clean source maps during partition dispose.

pkg/analyzer/lib/src/context/cache.dart

 // Copyright (c) 2015, 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.
 
 library analyzer.src.context.cache;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/engine.dart'
@@ skipping 48 matching lines @@
       });
       onResultInvalidatedPartitionSubscriptions.add(subscription);
     }
   }
 
   /**
    * Return an iterator returning all of the [Source] targets.
    */
   Iterable<Source> get sources {
     return _partitions
-        .map((CachePartition partition) => partition._sources)
+        .map((CachePartition partition) => partition.sources)
         .expand((Iterable<Source> sources) => sources);
   }
 
   // TODO(brianwilkerson) Implement or delete this.
 //  /**
 //   * Return information about each of the partitions in this cache.
 //   */
 //  List<AnalysisContextStatistics_PartitionData> get partitionData {
 //    int count = _partitions.length;
 //    List<AnalysisContextStatistics_PartitionData> data =
@@ skipping 104 matching lines @@
    * Return an iterator returning all of the map entries mapping targets to
    * cache entries. If the [context] is not `null`, then only entries that are
    * owned by the given context will be returned.
    */
   MapIterator<AnalysisTarget, CacheEntry> iterator(
       {InternalAnalysisContext context: null}) {
     List<Map<AnalysisTarget, CacheEntry>> maps =
         <Map<AnalysisTarget, CacheEntry>>[];
     for (CachePartition partition in _partitions) {
       if (context == null || partition.context == context) {
-        maps.add(partition.map);
+        maps.add(partition.entryMap);
       }
     }
     return new MultipleMapIterator<AnalysisTarget, CacheEntry>(maps);
   }
 
   /**
    * Puts the given [entry] into the cache.
    */
   void put(CacheEntry entry) {
     AnalysisTarget target = entry.target;
@@ skipping 373 matching lines @@
     for (TargetedResult dependedOnResult in thisData.dependedOnResults) {
       ResultData data = _partition._getDataFor(dependedOnResult);
       if (data != null && deltaResult != DeltaResult.KEEP_CONTINUE) {
         data.dependentResults.remove(thisResult);
       }
     }
     // Invalidate results that depend on this result.
     _invalidateDependentResults(id, thisData, delta, level + 1);
     // If empty and not explicitly added, remove the entry altogether.
     if (_resultMap.isEmpty && !explicitlyAdded) {
-      _partition._targetMap.remove(target);
+      _partition.entryMap.remove(target);
       _partition._removeIfSource(target);
     }
     // Notify controller.
     _partition.onResultInvalidated
         .add(new InvalidatedResult(this, descriptor, thisData.value));
   }
 
   /**
    * Invalidates all the results of this entry, with propagation.
    */
@@ skipping 252 matching lines @@
   /**
    * The [StreamController] reporting [InvalidatedResult]s.
    */
   final ReentrantSynchronousStream<InvalidatedResult> onResultInvalidated =
       new ReentrantSynchronousStream<InvalidatedResult>();
 
   /**
    * A table mapping the targets belonging to this partition to the information
    * known about those targets.
    */
-  HashMap<AnalysisTarget, CacheEntry> _targetMap =
+  final HashMap<AnalysisTarget, CacheEntry> entryMap =
       new HashMap<AnalysisTarget, CacheEntry>();
 
   /**
    * A set of the [Source] targets.
    */
-  final HashSet<Source> _sources = new HashSet<Source>();
+  final HashSet<Source> sources = new HashSet<Source>();
 
   /**
    * A table mapping full paths to lists of [Source]s with these full paths.
    */
-  final Map<String, List<Source>> _pathToSources = <String, List<Source>>{};
+  final Map<String, List<Source>> pathToSource = <String, List<Source>>{};
 
   /**
    * Initialize a newly created cache partition, belonging to the given
    * [context].
    */
   CachePartition(this.context);
 
   /**
-   * Return a table mapping the targets known to the context to the information
-   * known about the target.
-   *
-   * <b>Note:</b> This method is only visible for use by [AnalysisCache] and
-   * should not be used for any other purpose.
-   */
-  Map<AnalysisTarget, CacheEntry> get map => _targetMap;
-
-  /**
    * Notifies the partition that the client is going to stop using it.
    */
   void dispose() {
-    for (CacheEntry entry in _targetMap.values) {
+    for (CacheEntry entry in entryMap.values) {
       entry.dispose();
     }
-    _targetMap.clear();
+    entryMap.clear();
+    sources.clear();
+    pathToSource.clear();
   }
 
   /**
    * Return the entry associated with the given [target].
    */
-  CacheEntry get(AnalysisTarget target) => _targetMap[target];
+  CacheEntry get(AnalysisTarget target) => entryMap[target];
 
   /**
    * Return [Source]s whose full path is equal to the given [path].
    * Maybe empty, but not `null`.
    */
   List<Source> getSourcesWithFullName(String path) {
-    List<Source> sources = _pathToSources[path];
+    List<Source> sources = pathToSource[path];
     return sources != null ? sources : Source.EMPTY_LIST;
   }
 
   /**
    * Return `true` if this partition is responsible for the given [target].
    */
   bool isResponsibleFor(AnalysisTarget target);
 
   /**
    * Return an iterator returning all of the map entries mapping targets to
    * cache entries.
    */
   MapIterator<AnalysisTarget, CacheEntry> iterator() =>
-      new SingleMapIterator<AnalysisTarget, CacheEntry>(_targetMap);
+      new SingleMapIterator<AnalysisTarget, CacheEntry>(entryMap);
 
   /**
    * Puts the given [entry] into the partition.
    */
   void put(CacheEntry entry) {
     AnalysisTarget target = entry.target;
     if (entry._partition != null) {
       throw new StateError(
           'The entry for $target is already in ${entry._partition}');
     }
     entry._partition = this;
     entry.fixExceptionState();
-    _targetMap[target] = entry;
+    entryMap[target] = entry;
     _addIfSource(target);
   }
 
   /**
    * Remove all information related to the given [target] from this partition.
    * Return the entry associated with the target, or `null` if there was cache
    * entry for the target.
    */
   CacheEntry remove(AnalysisTarget target) {
     for (CacheFlushManager flushManager in _flushManagerMap.values) {
       flushManager.targetRemoved(target);
     }
-    CacheEntry entry = _targetMap.remove(target);
+    CacheEntry entry = entryMap.remove(target);
     if (entry != null) {
       entry._invalidateAll();
     }
     _removeIfSource(target);
     return entry;
   }
 
   /**
    * Records that a value of the result described by the given [descriptor]
    * for the given [target] was just read from the cache.
@@ skipping 18 matching lines @@
         if (data != null) {
           data.flush();
         }
       }
     }
   }
 
   /**
    * Return the number of targets that are mapped to cache entries.
    */
-  int size() => _targetMap.length;
+  int size() => entryMap.length;
 
   /**
-   * If the given [target] is a [Source], adds it to [_sources].
+   * If the given [target] is a [Source], adds it to [sources].
    */
   void _addIfSource(AnalysisTarget target) {
     if (target is Source) {
-      _sources.add(target);
+      sources.add(target);
       String fullName = target.fullName;
-      _pathToSources.putIfAbsent(fullName, () => <Source>[]).add(target);
+      pathToSource.putIfAbsent(fullName, () => <Source>[]).add(target);
     }
   }
 
   ResultData _getDataFor(TargetedResult result) {
     CacheEntry entry = context.analysisCache.get(result.target);
     return entry != null ? entry._resultMap[result.result] : null;
   }
 
   /**
    * Return the [CacheFlushManager] for the given [descriptor], not `null`.
    */
   CacheFlushManager _getFlushManager(ResultDescriptor descriptor) {
     ResultCachingPolicy policy = descriptor.cachingPolicy;
     if (identical(policy, DEFAULT_CACHING_POLICY)) {
       return UnlimitedCacheFlushManager.INSTANCE;
     }
     CacheFlushManager manager = _flushManagerMap[policy];
     if (manager == null) {
       manager = new CacheFlushManager(policy, _isPriorityAnalysisTarget);
       _flushManagerMap[policy] = manager;
     }
     return manager;
   }
 
   bool _isPriorityAnalysisTarget(AnalysisTarget target) {
     return context.priorityTargets.contains(target);
   }
 
   /**
-   * If the given [target] is a [Source], remove it from the list of [_sources].
+   * If the given [target] is a [Source], remove it from the list of [sources].
    */
   void _removeIfSource(AnalysisTarget target) {
     if (target is Source) {
-      _sources.remove(target);
-      String fullName = target.fullName;
-      List<Source> sources = _pathToSources[fullName];
-      if (sources != null) {
-        sources.remove(target);
-        if (sources.isEmpty) {
-          _pathToSources.remove(fullName);
+      sources.remove(target);
+      String path = target.fullName;
+      List<Source> pathSources = pathToSource[path];
+      if (pathSources != null) {
+        pathSources.remove(target);
+        if (pathSources.isEmpty) {
+          pathToSource.remove(path);
         }
       }
     }
   }
 }
 
 /**
  * The description for a change.
  */
 class Delta {
@@ skipping 215 matching lines @@
   void resultAccessed(TargetedResult result) {}
 
   @override
   List<TargetedResult> resultStored(TargetedResult newResult, newValue) {
     return TargetedResult.EMPTY_LIST;
   }
 
   @override
   void targetRemoved(AnalysisTarget target) {}
 }