Manage 'libraries containing part' in DartWorkManager.

pkg/analyzer/lib/src/task/dart_work_manager.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.task.dart_work_manager;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/engine.dart'
@@ skipping 49 matching lines @@
    * The sources whose kind we don't know yet.
    */
   final LinkedHashSet<Source> unknownSourceQueue = new LinkedHashSet<Source>();
 
   /**
    * The queue of library sources to process.
    */
   final LinkedHashSet<Source> librarySourceQueue = new LinkedHashSet<Source>();
 
   /**
+   * A table mapping library sources to the part sources they include.
+   */
+  final HashMap<Source, List<Source>> libraryPartsMap =

[Brian Wilkerson, 2015/05/22 16:05:42]

Aren't we already keeping this in the cache? Why would we duplicate the
information?

+      new HashMap<Source, List<Source>>();
+
+  /**
+   * A table mapping part sources to the library sources that include them.
+   */
+  final HashMap<Source, List<Source>> partLibrariesMap =
+      new HashMap<Source, List<Source>>();
+
+  /**
    * Initialize a newly created manager.
    */
   DartWorkManager(this.context);
 
   /**
    * Returns the correctly typed result of `context.analysisCache`.
    */
   AnalysisCache get analysisCache => context.analysisCache;
 
   /**
@@ skipping 12 matching lines @@
     addedSources = addedSources.where(_isDartSource).toList();
     changedSources = changedSources.where(_isDartSource).toList();
     removedSources = removedSources.where(_isDartSource).toList();
     // unknown queue
     unknownSourceQueue.addAll(addedSources);
     unknownSourceQueue.addAll(changedSources);
     unknownSourceQueue.removeAll(removedSources);
     // library queue
     librarySourceQueue.removeAll(changedSources);
     librarySourceQueue.removeAll(removedSources);
+    // parts in libraries
+    for (Source changedSource in changedSources) {
+      _onLibrarySourceChangedOrRemoved(changedSource);
+      _onPartSourceChangedOrRemoved(changedSource);
+    }
+    for (Source removedSource in removedSources) {
+      _onLibrarySourceChangedOrRemoved(removedSource);
+      _onPartSourceChangedOrRemoved(removedSource);
+    }
     // Some of the libraries might have been invalidated, reschedule them.
     {
       MapIterator<AnalysisTarget, CacheEntry> iterator =
           analysisCache.iterator();
       while (iterator.moveNext()) {
         AnalysisTarget target = iterator.key;
         if (_isDartSource(target)) {
           CacheEntry entry = iterator.value;
           if (entry.getValue(SOURCE_KIND) == SourceKind.LIBRARY &&
               entry.getValue(LIBRARY_ERRORS_READY) != true) {
@@ skipping 44 matching lines @@
     for (Source library in context.getLibrariesContaining(source)) {
       LibrarySpecificUnit unit = new LibrarySpecificUnit(library, source);
       for (ResultDescriptor descriptor in _UNIT_ERRORS) {
         errors.addAll(analysisCache.getValue(unit, descriptor));
       }
     }
     LineInfo lineInfo = analysisCache.getValue(source, LINE_INFO);
     return new AnalysisErrorInfoImpl(errors, lineInfo);
   }
 
+  /**
+   * Returns libraries containing the given [part].
+   * Maybe empty, but not null.
+   */
+  List<Source> getLibrariesContainingPart(Source part) {
+    List<Source> libraries = partLibrariesMap[part];
+    return libraries != null ? libraries : Source.EMPTY_LIST;
+  }
+
   @override
   TargetedResult getNextResult() {
     // Try to find a priority result to compute.
     while (priorityResultQueue.isNotEmpty) {
       TargetedResult result = priorityResultQueue.first;
       if (!_needsComputing(result.target, result.result)) {
         priorityResultQueue.remove(result);
         continue;
       }
       return result;
@@ skipping 43 matching lines @@
     // Organize sources.
     if (_isDartSource(target)) {
       SourceKind kind = outputs[SOURCE_KIND];
       if (kind != null) {
         unknownSourceQueue.remove(target);
         if (kind == SourceKind.LIBRARY) {
           librarySourceQueue.add(target);
         }
       }
     }
+    // Update parts in libraries.
+    if (_isDartSource(target)) {
+      Source library = target;
+      List<Source> includedParts = outputs[INCLUDED_PARTS];
+      if (includedParts != null) {
+        libraryPartsMap[library] = includedParts.toList();

[Brian Wilkerson, 2015/05/22 16:05:42]

"includedParts" is declared to be a List. Is the declaration wrong or the
"toList" unnecessary?

+        for (Source part in includedParts) {
+          List<Source> libraries =
+              partLibrariesMap.putIfAbsent(part, () => <Source>[]);
+          if (!libraries.contains(library)) {
+            libraries.add(library);
+          }
+        }
+      }
+    }
     // Update notice.
     if (_isDartSource(target)) {
       bool shouldSetErrors = false;
       outputs.forEach((ResultDescriptor descriptor, value) {
         if (descriptor == PARSED_UNIT && value != null) {
           context.getNotice(target).parsedDartUnit = value;
           shouldSetErrors = true;
         }
         if (_isErrorResult(descriptor)) {
           shouldSetErrors = true;
@@ skipping 25 matching lines @@
 
   /**
    * Returns `true` if the given [result] of the given [target] needs
    * computing, i.e. it is not in the valid and not in the error state.
    */
   bool _needsComputing(AnalysisTarget target, ResultDescriptor result) {
     CacheState state = analysisCache.getState(target, result);
     return state != CacheState.VALID && state != CacheState.ERROR;
   }
 
+  /**
+   * The given [library] source was changed or removed.
+   * Update [libraryPartsMap] and [partLibrariesMap].
+   */
+  void _onLibrarySourceChangedOrRemoved(Source library) {
+    List<Source> parts = libraryPartsMap.remove(library);
+    if (parts != null) {
+      for (Source part in parts) {
+        List<Source> libraries = partLibrariesMap[part];
+        if (libraries != null) {
+          libraries.remove(library);
+        }
+      }
+    }
+  }
+
+  /**
+   * The given [part] source was changed or removed.
+   * Update [libraryPartsMap] and [partLibrariesMap].
+   */
+  void _onPartSourceChangedOrRemoved(Source part) {
+    List<Source> libraries = partLibrariesMap.remove(part);
+    if (libraries != null) {
+      for (Source library in libraries) {
+        List<Source> parts = libraryPartsMap[library];
+        if (parts != null) {
+          parts.remove(part);
+        }
+      }
+    }
+  }
+
   static bool _isDartSource(AnalysisTarget target) {
     return target is Source && AnalysisEngine.isDartFileName(target.fullName);
   }
 
   static bool _isErrorResult(ResultDescriptor descriptor) {
     return _SOURCE_ERRORS.contains(descriptor) ||
         _UNIT_ERRORS.contains(descriptor);
   }
 }