Extract analysis/notifications into a separate operation/file.

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 'package:analysis_server/src/analysis_logger.dart';
 import 'package:analysis_server/src/channel.dart';
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/context_directory_manager.dart';
 import 'package:analysis_server/src/domain_analysis.dart';
+import 'package:analysis_server/src/operation/operation_analysis.dart';
 import 'package:analysis_server/src/operation/operation.dart';
 import 'package:analysis_server/src/operation/operation_queue.dart';
 import 'package:analysis_server/src/protocol.dart';
 import 'package:analysis_server/src/resource.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
-import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/sdk_io.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analysis_server/src/computers.dart';
 
 
 /**
  * An instance of [DirectoryBasedDartSdk] that is shared between
  * [AnalysisServer] instances to improve performance.
@@ skipping 97 matching lines @@
    */
   void schedulePerformAnalysisOperation(AnalysisContext context) {
     scheduleOperation(new PerformAnalysisOperation(context, false));
   }
 
   /**
    * Schedules execution of the given [ServerOperation].
    */
   void scheduleOperation(ServerOperation operation) {
     bool wasEmpty = operationQueue.isEmpty;
-    operationQueue.add(operation);
+    addOperation(operation);
     if (wasEmpty) {
       _schedulePerformOperation();
     }
   }
 
   /**
+   * 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.
    */
   void done() {
     running = false;
   }
 
   /**
    * There was an error related to the socket from which requests are being
    * read.
    */
@@ skipping 15 matching lines @@
         }
       } on RequestFailure catch (exception) {
         channel.sendResponse(exception.response);
         return;
       }
     }
     channel.sendResponse(new Response.unknownRequest(request));
   }
 
   /**
+   * Returns `true` if there is a subscription for the given [server] and [file].
+   */
+  bool hasAnalysisSubscription(AnalysisService service, String file) {
+    Set<String> files = analysisServices[service];
+    return files != null && files.contains(file);
+  }
+
+  /**
    * Returns `true` if the given [AnalysisContext] is a priority one.
    */
   bool isPriorityContext(AnalysisContext context) {
     // TODO(scheglov) implement support for priority sources/contexts
     return false;
   }
 
   /**
    * Perform the next available [ServerOperation].
    */
