Rework launch data

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:analyzer/file_system/file_system.dart';
@@ skipping 200 matching lines @@
    * The controller that is notified when analysis is started.
    */
   StreamController<AnalysisContext> _onAnalysisStartedController;
 
   /**
    * 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;
+
+  /**
    * True if any exceptions thrown by analysis should be propagated up the call
    * stack.
    */
   bool rethrowExceptions;
 
   /**
    * Initialize a newly created server to receive requests from and send
    * responses to the given [channel].
    *
    * 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,
       PackageMapProvider packageMapProvider, this.index, this.defaultSdk,
       {this.rethrowExceptions: true}) {
     searchEngine = createSearchEngine(index);
     operationQueue = new ServerOperationQueue(this);
     contextDirectoryManager =
         new ServerContextManager(this, resourceProvider, packageMapProvider);
     AnalysisEngine.instance.logger = new AnalysisLogger();
     _onAnalysisStartedController = new StreamController.broadcast();
     _onAnalysisCompleteController = new StreamController.broadcast();
+    _onFileAnalyzedController = new StreamController.broadcast();
     running = true;
     Notification notification = new ServerConnectedParams().toNotification();
     channel.sendNotification(notification);
     channel.listen(handleRequest, onDone: done, onError: error);
   }
 
   /**
+   * 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)) {
+      _onFileAnalyzedController.add(notice);
+    }
+  }
+
+  /**
    * Schedules execution of the given [ServerOperation].
    */
   void scheduleOperation(ServerOperation operation) {
     bool wasEmpty = operationQueue.isEmpty;
     addOperation(operation);
     if (wasEmpty) {
       _schedulePerformOperation();
     }
   }
 
@@ skipping 85 matching lines @@
   Stream<AnalysisContext> get onAnalysisStarted {
     return _onAnalysisStartedController.stream;
   }
 
   /**
    * The stream that is notified when analysis is complete.
    */
   Stream get onAnalysisComplete => _onAnalysisCompleteController.stream;
 
   /**
+   * The stream that is notified when a single file has been analyzed.
+   */
+  Stream get onFileAnalyzed => _onFileAnalyzedController.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 565 matching lines @@
     // send the notification
     channel.sendNotification(
         new ServerErrorParams(
             true,
             exceptionString,
             stackTraceString).toNotification());
   }
 }
 
 typedef void OptionUpdater(AnalysisOptionsImpl options);