new onPriorityChanged event stream

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 'package:analysis_server/src/analysis_logger.dart';
@@ skipping 145 matching lines @@
    * The controller that is notified when analysis is complete.
    */
   StreamController _onAnalysisCompleteController;
 
   /**
    * The controller that is notified when a single file has been analyzed.
    */
   StreamController<ChangeNotice> _onFileAnalyzedController;
 
   /**
+   * The controller used to notify others when priority sources change.
+   */
+  StreamController<PriorityChangeEvent> _onPriorityChangeController;
+
+  /**
    * True if any exceptions thrown by analysis should be propagated up the call
    * stack.
    */
   bool rethrowExceptions;
 
   /**
    * The stream that is notified when contexts are added or removed.
    */
   Stream<ContextsChangedEvent> onContextsChanged;
 
@@ skipping 12 matching lines @@
     searchEngine = createSearchEngine(index);
     operationQueue = new ServerOperationQueue(this);
     contextDirectoryManager =
         new ServerContextManager(this, resourceProvider, packageMapProvider);
     onContextsChanged =
         contextDirectoryManager.onContextsChanged.asBroadcastStream();
     AnalysisEngine.instance.logger = new AnalysisLogger();
     _onAnalysisStartedController = new StreamController.broadcast();
     _onAnalysisCompleteController = new StreamController.broadcast();
     _onFileAnalyzedController = new StreamController.broadcast();
+    _onPriorityChangeController =
+        new StreamController<PriorityChangeEvent>.broadcast();
     running = true;
     Notification notification = new ServerConnectedParams().toNotification();
     channel.sendNotification(notification);
     channel.listen(handleRequest, onDone: done, onError: error);
   }
 
   /**
    * The stream that is notified when analysis is complete.
    */
   Stream get onAnalysisComplete => _onAnalysisCompleteController.stream;
 
   /**
    * 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 a single file has been analyzed.
    */
   Stream get onFileAnalyzed => _onFileAnalyzedController.stream;
 
   /**
+   * The stream that is notified when priority sources change.
+   */
+  Stream<PriorityChangeEvent> get onPriorityChange =>
+      _onPriorityChangeController.stream;
+
+  /**
    * Adds the given [ServerOperation] to the queue, but does not schedule
    * operations execution.
    */
   void addOperation(ServerOperation operation) {
     operationQueue.add(operation);
   }
 
   /**
    * The socket from which requests are being read has been closed.
    */
@@ skipping 107 matching lines @@
     }
     // prepare Source
     Source source = getSource(file);
     if (context.getKindOf(source) == SourceKind.UNKNOWN) {
       return null;
     }
     // get errors for the file
     return context.getErrors(source);
   }
 
-  /**
-   * Returns resolved [AstNode]s at the given [offset] of the given [file].
-   *
-   * May be empty, but not `null`.
-   */
-  List<AstNode> getNodesAtOffset(String file, int offset) {
-    List<CompilationUnit> units = getResolvedCompilationUnits(file);
-    List<AstNode> nodes = <AstNode>[];
-    for (CompilationUnit unit in units) {
-      AstNode node = new NodeLocator.con1(offset).searchWithin(unit);
-      if (node != null) {
-        nodes.add(node);
-      }
-    }
-    return nodes;
-  }
-
 // TODO(brianwilkerson) Add the following method after 'prioritySources' has
 // been added to InternalAnalysisContext.
 //  /**
 //   * Return a list containing the full names of all of the sources that are
 //   * priority sources.
 //   */
 //  List<String> getPriorityFiles() {
 //    List<String> priorityFiles = new List<String>();
 //    folderMap.values.forEach((ContextDirectory directory) {
 //      InternalAnalysisContext context = directory.context;
 //      context.prioritySources.forEach((Source source) {
 //        priorityFiles.add(source.fullName);
 //      });
 //    });
 //    return priorityFiles;
 //  }
 
   /**
-   * Returns resolved [CompilationUnit]s of the Dart file with the given [path].
+   * Returns resolved [AstNode]s at the given [offset] of the given [file].
    *
    * May be empty, but not `null`.
    */
