Removed fixed dependencies

packages/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/error/error.dart';
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/engine.dart'
-    show
-        AnalysisEngine,
-        AnalysisErrorInfo,
-        AnalysisErrorInfoImpl,
-        AnalysisOptions,
-        CacheState,
-        InternalAnalysisContext;
-import 'package:analyzer/src/generated/error.dart';
+    show AnalysisEngine, AnalysisErrorInfo, CacheState, InternalAnalysisContext;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/src/task/html.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/model.dart';
 
 /**
  * The manager for Dart specific analysis.
  */
 class DartWorkManager implements WorkManager {
   /**
    * The list of errors that are reported for raw Dart [Source]s.
    */
-  static final List<ResultDescriptor> _SOURCE_ERRORS = <ResultDescriptor>[
+  static final List<ResultDescriptor<List<AnalysisError>>> _SOURCE_ERRORS =
+      <ResultDescriptor<List<AnalysisError>>>[
     BUILD_DIRECTIVES_ERRORS,
     BUILD_LIBRARY_ERRORS,
     PARSE_ERRORS,
     SCAN_ERRORS
   ];
 
   /**
    * The list of errors that are reported for raw Dart [LibrarySpecificUnit]s.
    */
-  static final List<ResultDescriptor> _UNIT_ERRORS = <ResultDescriptor>[
+  static final List<ResultDescriptor<List<AnalysisError>>> _UNIT_ERRORS =
+      <ResultDescriptor<List<AnalysisError>>>[
     HINTS,
     LINTS,
     LIBRARY_UNIT_ERRORS,
     RESOLVE_TYPE_NAMES_ERRORS,
+    RESOLVE_TYPE_BOUNDS_ERRORS,
     RESOLVE_UNIT_ERRORS,
     STRONG_MODE_ERRORS,
     VARIABLE_REFERENCE_ERRORS,
     VERIFY_ERRORS
   ];
 
   final InternalAnalysisContext context;
 
   /**
    * The [TargetedResult]s that should be computed with priority.
@@ skipping 20 matching lines @@
   /**
    * 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) {
-    analysisCache.onResultInvalidated.listen((InvalidatedResult event) {
+    context.onResultInvalidated.listen((InvalidatedResult event) {
       if (event.descriptor == LIBRARY_ERRORS_READY) {
         CacheEntry entry = event.entry;
-        if (entry.getValue(SOURCE_KIND) == SourceKind.LIBRARY) {
+        if (entry.explicitlyAdded &&
+            entry.getValue(SOURCE_KIND) == SourceKind.LIBRARY) {
           librarySourceQueue.add(entry.target);
         }
       }
     });
   }
 
   /**
    * Returns the correctly typed result of `context.analysisCache`.
    */
   AnalysisCache get analysisCache => context.analysisCache;
@@ skipping 10 matching lines @@
    * to be computed with priority.
    */
   void addPriorityResult(AnalysisTarget target, ResultDescriptor result) {
     priorityResultQueue.add(new TargetedResult(target, result));
   }
 
   @override
   void applyChange(List<Source> addedSources, List<Source> changedSources,
       List<Source> removedSources) {
     addedSources = addedSources.where(_isDartSource).toList();
-    changedSources = changedSources.where(_isDartSource).toList();
+    changedSources = changedSources
+        .where(_isDartSource)
+        .where((source) => _needsComputing(source, SOURCE_KIND))
+        .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) {
@@ skipping 37 matching lines @@
   List<AnalysisError> getErrors(Source source) {
     if (!_isDartSource(source) && source is! DartScript) {
       return AnalysisError.NO_ERRORS;
     }
     // If analysis is finished, use all the errors.
     if (analysisCache.getState(source, DART_ERRORS) == CacheState.VALID) {
       return analysisCache.getValue(source, DART_ERRORS);
     }
     // If analysis is in progress, combine all known partial results.
     List<AnalysisError> errors = <AnalysisError>[];
-    for (ResultDescriptor descriptor in _SOURCE_ERRORS) {
+    for (ResultDescriptor<List<AnalysisError>> descriptor in _SOURCE_ERRORS) {
       errors.addAll(analysisCache.getValue(source, descriptor));
     }
     for (Source library in context.getLibrariesContaining(source)) {
       LibrarySpecificUnit unit = new LibrarySpecificUnit(library, source);
-      for (ResultDescriptor descriptor in _UNIT_ERRORS) {
+      for (ResultDescriptor<List<AnalysisError>> descriptor in _UNIT_ERRORS) {
         errors.addAll(analysisCache.getValue(unit, descriptor));
       }
     }
     return errors;
   }
 
   /**
    * Returns libraries containing the given [part].
    * Maybe empty, but not null.
    */
   List<Source> getLibrariesContainingPart(Source part) {
     if (part.isInSystemLibrary) {
       DartWorkManager sdkDartWorkManager = _getSdkDartWorkManager();
       if (sdkDartWorkManager != this) {
         return sdkDartWorkManager.getLibrariesContainingPart(part);
       }
     }
     List<Source> libraries = partLibrariesMap[part];
-    return libraries != null ? libraries : Source.EMPTY_LIST;
+    libraries ??= _getLibrariesContainingPartFromResultProvider(part);
+    return libraries?.toList() ?? 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;
@@ skipping 81 matching lines @@
             if (needErrors) {
               librarySourceQueue.add(target);
             }
           }
         }
       }
     }
     // Update parts in libraries.
     if (isDartLibrarySource) {
       Source library = target;
-      List<Source> includedParts = outputs[INCLUDED_PARTS];
+      List<Source> includedParts = outputs[INCLUDED_PARTS] as List<Source>;
       if (includedParts != null) {
         libraryPartsMap[library] = includedParts;
         for (Source part in includedParts) {
           List<Source> libraries =
               partLibrariesMap.putIfAbsent(part, () => <Source>[]);
           if (!libraries.contains(library)) {
             libraries.add(library);
             _invalidateContainingLibraries(part);
           }
         }
@@ skipping 25 matching lines @@
           shouldSetErrors = true;
         }
       });
       if (shouldSetErrors) {
         AnalysisErrorInfo info = context.getErrors(source);
         context.getNotice(source).setErrors(info.errors, info.lineInfo);
       }
     }
   }
 
