Optimize AnalysisContext.getSourcesWithFullName().

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:collection';
 
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisEngine, CacheState, InternalAnalysisContext, RetentionPriority;
@@ skipping 93 matching lines @@
     // in which case the target should always be part of the SDK.
     //
     // TODO(brianwilkerson) Throw an exception here.
     AnalysisEngine.instance.logger.logInformation(
         'Could not find context for $target',
         new CaughtException(new AnalysisException(), null));
     return null;
   }
 
   /**
+   * 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 = <Source>[];
+    for (CachePartition partition in _partitions) {
+      List<Source> partitionSources = partition.getSourcesWithFullName(path);
+      sources.addAll(partitionSources);
+    }
+    return sources;
+  }
+
+  /**
    * Return the state of the given [result] for the given [target].
    *
    * It does not update the cache, if the corresponding [CacheEntry] does not
    * exist, then [CacheState.INVALID] is returned.
    */
   CacheState getState(AnalysisTarget target, ResultDescriptor result) {
     CacheEntry entry = get(target);
     if (entry == null) {
       return CacheState.INVALID;
     }
@@ skipping 597 matching lines @@
    */
   HashMap<AnalysisTarget, CacheEntry> _targetMap =
       new HashMap<AnalysisTarget, CacheEntry>();
 
   /**
    * A set of the [Source] targets.
    */
   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>>{};
+
+  /**
    * 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;
 
   /**
    * Return the entry associated with the given [target].
    */
   CacheEntry get(AnalysisTarget target) => _targetMap[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];
+    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);
@@ skipping 59 matching lines @@
    * Return the number of targets that are mapped to cache entries.
    */
   int size() => _targetMap.length;
 
   /**
    * If the given [target] is a [Source], adds it to [_sources].
    */
   void _addIfSource(AnalysisTarget target) {
     if (target is Source) {
       _sources.add(target);
+      {
+        String fullName = target.fullName;
+        _pathToSources.putIfAbsent(fullName, () => <Source>[]).add(target);
+      }
     }
   }
 
   ResultData _getDataFor(TargetedResult result, {bool orNull: false}) {
     CacheEntry entry = context.analysisCache.get(result.target);
     if (orNull) {
       return entry != null ? entry._resultMap[result.result] : null;
     } else {
       return entry._getResultData(result.result);
     }
@@ skipping 11 matching lines @@
   bool _isPriorityAnalysisTarget(AnalysisTarget target) {
     return context.priorityTargets.contains(target);
   }
 
   /**
    * If the given [target] is a [Source], removes it from [_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);
+          }
+        }
+      }
     }
   }
 }
 
 /**
  * The data about a single analysis result that is stored in a [CacheEntry].
  */
 // TODO(brianwilkerson) Consider making this a generic class so that the value
 // can be typed.
 class ResultData {
@@ skipping 107 matching lines @@
 class UniversalCachePartition extends CachePartition {
   /**
    * Initialize a newly created cache partition, belonging to the given
    * [context].
    */
   UniversalCachePartition(InternalAnalysisContext context) : super(context);
 
   @override
   bool isResponsibleFor(AnalysisTarget target) => true;
 }