Add notification of analyzed files

pkg/analysis_server/test/integration/integration_test_methods.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 file has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script
 // "pkg/analysis_server/tool/spec/generate_files".
 
 /**
  * Convenience methods for running integration tests
@@ skipping 222 matching lines @@
         .then((result) {
       ResponseDecoder decoder = new ResponseDecoder(null);
       return new AnalysisGetHoverResult.fromJson(decoder, 'result', result);
     });
   }
 
   /**
    * Return library dependency information for use in client-side indexing and
    * package URI resolution.
    *
+   * Clients that are only using the libraries field should consider using the
+   * analyzedFiles notification instead.
+   *
    * Returns
    *
    * libraries ( List<FilePath> )
    *
    *   A list of the paths of library elements referenced by files in existing
    *   analysis roots.
    *
    * packageMap ( Map<String, Map<String, List<FilePath>>> )
    *
    *   A mapping from context source roots to package maps which map package
@@ skipping 153 matching lines @@
   Future sendAnalysisSetAnalysisRoots(List<String> included, List<String> excluded, {Map<String, String> packageRoots}) {
     var params = new AnalysisSetAnalysisRootsParams(included, excluded, packageRoots: packageRoots).toJson();
     return server.send("analysis.setAnalysisRoots", params)
         .then((result) {
       expect(result, isNull);
       return null;
     });
   }
 
   /**
+   * Subscribe for general services (that is, services that are not specific to
+   * individual files). All previous subscriptions are replaced by the given
+   * set of services.
+   *
+   * It is an error if any of the elements in the list are not valid services.
+   * If there is an error, then the current subscriptions will remain
+   * unchanged.
+   *
+   * Parameters
+   *
+   * subscriptions ( List<GeneralAnalysisService> )
+   *
+   *   A list of the services being subscribed to.
+   */
+  Future sendAnalysisSetGeneralSubscriptions(List<GeneralAnalysisService> subscriptions) {
+    var params = new AnalysisSetGeneralSubscriptionsParams(subscriptions).toJson();
+    return server.send("analysis.setGeneralSubscriptions", params)
+        .then((result) {
+      expect(result, isNull);
+      return null;
+    });
+  }
+
+  /**
    * Set the priority files to the files in the given list. A priority file is
    * a file that is given priority when scheduling which analysis work to do
    * first. The list typically contains those files that are visible to the
    * user and those for which analysis results will have the biggest impact on
    * the user experience. The order of the files within the list is
    * significant: the first file will be given higher priority than the second,
    * the second higher priority than the third, and so on.
    *
    * Note that this request determines the set of requested priority files. The
    * actual set of priority files is the intersection of the requested set of
@@ skipping 14 matching lines @@
   Future sendAnalysisSetPriorityFiles(List<String> files) {
     var params = new AnalysisSetPriorityFilesParams(files).toJson();
     return server.send("analysis.setPriorityFiles", params)
         .then((result) {
       expect(result, isNull);
       return null;
     });
   }
 
   /**
-   * Subscribe for services. All previous subscriptions are replaced by the
-   * current set of subscriptions. If a given service is not included as a key
-   * in the map then no files will be subscribed to the service, exactly as if
-   * the service had been included in the map with an explicit empty list of
-   * files.
+   * Subscribe for services that are specific to individual files. All previous
+   * subscriptions are replaced by the current set of subscriptions. If a given
+   * service is not included as a key in the map then no files will be
+   * subscribed to the service, exactly as if the service had been included in
+   * the map with an explicit empty list of files.
    *
    * Note that this request determines the set of requested subscriptions. The
    * actual set of subscriptions at any given time is the intersection of this
    * set with the set of files currently subject to analysis. The files
    * currently subject to analysis are the set of files contained within an
    * actual analysis root but not excluded, plus all of the files transitively
    * reachable from those files via import, export and part directives. (See
    * analysis.setAnalysisRoots for an explanation of how the actual analysis
    * roots are determined.) When the actual analysis roots change, the actual
    * set of subscriptions is automatically updated, but the set of requested
@@ skipping 64 matching lines @@
   Future sendAnalysisUpdateOptions(AnalysisOptions options) {
     var params = new AnalysisUpdateOptionsParams(options).toJson();
     return server.send("analysis.updateOptions", params)
         .then((result) {
       expect(result, isNull);
       return null;
     });
   }
 
   /**
+   * Reports the paths of the files that are being analyzed.
+   *
+   * This notification is not subscribed to by default. Clients can subscribe
+   * by including the value "ANALYZED_FILES" in the list of services passed in
+   * an analysis.setGeneralSubscriptions request.
+   *
+   * Parameters
+   *
+   * directories ( List<FilePath> )
+   *
+   *   A list of the paths of the files that are being analyzed.
+   */
+  Stream<AnalysisAnalyzedFilesParams> onAnalysisAnalyzedFiles;
+
+  /**
+   * Stream controller for [onAnalysisAnalyzedFiles].
+   */
+  StreamController<AnalysisAnalyzedFilesParams> _onAnalysisAnalyzedFiles;
+
+  /**
    * Reports the errors associated with a given file. The set of errors
    * included in the notification is always a complete list that supersedes any
    * previously reported errors.
    *
    * It is only possible to unsubscribe from this notification by using the
    * command-line flag --no-error-notification.
    *
    * Parameters
    *
    * file ( FilePath )
@@ skipping 956 matching lines @@
    * Initialize the fields in InttestMixin, and ensure that notifications will
    * be handled.
    */
   void initializeInttestMixin() {
     _onServerConnected = new StreamController<ServerConnectedParams>(sync: true);
     onServerConnected = _onServerConnected.stream.asBroadcastStream();
     _onServerError = new StreamController<ServerErrorParams>(sync: true);
     onServerError = _onServerError.stream.asBroadcastStream();
     _onServerStatus = new StreamController<ServerStatusParams>(sync: true);
     onServerStatus = _onServerStatus.stream.asBroadcastStream();
+    _onAnalysisAnalyzedFiles = new StreamController<AnalysisAnalyzedFilesParams>(sync: true);
+    onAnalysisAnalyzedFiles = _onAnalysisAnalyzedFiles.stream.asBroadcastStream();
     _onAnalysisErrors = new StreamController<AnalysisErrorsParams>(sync: true);
     onAnalysisErrors = _onAnalysisErrors.stream.asBroadcastStream();
     _onAnalysisFlushResults = new StreamController<AnalysisFlushResultsParams>(sync: true);
     onAnalysisFlushResults = _onAnalysisFlushResults.stream.asBroadcastStream();
     _onAnalysisFolding = new StreamController<AnalysisFoldingParams>(sync: true);
     onAnalysisFolding = _onAnalysisFolding.stream.asBroadcastStream();
     _onAnalysisHighlights = new StreamController<AnalysisHighlightsParams>(sync: true);
     onAnalysisHighlights = _onAnalysisHighlights.stream.asBroadcastStream();
     _onAnalysisInvalidate = new StreamController<AnalysisInvalidateParams>(sync: true);
     onAnalysisInvalidate = _onAnalysisInvalidate.stream.asBroadcastStream();
@@ skipping 25 matching lines @@
         _onServerConnected.add(new ServerConnectedParams.fromJson(decoder, 'params', params));
         break;
       case "server.error":
         expect(params, isServerErrorParams);
         _onServerError.add(new ServerErrorParams.fromJson(decoder, 'params', params));
         break;
       case "server.status":
         expect(params, isServerStatusParams);
         _onServerStatus.add(new ServerStatusParams.fromJson(decoder, 'params', params));
         break;
+      case "analysis.analyzedFiles":
+        expect(params, isAnalysisAnalyzedFilesParams);
+        _onAnalysisAnalyzedFiles.add(new AnalysisAnalyzedFilesParams.fromJson(decoder, 'params', params));
+        break;
       case "analysis.errors":
         expect(params, isAnalysisErrorsParams);
         _onAnalysisErrors.add(new AnalysisErrorsParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.flushResults":
         expect(params, isAnalysisFlushResultsParams);
         _onAnalysisFlushResults.add(new AnalysisFlushResultsParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.folding":
         expect(params, isAnalysisFoldingParams);
@@ skipping 34 matching lines @@
       case "execution.launchData":
         expect(params, isExecutionLaunchDataParams);
         _onExecutionLaunchData.add(new ExecutionLaunchDataParams.fromJson(decoder, 'params', params));
         break;
       default:
         fail('Unexpected notification: $event');
         break;
     }
   }
 }