Initial re-write of analysis context for the new task model

pkg/analyzer/lib/src/generated/engine.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine;
 
 import "dart:math" as math;
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/cancelable_future.dart';
+import 'package:analyzer/src/context/cache.dart' as cache;
+import 'package:analyzer/src/context/context.dart' as cache;

[kevmoo, 2015/04/20 16:27:28]

Two imports both 'as cache'

[Brian Wilkerson, 2015/04/20 16:29:52]

You're right. That was a copy/paste error. I'll clean it up later. Thanks!

 import 'package:analyzer/src/generated/incremental_resolution_validator.dart';
 import 'package:analyzer/src/plugin/engine_plugin.dart';
 import 'package:analyzer/src/services/lint.dart';
+import 'package:analyzer/src/task/manager.dart';
 import 'package:analyzer/src/task/task_dart.dart';
+import 'package:analyzer/task/model.dart';
 
 import '../../instrumentation/instrumentation.dart';
 import 'ast.dart';
 import 'constant.dart';
 import 'element.dart';
 import 'error.dart';
 import 'error_verifier.dart';
 import 'html.dart' as ht;
 import 'incremental_resolver.dart'
     show IncrementalResolver, PoorMansIncrementalResolver;
@@ skipping 1096 matching lines @@
 
   @override
   set contentCache(ContentCache value) {
     _contentCache = value;
   }
 
   @override
   DeclaredVariables get declaredVariables => _declaredVariables;
 
   @override
+  List<AnalysisTarget> get explicitTargets {
+    List<AnalysisTarget> targets = <AnalysisTarget>[];
+    MapIterator<Source, SourceEntry> iterator = _cache.iterator();
+    while (iterator.moveNext()) {
+      if (iterator.value.explicitlyAdded) {
+        targets.add(iterator.key);
+      }
+    }
+    return targets;
+  }
+
+  @override
   List<Source> get htmlSources => _getSources(SourceKind.HTML);
 
   @override
   bool get isDisposed => _disposed;
 
   @override
   List<Source> get launchableClientLibrarySources {
     // TODO(brianwilkerson) This needs to filter out libraries that do not
     // reference dart:html, either directly or indirectly.
     List<Source> sources = new List<Source>();
@@ skipping 177 matching lines @@
   /**
    * Make _pendingFutureSources available to unit tests.
    */
   HashMap<Source, List<PendingFuture>> get pendingFutureSources_forTesting =>
       _pendingFutureSources;
 
   @override
   List<Source> get prioritySources => _priorityOrder;
 
   @override
+  List<AnalysisTarget> get priorityTargets => prioritySources;
+
+  @override
   List<Source> get refactoringUnsafeSources {
     List<Source> sources = new List<Source>();
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       SourceEntry sourceEntry = iterator.value;
       if (sourceEntry is DartEntry) {
         Source source = iterator.key;
         if (!source.isInSystemLibrary && !sourceEntry.isRefactoringSafe) {
           sources.add(source);
         }
@@ skipping 477 matching lines @@
           }
         }
       }
     } on _ElementByIdFinderException {
       return finder.result;
     }
     return null;
   }
 
   @override
