Roll Observatory packages and add a roll script

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'
     show
         AnalysisEngine,
         AnalysisErrorInfo,
         AnalysisErrorInfoImpl,
         AnalysisOptions,
         CacheState,
         InternalAnalysisContext;
 import 'package:analyzer/src/generated/error.dart';
 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/driver.dart';
+import 'package:analyzer/src/task/html.dart';
 import 'package:analyzer/task/dart.dart';
-import 'package:analyzer/task/general.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>[
     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>[
     HINTS,
-    RESOLVE_REFERENCES_ERRORS,
+    LINTS,
+    LIBRARY_UNIT_ERRORS,
     RESOLVE_TYPE_NAMES_ERRORS,
+    RESOLVE_UNIT_ERRORS,
     VARIABLE_REFERENCE_ERRORS,
     VERIFY_ERRORS
   ];
 
   final InternalAnalysisContext context;
 
   /**
    * The [TargetedResult]s that should be computed with priority.
    */
   final LinkedHashSet<TargetedResult> priorityResultQueue =
@@ skipping 48 matching lines @@
       context.privateAnalysisCachePartition;
 
   /**
    * Specifies that the client want the given [result] of the given [target]
    * to be computed with priority.
    */
   void addPriorityResult(AnalysisTarget target, ResultDescriptor result) {
     priorityResultQueue.add(new TargetedResult(target, result));
   }
 
-  /**
-   * Notifies the manager about changes in the explicit source list.
-   */
+  @override
   void applyChange(List<Source> addedSources, List<Source> changedSources,
       List<Source> removedSources) {
     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
@@ skipping 30 matching lines @@
         } else if (sourceKind == SourceKind.PART) {
           List<Source> libraries = context.getLibrariesContaining(target);
           for (Source library in libraries) {
             addPriorityResult(library, LIBRARY_ERRORS_READY);
           }
         }
       }
     }
   }
 
-  /**
-   * Return an [AnalysisErrorInfo] containing the list of all of the errors and
-   * the line info associated with the given [source]. The list of errors will
-   * be empty if the source is not known to the context or if there are no
-   * errors in the source. The errors contained in the list can be incomplete.
-   */
-  AnalysisErrorInfo getErrors(Source source) {
+  @override
+  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) {
-      List<AnalysisError> errors = analysisCache.getValue(source, DART_ERRORS);
-      LineInfo lineInfo = analysisCache.getValue(source, LINE_INFO);
-      return new AnalysisErrorInfoImpl(errors, lineInfo);
+      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) {
       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) {
         errors.addAll(analysisCache.getValue(unit, descriptor));
       }
     }
-    LineInfo lineInfo = analysisCache.getValue(source, LINE_INFO);
-    return new AnalysisErrorInfoImpl(errors, lineInfo);
+    return errors;
   }
 
   /**
    * 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;
   }
@@ skipping 58 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);
     // Organize sources.
-    if (_isDartSource(target)) {
+    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)) {
             _schedulePriorityLibrarySourceAnalysis(source);
           } else {
             bool needErrors = _shouldErrorsBeComputed(source);
             if (needErrors) {
               librarySourceQueue.add(target);
             }
           }
         }
       }
     }
     // Update parts in libraries.
-    if (_isDartSource(target)) {
+    if (isDartLibrarySource) {
       Source library = target;
       List<Source> includedParts = outputs[INCLUDED_PARTS];
       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);
           }
         }
       }
     }
     // Update notice.
-    if (_isDartSource(target)) {
+    if (isDartSource) {
       bool shouldSetErrors = false;
       outputs.forEach((ResultDescriptor descriptor, value) {
         if (descriptor == PARSED_UNIT && value != null) {
           context.getNotice(target).parsedDartUnit = value;
           shouldSetErrors = true;
         }
         if (descriptor == DART_ERRORS) {
           shouldSetErrors = true;
         }
       });
       if (shouldSetErrors) {
-        AnalysisErrorInfo info = getErrors(target);
+        AnalysisErrorInfo info = context.getErrors(target);
         context.getNotice(target).setErrors(info.errors, info.lineInfo);
       }
     }
     if (target is LibrarySpecificUnit) {
       Source source = target.source;
       bool shouldSetErrors = false;
       outputs.forEach((ResultDescriptor descriptor, value) {
         if (descriptor == RESOLVED_UNIT && value != null) {
           context.getNotice(source).resolvedDartUnit = value;
           shouldSetErrors = true;
         }
       });
       if (shouldSetErrors) {
-        AnalysisErrorInfo info = getErrors(source);
+        AnalysisErrorInfo info = context.getErrors(source);
         context.getNotice(source).setErrors(info.errors, info.lineInfo);
       }
     }
   }
 
   void unitIncrementallyResolved(Source librarySource, Source unitSource) {
     librarySourceQueue.add(librarySource);
   }
 
   /**
@@ skipping 94 matching lines @@
     }
   }
 
   bool _shouldErrorsBeComputed(Source source) =>
       context.shouldErrorsBeAnalyzed(source, null);
 
   static bool _isDartSource(AnalysisTarget target) {
     return target is Source && AnalysisEngine.isDartFileName(target.fullName);
   }
 }