@@ skipping 15 matching lines @@
     } finally {
       if (!operationQueue.isEmpty) {
         _schedulePerformOperation();
       } else {
         sendStatusNotification(null);
       }
     }
   }
 
   /**
-   * Perform analysis in the given [AnalysisContext].
-   */
-  void internalPerformAnalysis(AnalysisContext context) {
-    //
-    // TODO(brianwilkerson) Add an optional function-valued parameter to
-    // performAnalysisTask that will be called when the task has been computed
-    // but before it is performed and send notification in the function:
-    //
-    // AnalysisResult result = context.performAnalysisTask((taskDescription) {
-    //   sendStatusNotification(context.toString(), taskDescription);
-    // });
-    // prepare results
-    AnalysisResult result = context.performAnalysisTask();
-    List<ChangeNotice> notices = result.changeNotices;
-    if (notices == null) {
-      return;
-    }
-    // TODO(scheglov) remember known sources
-    // TODO(scheglov) index units
-    // TODO(scheglov) schedule notifications
-    sendNotices(notices);
-    // continue analysis
-    operationQueue.add(new PerformAnalysisOperation(context, true));
-  }
-
-  /**
-   * Send the information in the given list of notices back to the client.
-   */
-  void sendNotices(List<ChangeNotice> notices) {
-    for (int i = 0; i < notices.length; i++) {
-      ChangeNotice notice = notices[i];
-      Source source = notice.source;
-      CompilationUnit dartUnit = notice.compilationUnit;
-      // TODO(scheglov) use default subscriptions
-      String file = source.fullName;
-      if (dartUnit != null) {
-        Set<String> files = analysisServices[AnalysisService.HIGHLIGHTS];
-        if (files != null && files.contains(file)) {
-          sendAnalysisNotificationHighlights(file, dartUnit);
-        }
-      }
-      if (!source.isInSystemLibrary) {
-        // errors
-        sendAnalysisNotificationErrors(file, notice.errors);
-      }
-    }
-  }
-
-  void sendAnalysisNotificationErrors(String file, List<AnalysisError> errors) {
-    Notification notification = new Notification(NOTIFICATION_ERRORS);
-    notification.setParameter(FILE, file);
-    notification.setParameter(ERRORS, errors.map(errorToJson).toList());
-    sendNotification(notification);
-  }
-
-  void sendAnalysisNotificationHighlights(String file, CompilationUnit dartUnit) {
-    Notification notification = new Notification(NOTIFICATION_HIGHLIGHTS);
-    notification.setParameter(FILE, file);
-    notification.setParameter(
-        REGIONS,
-        new DartUnitHighlightsComputer(dartUnit).compute());
-    sendNotification(notification);
-  }
-
-  /**
    * Send status notification to the client. The `contextId` indicates
    * the current context being analyzed or `null` if analysis is complete.
    */
   void sendStatusNotification(String contextId) {
 //    if (contextId == lastStatusNotificationContextId) {
 //      return;
 //    }
 //    lastStatusNotificationContextId = contextId;
     Notification notification = new Notification(NOTIFICATION_STATUS);
     Map<String, Object> analysis = new Map();
@@ skipping 57 matching lines @@
   void setAnalysisSubscriptions(Map<AnalysisService, Set<String>> subscriptions) {
     // send notifications for already analyzed sources
     subscriptions.forEach((service, Set<String> newFiles) {
       Set<String> oldFiles = analysisServices[service];
       Set<String> todoFiles = oldFiles != null ? newFiles.difference(oldFiles) : newFiles;
       for (String file in todoFiles) {
         if (service == AnalysisService.ERRORS) {
           Source source = _getSource(file);
           AnalysisContext analysisContext = _getAnalysisContext(file);
           List<AnalysisError> errors = analysisContext.getErrors(source).errors;
-          sendAnalysisNotificationErrors(file, errors);
+          sendAnalysisNotificationErrors(this, file, errors);
         }
         if (service == AnalysisService.HIGHLIGHTS) {
           CompilationUnit dartUnit = test_getResolvedCompilationUnit(file);
           if (dartUnit != null) {
-            sendAnalysisNotificationHighlights(file, dartUnit);
+            sendAnalysisNotificationHighlights(this, file, dartUnit);
           }
         }
       }
     });
     // remember new subscriptions
     this.analysisServices = subscriptions;
   }
 
   /**
    * Return the [AnalysisContext] that is used to analyze the given [path].
@@ skipping 36 matching lines @@
     return context.getResolvedCompilationUnit2(unitSource, librarySources[0]);
   }
 
   /**
    * Return `true` if all operations have been performed in this [AnalysisServer].
    */
   bool test_areOperationsFinished() {
     return operationQueue.isEmpty;
   }
 
-  static Map<String, Object> errorToJson(AnalysisError analysisError) {
-    // TODO(paulberry): move this function into the AnalysisError class.
-    ErrorCode errorCode = analysisError.errorCode;
-    Map<String, Object> result = {
-      'file': analysisError.source.fullName,
-      // TODO(scheglov) add Enum.fullName ?
-      'errorCode': '${errorCode.runtimeType}.${(errorCode as Enum).name}',
-      'offset': analysisError.offset,
-      'length': analysisError.length,
-      'message': analysisError.message
-    };
-    if (analysisError.correction != null) {
-      result['correction'] = analysisError.correction;
-    }
-    return result;
-  }
-
   /**
    * Send the given [notification] to the client.
    */
   void sendNotification(Notification notification) {
     channel.sendNotification(notification);
   }
 
   /**
    * Schedules [performOperation] exection.
    */
@@ skipping 68 matching lines @@
 /**
  * An enumeration of the services provided by the server domain.
  */
 class ServerService extends Enum2<ServerService> {
   static const ServerService STATUS = const ServerService('STATUS', 0);
 
   static const List<ServerService> VALUES = const [STATUS];
 
   const ServerService(String name, int ordinal) : super(name, ordinal);
 }