+  cache.CacheEntry getCacheEntry(AnalysisTarget target) {
+    return null;
+  }
+
+  @override
   CompilationUnitElement getCompilationUnitElement(
       Source unitSource, Source librarySource) {
     LibraryElement libraryElement = getLibraryElement(librarySource);
     if (libraryElement != null) {
       // try defining unit
       CompilationUnitElement definingUnit =
           libraryElement.definingCompilationUnit;
       if (definingUnit.source == unitSource) {
         return definingUnit;
       }
@@ skipping 3893 matching lines @@
    * The instrumentation service that is to be used by this analysis engine.
    */
   InstrumentationService _instrumentationService =
       InstrumentationService.NULL_SERVICE;
 
   /**
    * The partition manager being used to manage the shared partitions.
    */
   final PartitionManager partitionManager = new PartitionManager();
 
+  /**
+   * The partition manager being used to manage the shared partitions.
+   */
+  final cache.PartitionManager partitionManager_new =
+      new cache.PartitionManager();
+
+  /**
+   * A flag indicating whether the (new) task model should be used to perform
+   * analysis.
+   */
+  bool useTaskModel = false;
+
+  /**
+   * The task manager used to manage the tasks used to analyze code.
+   */
+  TaskManager _taskManager;
+
+  /**
+   * A flag indicating whether union types should be used.
+   */
+  bool enableUnionTypes = false;

[scheglov, 2015/04/20 03:44:50]

IIRC Paul removed union types support some a week or two ago.

[Brian Wilkerson, 2015/04/20 15:00:36]

Yes. That resulted from a merge issue. I've re-removed them. Thanks!

+
+  /**
+   * A flag indicating whether union types should have strict semantics. This
+   * option has no effect when `enabledUnionTypes` is `false`.
+   */
+  bool strictUnionTypes = false;
+
   AnalysisEngine._();
 
   /**
    * Return the instrumentation service that is to be used by this analysis
    * engine.
    */
   InstrumentationService get instrumentationService => _instrumentationService;
 
   /**
    * Set the instrumentation service that is to be used by this analysis engine
@@ skipping 15 matching lines @@
 
   /**
    * Set the logger that should receive information about errors within the
    * analysis engine to the given [logger].
    */
   void set logger(Logger logger) {
     this._logger = logger == null ? Logger.NULL : logger;
   }
 
   /**
+   * Return the task manager used to manage the tasks used to analyze code.
+   */
+  TaskManager get taskManager {
+    if (_taskManager == null) {
+      _taskManager = new TaskManager();
+      _taskManager.addTaskDescriptors(enginePlugin.taskDescriptors());
+    }
+    return _taskManager;
+  }
+
+  /**
    * Clear any caches holding on to analysis results so that a full re-analysis
    * will be performed the next time an analysis context is created.
    */
   void clearCaches() {
     partitionManager.clearCache();
   }
 
   /**
    * Create and return a new context in which analysis can be performed.
    */
@@ skipping 1378 matching lines @@
   CycleBuilder_LibraryPair(ResolvableLibrary library,
       List<CycleBuilder_SourceEntryPair> entryPairs) {
     this.library = library;
     this.entryPairs = entryPairs;
   }
 }
 
 /**
  * A pair containing a source and the cache entry associated with that source.
  * They are used to reduce the number of times an entry must be looked up in the
- * [cache].
+ * cache.
  */
 class CycleBuilder_SourceEntryPair {
   /**
    * The source associated with the entry.
    */
   Source source;
 
   /**
    * The entry associated with the source.
    */
@@ skipping 1817 matching lines @@
  */
 abstract class InternalAnalysisContext implements AnalysisContext {
   /**
    * Allow the client to supply its own content cache.  This will take the
    * place of the content cache created by default, allowing clients to share
    * the content cache between contexts.
    */
   set contentCache(ContentCache value);
 
   /**
+   * Return a list of the explicit targets being analyzed by this context.
+   */
+  List<AnalysisTarget> get explicitTargets;
+
+  /**
+   * A factory to override how [LibraryResolver] is created.
+   */
+  LibraryResolverFactory get libraryResolverFactory;
+
+  /**
    * Return a list containing all of the sources that have been marked as
    * priority sources. Clients must not modify the returned list.
    */
   List<Source> get prioritySources;
 
   /**
+   * Return a list of the priority targets being analyzed by this context.
+   */
+  List<AnalysisTarget> get priorityTargets;
+
+  /**
    * A factory to override how [ResolverVisitor] is created.
    */
   ResolverVisitorFactory get resolverVisitorFactory;
 
   /**
    * Returns a statistics about this context.
    */
   AnalysisContextStatistics get statistics;
 
   /**
    * Sets the [TypeProvider] for this context.
    */
   void set typeProvider(TypeProvider typeProvider);
 
   /**
    * A factory to override how [TypeResolverVisitor] is created.
    */
   TypeResolverVisitorFactory get typeResolverVisitorFactory;
 
   /**
-   * A factory to override how [LibraryResolver] is created.
-   */
-  LibraryResolverFactory get libraryResolverFactory;
-
-  /**
    * Add the given [source] with the given [information] to this context.
    */
   void addSourceInfo(Source source, SourceEntry information);
 
   /**
    * Return a list containing the sources of the libraries that are exported by
    * the library with the given [source]. The list will be empty if the given
    * source is invalid, if the given source does not represent a library, or if
    * the library does not export any other libraries.
    *
@@ skipping 25 matching lines @@
   CompilationUnit computeResolvableCompilationUnit(Source source);
 
   /**
    * Return all the resolved [CompilationUnit]s for the given [source] if not
    * flushed, otherwise return `null` and ensures that the [CompilationUnit]s
    * will be eventually returned to the client from [performAnalysisTask].
    */
   List<CompilationUnit> ensureResolvedDartUnits(Source source);
 
   /**
+   * Return the cache entry associated with the given [target].
+   */
+  cache.CacheEntry getCacheEntry(AnalysisTarget target);
+
+  /**
    * Return context that owns the given [source].
    */
   InternalAnalysisContext getContextFor(Source source);
 
   /**
    * Return a namespace containing mappings for all of the public names defined
    * by the given [library].
    */
   Namespace getPublicNamespace(LibraryElement library);
 
@@ skipping 2570 matching lines @@
   visitElement(Element element) {
     if (element.id == _id) {
       result = element;
       throw new _ElementByIdFinderException();
     }
     super.visitElement(element);
   }
 }
 
 class _ElementByIdFinderException {}