-  List<CompilationUnit> getResolvedCompilationUnits(String path) {
-    List<CompilationUnit> units = <CompilationUnit>[];
-    // prepare AnalysisContext
-    AnalysisContext context = getAnalysisContext(path);
-    if (context == null) {
-      return units;
-    }
-    // add a unit for each unit/library combination
-    Source unitSource = getSource(path);
-    List<Source> librarySources = context.getLibrariesContaining(unitSource);
-    for (Source librarySource in librarySources) {
-      CompilationUnit unit =
-          context.resolveCompilationUnit2(unitSource, librarySource);
-      if (unit != null) {
-        units.add(unit);
+  List<AstNode> getNodesAtOffset(String file, int offset) {
+    List<CompilationUnit> units = getResolvedCompilationUnits(file);
+    List<AstNode> nodes = <AstNode>[];
+    for (CompilationUnit unit in units) {
+      AstNode node = new NodeLocator.con1(offset).searchWithin(unit);
+      if (node != null) {
+        nodes.add(node);
       }
     }
-    // done
-    return units;
+    return nodes;
   }
 
   /**
    * Returns the [CompilationUnit] of the Dart file with the given [path] 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.
    */
   CompilationUnit getResolvedCompilationUnitToResendNotification(String path) {
     // prepare AnalysisContext
@@ skipping 10 matching lines @@
     // if library has not been resolved yet, the unit will be resolved later
     Source librarySource = librarySources[0];
     if (context.getLibraryElement(librarySource) == null) {
       return null;
     }
     // if library has been already resolved, resolve unit
     return context.resolveCompilationUnit2(unitSource, librarySource);
   }
 
   /**
+   * Returns resolved [CompilationUnit]s of the Dart file with the given [path].
+   *
+   * May be empty, but not `null`.
+   */
+  List<CompilationUnit> getResolvedCompilationUnits(String path) {
+    List<CompilationUnit> units = <CompilationUnit>[];
+    // prepare AnalysisContext
+    AnalysisContext context = getAnalysisContext(path);
+    if (context == null) {
+      return units;
+    }
+    // add a unit for each unit/library combination
+    Source unitSource = getSource(path);
+    List<Source> librarySources = context.getLibrariesContaining(unitSource);
+    for (Source librarySource in librarySources) {
+      CompilationUnit unit =
+          context.resolveCompilationUnit2(unitSource, librarySource);
+      if (unit != null) {
+        units.add(unit);
+      }
+    }
+    // done
+    return units;
+  }
+
+  /**
    * Return the [Source] of the Dart file with the given [path].
    */
   Source getSource(String path) {
     // try SDK
     {
       Uri uri = resourceProvider.pathContext.toUri(path);
       Source sdkSource = defaultSdk.fromFileUri(uri);
       if (sdkSource != null) {
         return sdkSource;
       }
@@ skipping 287 matching lines @@
         }
       }
     });
     // remember new subscriptions
     this.analysisServices = subscriptions;
   }
 
   /**
    * Set the priority files to the given [files].
    */
-  void setPriorityFiles(Request request, List<String> files) {
+  void setPriorityFiles(String requestId, List<String> files) {
     Map<AnalysisContext, List<Source>> sourceMap =
         new HashMap<AnalysisContext, List<Source>>();
     List<String> unanalyzed = new List<String>();
     files.forEach((file) {
       AnalysisContext analysisContext = getAnalysisContext(file);
       if (analysisContext == null) {
         unanalyzed.add(file);
       } else {
         List<Source> sourceList = sourceMap[analysisContext];
         if (sourceList == null) {
           sourceList = <Source>[];
           sourceMap[analysisContext] = sourceList;
         }
         sourceList.add(getSource(file));
       }
     });
     if (unanalyzed.isNotEmpty) {
       StringBuffer buffer = new StringBuffer();
       buffer.writeAll(unanalyzed, ', ');
       throw new RequestFailure(
-          new Response.unanalyzedPriorityFiles(request, buffer.toString()));
+          new Response.unanalyzedPriorityFiles(requestId, buffer.toString()));
     }
     folderMap.forEach((Folder folder, AnalysisContext context) {
       List<Source> sourceList = sourceMap[context];
       if (sourceList == null) {
         sourceList = Source.EMPTY_ARRAY;
       }
       context.analysisPriorityOrder = sourceList;
     });
+    Source firstSource = files.length > 0 ? getSource(files[0]) : null;
+    _onPriorityChangeController.add(new PriorityChangeEvent(firstSource));
   }
 
   /**
    * Returns `true` if errors should be reported for [file] with the given
    * absolute path.
    */
   bool shouldSendErrorsNotificationFor(String file) {
     // TODO(scheglov) add support for the "--no-error-notification" flag.
     return contextDirectoryManager.isInAnalysisRoot(file);
   }
@@ skipping 135 matching lines @@
 
   /**
    * The contexts that were removed from the server.
    */
   final List<AnalysisContext> removed;
 
   ContextsChangedEvent({this.added: AnalysisContext.EMPTY_LIST, this.changed:
       AnalysisContext.EMPTY_LIST, this.removed: AnalysisContext.EMPTY_LIST});
 }
 
+/**
+ * A [PriorityChangeEvent] indicates which sources are currently prioritized

[Brian Wilkerson, 2014/11/24 16:17:11]

I think it indicates that the list of priority changes has been changed.

[danrubel, 2014/11/24 17:54:06]

Cleaned up.

+ * and should be analyzed before other sources.
+ */
+class PriorityChangeEvent {
+  final Source firstSource;

[Brian Wilkerson, 2014/11/24 16:17:11]

Shouldn't this be a List<Source>? Or possibly a Map<AnalysisContext,
List<Source>>?

[danrubel, 2014/11/24 17:54:05]

I only need the first source if there is one and I was keeping the event
minimal. If we find listeners need more information, we can enhance the API.

[Brian Wilkerson, 2014/11/24 18:14:38]

Understood, and in general I agree with only doing what we need now (I
considered suggesting that we also include the old priority list but decided we
didn't need it yet and could cleanly add it later).

However, defining 'firstSource' means that we will always have to support it for
backward compatibility. In this case I think it would be better to support a
more general API and not have that constraint. (I suppose it won't be too
terrible to always need to have an accessor for the first element in the list,
but still...)

+
+  PriorityChangeEvent(this.firstSource);
+}
+
 class ServerContextManager extends ContextManager {
   final AnalysisServer analysisServer;
 
   /**
    * The default options used to create new analysis contexts.
    */
   AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
 
   /**
    * The controller for sending [ContextsChangedEvent]s.
@@ skipping 60 matching lines @@
    * [packageUriResolver].
    */
   SourceFactory _createSourceFactory(UriResolver packageUriResolver) {
     List<UriResolver> resolvers = <UriResolver>[
         new DartUriResolver(analysisServer.defaultSdk),
         new ResourceUriResolver(resourceProvider),
         packageUriResolver];
     return new SourceFactory(resolvers);
   }
 }