Roll Observatory packages and add a roll script

packages/analyzer/lib/task/model.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.task.model;
 
 import 'dart:collection';
+import 'dart:developer';
 
 import 'package:analyzer/src/generated/engine.dart' hide AnalysisTask;
+import 'package:analyzer/src/generated/error.dart' show AnalysisError;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/task/driver.dart';
 import 'package:analyzer/src/task/model.dart';
 
 /**
  * A function that converts the given [key] and [value] into a [TaskInput].
  */
 typedef TaskInput<E> BinaryFunction<K, V, E>(K key, V value);
 
 /**
  * A function that takes an analysis [context] and an analysis [target] and
@@ skipping 53 matching lines @@
  * Clients are expected to extend this class when creating new tasks.
  */
 abstract class AnalysisTask {
   /**
    * A table mapping the types of analysis tasks to the number of times each
    * kind of task has been performed.
    */
   static final Map<Type, int> countMap = new HashMap<Type, int>();
 
   /**
+   * A table mapping the types of analysis tasks to user tags used to collect
+   * timing data for the Observatory.
+   */
+  static Map<Type, UserTag> tagMap = new HashMap<Type, UserTag>();
+
+  /**
    * A table mapping the types of analysis tasks to stopwatches used to compute
    * how much time was spent executing each kind of task.
    */
   static final Map<Type, Stopwatch> stopwatchMap =
       new HashMap<Type, Stopwatch>();
 
   /**
    * The context in which the task is to be performed.
    */
   final AnalysisContext context;
@@ skipping 94 matching lines @@
    * map should be fully populated (have a key/value pair for each result that
    * this task is expected to produce) or the [caughtException] should be set.
    *
    * Clients should not override this method.
    */
   void perform() {
     try {
       _safelyPerform();
     } on AnalysisException catch (exception, stackTrace) {
       caughtException = new CaughtException(exception, stackTrace);
-      AnalysisEngine.instance.logger.logInformation(
-          "Task failed: ${description}", caughtException);
+      AnalysisEngine.instance.logger
+          .logInformation("Task failed: ${description}", caughtException);
     }
   }
 
   @override
   String toString() => description;
 
   /**
    * Perform this analysis task, ensuring that all exceptions are wrapped in an
    * [AnalysisException].
    *
    * Clients should not override this method.
    */
   void _safelyPerform() {
     try {
       //
       // Report that this task is being performed.
       //
       String contextName = context.name;
       if (contextName == null) {
         contextName = 'unnamed';
       }
-      AnalysisEngine.instance.instrumentationService.logAnalysisTask(
-          contextName, this);
+      AnalysisEngine.instance.instrumentationService
+          .logAnalysisTask(contextName, this);
       //
       // Gather statistics on the performance of the task.
       //
       int count = countMap[runtimeType];
       countMap[runtimeType] = count == null ? 1 : count + 1;
+//      UserTag tag = tagMap.putIfAbsent(
+//          runtimeType, () => new UserTag(runtimeType.toString()));
       Stopwatch stopwatch = stopwatchMap[runtimeType];
       if (stopwatch == null) {
         stopwatch = new Stopwatch();
         stopwatchMap[runtimeType] = stopwatch;
       }
+//      UserTag previousTag = tag.makeCurrent();
+//      try {
       stopwatch.start();
       //
       // Actually perform the task.
       //
       try {
         if (dependencyCycle != null && !handlesDependencyCycles) {
           throw new InfiniteTaskLoopException(this, dependencyCycle);
         }
         internalPerform();
       } finally {
         stopwatch.stop();
       }
+//      } finally {
+//        previousTag.makeCurrent();
+//      }
     } on AnalysisException {
       rethrow;
     } catch (exception, stackTrace) {
       throw new AnalysisException(
           'Unexpected exception while performing $description',
           new CaughtException(exception, stackTrace));
     }
   }
 }
 
 /**
  * A description of a [List]-based analysis result that can be computed by an
  * [AnalysisTask].
  *
  * Clients are not expected to subtype this class.
  */
 abstract class ListResultDescriptor<E> implements ResultDescriptor<List<E>> {
   /**
    * Initialize a newly created analysis result to have the given [name] and
    * [defaultValue]. If a [cachingPolicy] is provided, it will control how long
    * values associated with this result will remain in the cache.
    */
   factory ListResultDescriptor(String name, List<E> defaultValue,
-      {ResultCachingPolicy<List<E>> cachingPolicy}) = ListResultDescriptorImpl<E>;
+      {ResultCachingPolicy<List<E>> cachingPolicy}) = ListResultDescriptorImpl<
+      E>;
 
   @override
