Hook for overriding the ContextManager and some code clean-up (with more to follow)

pkg/analysis_server/lib/src/analysis_server.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.
 
 library analysis.server;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:core' hide Resource;
 import 'dart:math' show max;
@@ skipping 90 matching lines @@
    * The [SearchEngine] for this server, may be `null` if indexing is disabled.
    */
   final SearchEngine searchEngine;
 
   /**
    * The plugin associated with this analysis server.
    */
   final ServerPlugin serverPlugin;
 
   /**
-   * [ContextManager] which handles the mapping from analysis roots
-   * to context directories.
+   * The [ContextManager] that handles the mapping from analysis roots to
+   * context directories.
    */
-  ServerContextManager contextDirectoryManager;
+  ServerContextManager contextManager;
 
   /**
    * A flag indicating whether the server is running.  When false, contexts
    * will no longer be added to [contextWorkQueue], and [performOperation] will
    * discard any tasks it finds on [contextWorkQueue].
    */
   bool running;
 
   /**
    * A flag indicating the value of the 'analyzing' parameter sent in the last
@@ skipping 122 matching lines @@
 
   /**
    * The plugins that are defined outside the analysis_server package.
    */
   List<Plugin> userDefinedPlugins;
 
   /**
    * Initialize a newly created server to receive requests from and send
    * responses to the given [channel].
    *
+   * If a [contextManager] is provided, then the [packageResolverProvider] will
+   * be ignored.
+   *
    * If [rethrowExceptions] is true, then any exceptions thrown by analysis are
    * propagated up the call stack.  The default is true to allow analysis
    * exceptions to show up in unit tests, but it should be set to false when
    * running a full analysis server.
    */
   AnalysisServer(this.channel, this.resourceProvider,
       OptimizingPubPackageMapProvider packageMapProvider, Index _index,
       this.serverPlugin, AnalysisServerOptions analysisServerOptions,
       this.defaultSdk, this.instrumentationService,
-      {ResolverProvider packageResolverProvider: null,
+      {ContextManager contextManager: null,
+      ResolverProvider packageResolverProvider: null,
       this.rethrowExceptions: true})
       : index = _index,
         searchEngine = _index != null ? createSearchEngine(_index) : null {
     _performance = performanceDuringStartup;
     operationQueue = new ServerOperationQueue();
-    contextDirectoryManager = new ServerContextManager(this, resourceProvider,
-        packageResolverProvider, packageMapProvider, instrumentationService);
-    contextDirectoryManager.defaultOptions.incremental = true;
-    contextDirectoryManager.defaultOptions.incrementalApi =
-        analysisServerOptions.enableIncrementalResolutionApi;
-    contextDirectoryManager.defaultOptions.incrementalValidation =
-        analysisServerOptions.enableIncrementalResolutionValidation;
-    contextDirectoryManager.defaultOptions.generateImplicitErrors = false;
+    if (contextManager == null) {
+      contextManager = new ServerContextManager(this, resourceProvider,
+          packageResolverProvider, packageMapProvider, instrumentationService);
+      AnalysisOptionsImpl options =
+          (contextManager as ServerContextManager).defaultOptions;
+      options.incremental = true;
+      options.incrementalApi =
+          analysisServerOptions.enableIncrementalResolutionApi;
+      options.incrementalValidation =
+          analysisServerOptions.enableIncrementalResolutionValidation;
+      options.generateImplicitErrors = false;
+    } else if (contextManager is! ServerContextManager) {
+      // TODO(brianwilkerson) Remove this when the interface is complete.
+      throw new StateError(
+          'The contextManager must be an instance of ServerContextManager');
+    }
+    this.contextManager = contextManager;
     _noErrorNotification = analysisServerOptions.noErrorNotification;
     AnalysisEngine.instance.logger = new AnalysisLogger();
     _onAnalysisStartedController = new StreamController.broadcast();
     _onFileAnalyzedController = new StreamController.broadcast();
     _onPriorityChangeController =
         new StreamController<PriorityChangeEvent>.broadcast();
     running = true;
     onAnalysisStarted.first.then((_) {
       onAnalysisComplete.then((_) {
         performanceAfterStartup = new ServerPerformance();
@@ skipping 24 matching lines @@
    * The stream that is notified when analysis of a context is started.
    */
   Stream<AnalysisContext> get onAnalysisStarted {
     return _onAnalysisStartedController.stream;
   }
 
   /**
    * The stream that is notified when contexts are added or removed.
    */
   Stream<ContextsChangedEvent> get onContextsChanged =>
-      contextDirectoryManager.onContextsChanged;
+      contextManager.onContextsChanged;
 
   /**
    * The stream that is notified when a single file has been analyzed.
    */
   Stream get onFileAnalyzed => _onFileAnalyzedController.stream;
 
   /**
    * The stream that is notified when priority sources change.
    */
   Stream<PriorityChangeEvent> get onPriorityChange =>
@@ skipping 32 matching lines @@
   void error(argument) {
     running = false;
   }
 
   /**
    * If the given notice applies to a file contained within an analysis root,
    * notify interested parties that the file has been (at least partially)
    * analyzed.
    */
   void fileAnalyzed(ChangeNotice notice) {
-    if (contextDirectoryManager.isInAnalysisRoot(notice.source.fullName)) {
+    if (contextManager.isInAnalysisRoot(notice.source.fullName)) {
       _onFileAnalyzedController.add(notice);
     }
   }
 
   /**
    * Return the preferred [AnalysisContext] for analyzing the given [path].
    * This will be the context that explicitly contains the path, if any such
    * context exists, otherwise it will be the first analysis context that
    * implicitly analyzes it.  Return `null` if no context is analyzing the
    * path.
@@ skipping 70 matching lines @@
     }
     // try to find the deep-most containing context
     Resource resource = resourceProvider.getResource(path);
     if (resource is! File) {
       return new ContextSourcePair(null, null);
     }
     File file = resource;
     {
       AnalysisContext containingContext = getContainingContext(path);
       if (containingContext != null) {
-        Source source =
-            ContextManager.createSourceInContext(containingContext, file);
+        Source source = AbstractContextManager.createSourceInContext(
+            containingContext, file);
         return new ContextSourcePair(containingContext, source);
       }
     }
     // try to find a context that analysed the file
     for (AnalysisContext context in folderMap.values) {
-      Source source = ContextManager.createSourceInContext(context, file);
+      Source source =
+          AbstractContextManager.createSourceInContext(context, file);
       SourceKind kind = context.getKindOf(source);
       if (kind != SourceKind.UNKNOWN) {
         return new ContextSourcePair(context, source);
       }
     }
     // try to find a context for which the file is a priority source
     for (InternalAnalysisContext context in folderMap.values) {
       List<Source> sources = context.getSourcesWithFullName(path);
       if (sources.isNotEmpty) {
         Source source = sources.first;
@@ skipping 279 matching lines @@
     // Clear any operations that are pending.
     if (roots == null) {
       operationQueue.clear();
     } else {
       for (AnalysisContext context in _getContexts(roots)) {
         operationQueue.contextRemoved(context);
       }
     }
     // Instruct the contextDirectoryManager to rebuild all contexts from
     // scratch.
-    contextDirectoryManager.refresh(roots);
+    contextManager.refresh(roots);
   }
 
   /**
    * Schedules execution of the given [ServerOperation].
    */
   void scheduleOperation(ServerOperation operation) {
     addOperation(operation);
     _schedulePerformOperation();
   }
 
@@ skipping 84 matching lines @@
    * The current implementation is intentionally simplified and expected
    * that only folders are given each given folder corresponds to the exactly
    * one context.
    *
    * So, we can start working in parallel on adding services and improving
    * projects/contexts support.
    */
   void setAnalysisRoots(String requestId, List<String> includedPaths,
       List<String> excludedPaths, Map<String, String> packageRoots) {
     try {
-      contextDirectoryManager.setRoots(
-          includedPaths, excludedPaths, packageRoots);
+      contextManager.setRoots(includedPaths, excludedPaths, packageRoots);
     } on UnimplementedError catch (e) {
       throw new RequestFailure(
           new Response.unsupportedFeature(requestId, e.message));
     }
   }
 
   /**
    * Implementation for `analysis.setSubscriptions`.
    */
   void setAnalysisSubscriptions(
@@ skipping 63 matching lines @@
       // Try to make the file analyzable.
       // If it is not in any context yet, add it to the first one which
       // could use it, e.g. imports its package, even if not the library.
       if (preferredContext == null) {
         Resource resource = resourceProvider.getResource(file);
         if (resource is File && resource.exists) {
           for (AnalysisContext context in folderMap.values) {
             Uri uri = context.sourceFactory.restoreUri(source);
             if (uri.scheme != 'file') {
               preferredContext = context;
-              source = ContextManager.createSourceInContext(context, resource);
+              source = AbstractContextManager.createSourceInContext(
+                  context, resource);
               break;
             }
           }
         }
       }
       // Fill the source map.
       bool contextFound = false;
       for (AnalysisContext context in folderMap.values) {
         if (context == preferredContext ||
             context.getKindOf(source) != SourceKind.UNKNOWN) {
@@ skipping 26 matching lines @@
     });
     operationQueue.reschedule();
     _onPriorityChangeController.add(new PriorityChangeEvent(firstSource));
   }
 
   /**
    * Returns `true` if errors should be reported for [file] with the given
    * absolute path.
    */
   bool shouldSendErrorsNotificationFor(String file) {
-    return !_noErrorNotification &&
-        contextDirectoryManager.isInAnalysisRoot(file);
+    return !_noErrorNotification && contextManager.isInAnalysisRoot(file);
   }
 
   void shutdown() {
     running = false;
     if (index != null) {
       index.clear();
       index.stop();
     }
     // Defer closing the channel and shutting down the instrumentation server so
     // that the shutdown response can be sent and logged.
@@ skipping 126 matching lines @@
     //
     // Update existing contexts.
     //
     folderMap.forEach((Folder folder, AnalysisContext context) {
       AnalysisOptionsImpl options =
           new AnalysisOptionsImpl.from(context.analysisOptions);
       optionUpdaters.forEach((OptionUpdater optionUpdater) {
         optionUpdater(options);
       });
       context.analysisOptions = options;
+      // TODO(brianwilkerson) As far as I can tell, this doesn't cause analysis

[Paul Berry, 2015/07/09 21:45:57]

Ouch.  I believe you are right.

+      // to be scheduled for this context.
     });
     //
     // Update the defaults used to create new contexts.
     //
-    AnalysisOptionsImpl options = contextDirectoryManager.defaultOptions;
+    AnalysisOptionsImpl options = contextManager.defaultOptions;
     optionUpdaters.forEach((OptionUpdater optionUpdater) {
       optionUpdater(options);
     });
   }
 
   /**
    * Return a set of contexts containing all of the resources in the given list
    * of [resources].
    */
   Set<AnalysisContext> _getContexts(List<Resource> resources) {
     Set<AnalysisContext> contexts = new HashSet<AnalysisContext>();
     resources.forEach((Resource resource) {
       if (resource is Folder) {
-        contexts
-            .addAll(contextDirectoryManager.contextsInAnalysisRoot(resource));
+        contexts.addAll(contextManager.contextsInAnalysisRoot(resource));
       }
     });
     return contexts;
   }
 
   /**
    * Returns the [CompilationUnit] of the Dart file with the given [source] that
    * should be used to resend notifications for already resolved unit.
    * Returns `null` if the file is not a part of any context, library has not
    * been yet resolved, or any problem happened.
@@ skipping 46 matching lines @@
 
 class AnalysisServerOptions {
   bool enableIncrementalResolutionApi = false;
   bool enableIncrementalResolutionValidation = false;
   bool noErrorNotification = false;
   bool noIndex = false;
   String fileReadMode = 'as-is';
 }
 
 /**
- * A [ContextsChangedEvent] indicate what contexts were added or removed.
- *
- * No context should be added to the event more than once. It does not make
- * sense, for example, for a context to be both added and removed.
+ * An implementation of a [ContextsChangedEvent].
  */
-class ContextsChangedEvent {
-
+class ContextsChangedEventImpl implements ContextsChangedEvent {

[Paul Berry, 2015/07/09 21:45:57]

I don't follow the benefit of making an interface/implementation distinction for
this class.  Usually the benefit would be to allow the implementation to be part
of the public API while the implementation remains private.  But since the
plug-in will have to provide an implementation of onContextsChanged, which
returns a stream of ContextsChangedEvent, that means that the plug-in will have
to be able to create concrete instantiations of ContextsChangedEvent.  So both
the implementation and the interface will have to be part of the public API in
order for someone to write a context manager plug-in.

[Brian Wilkerson, 2015/07/13 17:18:50]

I agree. Done.

   /**
    * The contexts that were added to the server.
    */
   final List<AnalysisContext> added;
 
   /**
    * The contexts that were changed.
    */
   final List<AnalysisContext> changed;
 
   /**
    * The contexts that were removed from the server.
    */
   final List<AnalysisContext> removed;
 
-  ContextsChangedEvent({this.added: AnalysisContext.EMPTY_LIST,
+  ContextsChangedEventImpl({this.added: AnalysisContext.EMPTY_LIST,
       this.changed: AnalysisContext.EMPTY_LIST,
       this.removed: AnalysisContext.EMPTY_LIST});
 }
 
 /**
  * Information about a file - an [AnalysisContext] that analyses the file,
  * and the [Source] representing the file in this context.
  */
 class ContextSourcePair {
   /**
@@ skipping 14 matching lines @@
 
 /**
  * A [PriorityChangeEvent] indicates the set the priority files has changed.
  */
 class PriorityChangeEvent {
   final Source firstSource;
 
   PriorityChangeEvent(this.firstSource);
 }
 
-class ServerContextManager extends ContextManager {
+class ServerContextManager extends AbstractContextManager {
   final AnalysisServer analysisServer;
 
   /**
    * The default options used to create new analysis contexts.
    */
   AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
 
   /**
    * The controller for sending [ContextsChangedEvent]s.
    */
@@ skipping 17 matching lines @@
 
   @override
   AnalysisContext addContext(Folder folder, UriResolver packageUriResolver) {
     InternalAnalysisContext context =
         AnalysisEngine.instance.createAnalysisContext();
     context.contentCache = analysisServer.overlayState;
     analysisServer.folderMap[folder] = context;
     context.sourceFactory = _createSourceFactory(packageUriResolver);
     context.analysisOptions = new AnalysisOptionsImpl.from(defaultOptions);
     _onContextsChangedController
-        .add(new ContextsChangedEvent(added: [context]));
+        .add(new ContextsChangedEventImpl(added: [context]));
     analysisServer.schedulePerformAnalysisOperation(context);
     return context;
   }
 
   @override
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet) {
     AnalysisContext context = analysisServer.folderMap[contextFolder];
     if (context != null) {
       context.applyChanges(changeSet);
       analysisServer.schedulePerformAnalysisOperation(context);
@@ skipping 23 matching lines @@
     // computeFlushedFiles instead of using the referenced context above, this
     // is an attempt to be careful concerning the referenced issue.
     List<String> flushedFiles = computeFlushedFiles(folder);
     sendAnalysisNotificationFlushResults(analysisServer, flushedFiles);
 
     if (analysisServer.index != null) {
       analysisServer.index.removeContext(context);
     }
     analysisServer.operationQueue.contextRemoved(context);
     _onContextsChangedController
-        .add(new ContextsChangedEvent(removed: [context]));
+        .add(new ContextsChangedEventImpl(removed: [context]));
     analysisServer.sendContextAnalysisDoneNotifications(
         context, AnalysisDoneReason.CONTEXT_REMOVED);
     context.dispose();
   }
 
   @override
   bool shouldFileBeAnalyzed(File file) {
     List<ShouldAnalyzeFile> functions =
         analysisServer.serverPlugin.analyzeFileFunctions;
     for (ShouldAnalyzeFile shouldAnalyzeFile in functions) {
       if (shouldAnalyzeFile(file)) {
         // Emacs creates dummy links to track the fact that a file is open for
         // editing and has unsaved changes (e.g. having unsaved changes to
         // 'foo.dart' causes a link '.#foo.dart' to be created, which points to
         // the non-existent file 'username@hostname.pid'. To avoid these dummy
         // links causing the analyzer to thrash, just ignore links to
         // non-existent files.
         return file.exists;
       }
     }
     return false;
   }
 
   @override
   void updateContextPackageUriResolver(
       Folder contextFolder, UriResolver packageUriResolver) {
     AnalysisContext context = analysisServer.folderMap[contextFolder];
     context.sourceFactory = _createSourceFactory(packageUriResolver);
     _onContextsChangedController
-        .add(new ContextsChangedEvent(changed: [context]));
+        .add(new ContextsChangedEventImpl(changed: [context]));
     analysisServer.schedulePerformAnalysisOperation(context);
   }
 
   void _computingPackageMap(bool computing) {
     if (analysisServer.serverServices.contains(ServerService.STATUS)) {
       PubStatus pubStatus = new PubStatus(computing);
       ServerStatusParams params = new ServerStatusParams(pub: pubStatus);
       analysisServer.sendNotification(params.toNotification());
     }
   }
@@ skipping 115 matching lines @@
   /**
    * The [PerformanceTag] for time spent in server request handlers.
    */
   static PerformanceTag serverRequests = new PerformanceTag('serverRequests');
 
   /**
    * The [PerformanceTag] for time spent in split store microtasks.
    */
   static PerformanceTag splitStore = new PerformanceTag('splitStore');
 }