Roll Observatory deps (charted -> ^0.3.0)

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/src/context/cache.dart';
 import 'package:analyzer/src/generated/engine.dart'
@@ skipping 28 matching lines @@
 
   /**
    * The list of errors that are reported for raw Dart [LibrarySpecificUnit]s.
    */
   static final List<ResultDescriptor> _UNIT_ERRORS = <ResultDescriptor>[
     HINTS,
     LINTS,
     LIBRARY_UNIT_ERRORS,
     RESOLVE_TYPE_NAMES_ERRORS,
     RESOLVE_UNIT_ERRORS,
+    STRONG_MODE_ERRORS,
     VARIABLE_REFERENCE_ERRORS,
     VERIFY_ERRORS
   ];
 
   final InternalAnalysisContext context;
 
   /**
    * The [TargetedResult]s that should be computed with priority.
    */
   final LinkedHashSet<TargetedResult> priorityResultQueue =
@@ skipping 127 matching lines @@
       }
     }
     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;
   }
 
   @override
   TargetedResult getNextResult() {
     // Try to find a priority result to compute.
     while (priorityResultQueue.isNotEmpty) {
       TargetedResult result = priorityResultQueue.first;
       if (!_needsComputing(result.target, result.result)) {
@@ skipping 52 matching lines @@
    * Notifies the manager about [SourceFactory] changes.
    */
   void onSourceFactoryChanged() {
     _invalidateAllLocalResolutionInformation(true);
   }
 
   @override
   void resultsComputed(
       AnalysisTarget target, Map<ResultDescriptor, dynamic> outputs) {
     bool isDartSource = _isDartSource(target);
+    // Route SDK outputs to the SDK WorkManager.
+    if (isDartSource && target.source.isInSystemLibrary) {
+      DartWorkManager sdkWorkManager = _getSdkDartWorkManager();
+      if (sdkWorkManager != this) {
+        sdkWorkManager.resultsComputed(target, outputs);
+        return;
+      }
+    }
     // Organize sources.
     bool isDartLibrarySource = false;
     if (isDartSource) {
       Source source = target;
       SourceKind kind = outputs[SOURCE_KIND];
       if (kind != null) {
         unknownSourceQueue.remove(source);
         if (kind == SourceKind.LIBRARY) {
           isDartLibrarySource = true;
           if (context.prioritySources.contains(source)) {
@@ skipping 54 matching lines @@
         context.getNotice(source).setErrors(info.errors, info.lineInfo);
       }
     }
   }
 
   void unitIncrementallyResolved(Source librarySource, Source unitSource) {
     librarySourceQueue.add(librarySource);
   }
 
   /**
+   * 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;
+        }
+      }
+    }
+    return this;
+  }
+
+  /**
    * Invalidate all of the resolution results computed by this context. The flag
    * [invalidateUris] should be `true` if the cached results of converting URIs
    * to source files should also be invalidated.
    */
   void _invalidateAllLocalResolutionInformation(bool invalidateUris) {
     CachePartition partition = privateAnalysisCachePartition;
     // Prepare targets and values to invalidate.
     List<Source> dartSources = <Source>[];
     List<LibrarySpecificUnit> unitTargets = <LibrarySpecificUnit>[];
     MapIterator<AnalysisTarget, CacheEntry> iterator = partition.iterator();
@@ skipping 84 matching lines @@
     }
   }
 
   bool _shouldErrorsBeComputed(Source source) =>
       context.shouldErrorsBeAnalyzed(source, null);
 
   static bool _isDartSource(AnalysisTarget target) {
     return target is Source && AnalysisEngine.isDartFileName(target.fullName);
   }
 }