-  ListTaskInput<E> of(AnalysisTarget target);
+  ListTaskInput<E> of(AnalysisTarget target, {bool flushOnAccess: false});
 }
 
 /**
  * A description of an input to an [AnalysisTask] that can be used to compute
  * that input.
  *
  * Clients are not expected to subtype this class.
  */
 abstract class ListTaskInput<E> extends TaskInput<List<E>> {
   /**
@@ skipping 94 matching lines @@
    */
   V get defaultValue;
 
   /**
    * Return the name of this descriptor.
    */
   String get name;
 
   /**
    * Return a task input that can be used to compute this result for the given
-   * [target].
+   * [target]. If [flushOnAccess] is `true` then the value of this result that
+   * is associated with the [target] will be flushed when it is accessed.
    */
-  TaskInput<V> of(AnalysisTarget target);
+  TaskInput<V> of(AnalysisTarget target, {bool flushOnAccess: false});
 }
 
 /**
+ * A specification of the given [result] for the given [target].
+ *
+ * Clients are not expected to subtype this class.
+ */
+class TargetedResult {
+  /**
+   * An empty list of results.
+   */
+  static final List<TargetedResult> EMPTY_LIST = const <TargetedResult>[];
+
+  /**
+   * The target with which the result is associated.
+   */
+  final AnalysisTarget target;
+
+  /**
+   * The result associated with the target.
+   */
+  final ResultDescriptor result;
+
+  /**
+   * Initialize a new targeted result.
+   */
+  TargetedResult(this.target, this.result);
+
+  @override
+  int get hashCode {
+    return JenkinsSmiHash.combine(target.hashCode, result.hashCode);
+  }
+
+  @override
+  bool operator ==(other) {
+    return other is TargetedResult &&
+        other.target == target &&
+        other.result == result;
+  }
+
+  @override
+  String toString() => '$result for $target';
+}
+
+/**
  * A description of an [AnalysisTask].
  */
 abstract class TaskDescriptor {
   /**
    * Initialize a newly created task descriptor to have the given [name] and to
    * describe a task that takes the inputs built using the given [inputBuilder],
    * and produces the given [results]. The [buildTask] will be used to create
    * the instance of [AnalysisTask] thusly described.
    */
-  factory TaskDescriptor(String name, BuildTask buildTask,
+  factory TaskDescriptor(
+      String name,
+      BuildTask buildTask,
       CreateTaskInputs inputBuilder,
       List<ResultDescriptor> results) = TaskDescriptorImpl;
 
   /**
    * Return the builder used to build the inputs to the task.
    */
   CreateTaskInputs get createTaskInputs;
 
   /**
    * Return the name of the task being described.
@@ skipping 63 matching lines @@
 
   /**
    * Set the [value] that was computed for the current result.
    *
    * Throws a [StateError] if [moveNext] has not been invoked or if the last
    * invocation of [moveNext] returned `false`.
    */
   void set currentValue(Object value);
 
   /**
+   * Return `true` if the value accessed by this input builder should be flushed
+   * from the cache at the time it is retrieved.
+   */
+  bool get flushOnAccess;
+
+  /**
    * Return the [value] that was computed by this builder.
    *
    * Throws a [StateError] if [moveNext] has not been invoked or if the last
    * invocation of [moveNext] returned `true`.
    *
    * Returns `null` if no value could be computed due to a circular dependency.
    */
   V get inputValue;
 
   /**
@@ skipping 11 matching lines @@
    * be computed, or `false` if the inputs have been computed.
    *
    * It is safe to invoke [moveNext] after it has returned `false`. In this case
    * [moveNext] has no effect and will again return `false`.
    *
    * Throws a [StateError] if the value of the current result has not been
    * provided using [currentValue].
    */
   bool moveNext();
 }
+
+/**
+ * [WorkManager]s are used to drive analysis.
+ *
+ * They know specific of the targets and results they care about,
+ * so they can request analysis results in optimal order.
+ */
+abstract class WorkManager {
+  /**
+   * Notifies the manager about changes in the explicit source list.
+   */
+  void applyChange(List<Source> addedSources, List<Source> changedSources,
+      List<Source> removedSources);
+
+  /**
+   * Notifies the managers that the given set of priority [targets] was set.
+   */
+  void applyPriorityTargets(List<AnalysisTarget> targets);
+
+  /**
+   * Return a list of all of the errors 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.
+   */
+  List<AnalysisError> getErrors(Source source);
+
+  /**
+   * Return the next [TargetedResult] that this work manager wants to be
+   * computed, or `null` if this manager doesn't need any new results.
+   *
+   * Note, that it is not guaranteed that this result will be computed, it is
+   * up to the work manager to check whether the result is already computed
+   * (for example during the next [getNextResult] invocation) or computation
+   * of the same result should be requested again.
+   */
+  TargetedResult getNextResult();
+
+  /**
+   * Return the priority if the next work order this work manager want to be
+   * computed. The [AnalysisDriver] will perform the work order with
+   * the highest priority.
+   *
+   * Even if the returned value is [WorkOrderPriority.NONE], it still does not
+   * guarantee that [getNextResult] will return not `null`.
+   */
+  WorkOrderPriority getNextResultPriority();
+
+  /**
+   * Notifies the manager about analysis options changes.
+   */
+  void onAnalysisOptionsChanged();
+
+  /**
+   * Notifies the manager about [SourceFactory] changes.
+   */
+  void onSourceFactoryChanged();
+
+  /**
+   * Notifies the manager that the given [outputs] were produced for
+   * the given [target].
+   */
+  void resultsComputed(
+      AnalysisTarget target, Map<ResultDescriptor, dynamic> outputs);
+}
+
+/**
+ * The priorities of work orders returned by [WorkManager]s.
+ *
+ * New priorities may be added with time, clients need to tolerate this.
+ */
+enum WorkOrderPriority {
+  /**
+   * Responding to an user's action.
+   */
+  INTERACTIVE,
+
+  /**
+   * Computing information for priority sources.
+   */
+  PRIORITY,
+
+  /**
+   * A work should be done, but without any special urgency.
+   */
+  NORMAL,
+
+  /**
+   * Nothing to do.
+   */
+  NONE
+}