+  /**
+   * The given unit was incrementally resolved. Some of its error results might
+   * have been invalidated, so we schedule it for computing errors.
+   */
   void unitIncrementallyResolved(Source librarySource, Source unitSource) {
     librarySourceQueue.add(librarySource);
   }
 
   /**
+   * Ask the [context]'s result provider for [CONTAINING_LIBRARIES].
+   * Return the list of containing libraries, or `null` if unknown.
+   */
+  List<Source> _getLibrariesContainingPartFromResultProvider(Source part) {
+    CacheEntry cacheEntry = context.getCacheEntry(part);
+    bool knows = context.aboutToComputeResult(cacheEntry, CONTAINING_LIBRARIES);
+    if (knows) {
+      return cacheEntry.getValue(CONTAINING_LIBRARIES);
+    }
+    return null;
+  }
+
+  /**
    * Return the SDK [DartWorkManager] or this one.
    */
   DartWorkManager _getSdkDartWorkManager() {
     SourceFactory sourceFactory = context.sourceFactory;
     InternalAnalysisContext sdkContext = sourceFactory.dartSdk.context;
     if (sdkContext != context) {
       for (WorkManager workManager in sdkContext.workManagers) {
         if (workManager is DartWorkManager) {
           return workManager;
         }
@@ skipping 18 matching lines @@
       // Optionally gather Dart sources to invalidate URIs resolution.
       if (invalidateUris && _isDartSource(target)) {
         dartSources.add(target);
       }
       // LibrarySpecificUnit(s) are roots of Dart resolution.
       // When one is invalidated, invalidation is propagated to all resolution.
       if (target is LibrarySpecificUnit) {
         unitTargets.add(target);
         Source library = target.library;
         if (context.exists(library)) {
-          librarySourceQueue.add(library);
+          CacheEntry entry = iterator.value;
+          if (entry.explicitlyAdded) {
+            librarySourceQueue.add(library);
+          }
         }
       }
     }
     // Invalidate targets and values.
     unitTargets.forEach(partition.remove);
     for (Source dartSource in dartSources) {
       CacheEntry entry = partition.get(dartSource);
-      if (dartSource != null) {
+      if (entry != null) {
         // TODO(scheglov) we invalidate too much.
         // Would be nice to invalidate just URLs resolution.
         entry.setState(PARSED_UNIT, CacheState.INVALID);
         entry.setState(IMPORTED_LIBRARIES, CacheState.INVALID);
         entry.setState(EXPLICITLY_IMPORTED_LIBRARIES, CacheState.INVALID);
         entry.setState(EXPORTED_LIBRARIES, CacheState.INVALID);
         entry.setState(INCLUDED_PARTS, CacheState.INVALID);
+        entry.setState(LIBRARY_SPECIFIC_UNITS, CacheState.INVALID);
+        entry.setState(UNITS, CacheState.INVALID);
       }
     }
   }
 
   /**
    * Invalidate  [CONTAINING_LIBRARIES] for the given [source].
    * [CONTAINING_LIBRARIES] does not have dependencies, so we manage it here.
    * The [source] may be a part, or a library whose contents is updated so
    * will be a part.
    */
@@ skipping 40 matching lines @@
     bool needErrors = _shouldErrorsBeComputed(librarySource);
     if (needErrors) {
       addPriorityResult(librarySource, LIBRARY_ERRORS_READY);
     } else {
       var target = new LibrarySpecificUnit(librarySource, librarySource);
       addPriorityResult(target, RESOLVED_UNIT);
     }
   }
 
   bool _shouldErrorsBeComputed(Source source) =>
-      context.shouldErrorsBeAnalyzed(source, null);
+      context.shouldErrorsBeAnalyzed(source);
 
   static bool _isDartSource(AnalysisTarget target) {
     return target is Source && AnalysisEngine.isDartFileName(target.fullName);
   }
 }