Remove the unused operations queue

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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:core';
 import 'dart:io' as io;
 import 'dart:math' show max;
 
 import 'package:analysis_server/protocol/protocol.dart';
 import 'package:analysis_server/protocol/protocol_generated.dart'
     hide AnalysisOptions;
 import 'package:analysis_server/src/analysis_logger.dart';
 import 'package:analysis_server/src/channel/channel.dart';
 import 'package:analysis_server/src/collections.dart';
 import 'package:analysis_server/src/computer/computer_highlights.dart';
 import 'package:analysis_server/src/computer/computer_highlights2.dart';
 import 'package:analysis_server/src/computer/computer_outline.dart';
 import 'package:analysis_server/src/computer/new_notifications.dart';
 import 'package:analysis_server/src/context_manager.dart';
 import 'package:analysis_server/src/domains/analysis/navigation.dart';
 import 'package:analysis_server/src/domains/analysis/navigation_dart.dart';
 import 'package:analysis_server/src/domains/analysis/occurrences.dart';
 import 'package:analysis_server/src/domains/analysis/occurrences_dart.dart';
-import 'package:analysis_server/src/operation/operation.dart';
 import 'package:analysis_server/src/operation/operation_analysis.dart';
-import 'package:analysis_server/src/operation/operation_queue.dart';
 import 'package:analysis_server/src/plugin/notification_manager.dart';
 import 'package:analysis_server/src/plugin/plugin_manager.dart';
 import 'package:analysis_server/src/plugin/plugin_watcher.dart';
 import 'package:analysis_server/src/plugin/server_plugin.dart';
 import 'package:analysis_server/src/protocol_server.dart' as server;
 import 'package:analysis_server/src/server/diagnostic_server.dart';
 import 'package:analysis_server/src/services/correction/namespace.dart';
 import 'package:analysis_server/src/services/index/index.dart';
 import 'package:analysis_server/src/services/search/search_engine.dart';
 import 'package:analysis_server/src/services/search/search_engine_internal.dart';
@@ skipping 58 matching lines @@
  * [CommunicationChannel] for analysis requests and process them.
  */
 class AnalysisServer {
   /**
    * The version of the analysis server. The value should be replaced
    * automatically during the build.
    */
   static final String VERSION = '1.18.1';
 
   /**
-   * The number of milliseconds to perform operations before inserting
-   * a 1 millisecond delay so that the VM and dart:io can deliver content
-   * to stdin. This should be removed once the underlying problem is fixed.
-   */
-  static int performOperationDelayFrequency = 25;
-
-  /**
    * The options of this server instance.
    */
   AnalysisServerOptions options;
 
   /**
    * The channel from which requests are received and to which responses should
    * be sent.
    */
   final ServerCommunicationChannel channel;
 
@@ skipping 64 matching lines @@
    * The object used to manage the SDK's known to this server.
    */
   DartSdkManager sdkManager;
 
   /**
    * The instrumentation service that is to be used by this analysis server.
    */
   final InstrumentationService instrumentationService;
 
   /**
-   * A queue of the operations to perform in this server.
-   */
-  ServerOperationQueue operationQueue;
-
-  /**
-   * True if there is a pending future which will execute [performOperation].
-   */
-  bool performOperationPending = false;
-
-  /**
    * A set of the [ServerService]s to send notifications for.
    */
   Set<ServerService> serverServices = new HashSet<ServerService>();
 
   /**
    * A set of the [GeneralAnalysisService]s to send notifications for.
    */
   Set<GeneralAnalysisService> generalAnalysisServices =
       new HashSet<GeneralAnalysisService>();
 
   /**
    * A table mapping [AnalysisService]s to the file paths for which these
    * notifications should be sent.
    */
   Map<AnalysisService, Set<String>> analysisServices =
       new HashMap<AnalysisService, Set<String>>();
 
   /**
-   * A table mapping [AnalysisContext]s to the completers that should be
-   * completed when analysis of this context is finished.
-   */
-  Map<AnalysisContext, Completer<AnalysisDoneReason>>
-      contextAnalysisDoneCompleters =
-      new HashMap<AnalysisContext, Completer<AnalysisDoneReason>>();
-
-  /**
    * Performance information before initial analysis is complete.
    */
   ServerPerformance performanceDuringStartup = new ServerPerformance();
 
   /**
    * Performance information after initial analysis is complete
    * or `null` if the initial analysis is not yet complete
    */
   ServerPerformance performanceAfterStartup;
 
   /**
    * A [RecentBuffer] of the most recent exceptions encountered by the analysis
    * server.
    */
   final RecentBuffer<ServerException> exceptions = new RecentBuffer(10);
 
   /**
    * The class into which performance information is currently being recorded.
    * During startup, this will be the same as [performanceDuringStartup]
    * and after startup is complete, this switches to [performanceAfterStartup].
    */
   ServerPerformance _performance;
 
   /**
    * The [Completer] that completes when analysis is complete.
    */
   Completer _onAnalysisCompleteCompleter;
 
   /**
-   * The [Completer] that completes when the next operation is performed.
-   */
-  Completer _test_onOperationPerformedCompleter;
-
-  /**
    * The controller that is notified when analysis is started.
    */
   StreamController<bool> _onAnalysisStartedController;
 
   /**
    * 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;
-
-  /**
-   * The next time (milliseconds since epoch) after which the analysis server
-   * should pause so that pending requests can be fetched by the system.
-   */
-  // Add 1 sec to prevent delay from impacting short running tests
-  int _nextPerformOperationDelayTime =
-      new DateTime.now().millisecondsSinceEpoch + 1000;
-
-  /**
    * The content overlay for all analysis drivers.
    */
   final nd.FileContentOverlay fileContentOverlay = new nd.FileContentOverlay();
 
   /**
    * The current state of overlays from the client.  This is used as the
    * content cache for all contexts.
    */
   final ContentCache overlayState = new ContentCache();
 
@@ skipping 88 matching lines @@
       this.channel,
       this.resourceProvider,
       PubPackageMapProvider packageMapProvider,
       this.index,
       this.serverPlugin,
       this.options,
       this.sdkManager,
       this.instrumentationService,
       {this.diagnosticServer,
       ResolverProvider fileResolverProvider: null,
-      ResolverProvider packageResolverProvider: null,
-      this.rethrowExceptions: true})
+      ResolverProvider packageResolverProvider: null})
       : notificationManager =
             new NotificationManager(channel, resourceProvider) {
     _performance = performanceDuringStartup;
 
     pluginManager = new PluginManager(
         resourceProvider,
         _getByteStorePath(),
         sdkManager.defaultSdkDirectory,
         notificationManager,
         instrumentationService);
     PluginWatcher pluginWatcher =
         new PluginWatcher(resourceProvider, pluginManager);
 
     defaultContextOptions.incremental = true;
     defaultContextOptions.incrementalApi =
         options.enableIncrementalResolutionApi;
     defaultContextOptions.incrementalValidation =
         options.enableIncrementalResolutionValidation;
     defaultContextOptions.generateImplicitErrors = false;
-    operationQueue = new ServerOperationQueue();
 
     {
       String name = options.newAnalysisDriverLog;
       StringSink sink = new NullStringSink();
       if (name != null) {
         if (name == 'stdout') {
           sink = io.stdout;
         } else if (name.startsWith('file:')) {
           String path = name.substring('file:'.length);
           sink = new io.File(path).openWrite(mode: io.FileMode.APPEND);
@@ skipping 104 matching lines @@
   Stream get onFileAnalyzed => _onFileAnalyzedController.stream;
 
   /**
    * The stream that is notified when a single file has been changed. This
    * exists as a temporary stopgap for plugins, until the official plugin API is
    * complete.
    */
   Stream get onFileChanged => _onFileChangedController.stream;
 
   /**
-   * The [Future] that completes when the next operation is performed.
-   */
-  Future get test_onOperationPerformed {
-    if (_test_onOperationPerformedCompleter == null) {
-      _test_onOperationPerformedCompleter = new Completer();
-    }
-    return _test_onOperationPerformedCompleter.future;
-  }
-
-  /**
    * Return the total time the server's been alive.
    */
   Duration get uptime {
     DateTime start = new DateTime.fromMillisecondsSinceEpoch(
         performanceDuringStartup.startTime);
     return new DateTime.now().difference(start);
   }
 
   /**
-   * 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() {
     index?.stop();
     running = false;
   }
 
   /**
    * There was an error related to the socket from which requests are being
    * read.
@@ skipping 198 matching lines @@
    */
   bool hasAnalysisSubscription(AnalysisService service, String file) {
     Set<String> files = analysisServices[service];
     return files != null && files.contains(file);
   }
 
   /**
    * Return `true` if analysis is complete.
    */
   bool isAnalysisComplete() {
-    return operationQueue.isEmpty && !analysisDriverScheduler.isAnalyzing;
+    return !analysisDriverScheduler.isAnalyzing;
   }
 
   /**
    * Return `true` if the given path is a valid `FilePath`.
    *
    * This means that it is absolute and normalized.
    */
   bool isValidFilePath(String path) {
     return resourceProvider.absolutePathContext.isValid(path);
   }
 
   /**
-   * Perform the next available [ServerOperation].
-   */
-  void performOperation() {
-    assert(performOperationPending);
-    PerformanceTag.unknown.makeCurrent();
-    performOperationPending = false;
-    if (!running) {
-      // An error has occurred, or the connection to the client has been
-      // closed, since this method was scheduled on the event queue.  So
-      // don't do anything.  Instead clear the operation queue.
-      operationQueue.clear();
-      return;
-    }
-    // prepare next operation
-    ServerOperation operation = operationQueue.take();
-    if (operation == null) {
-      // This can happen if the operation queue is cleared while the operation
-      // loop is in progress.  No problem; we just need to exit the operation
-      // loop and wait for the next operation to be added.
-      ServerPerformanceStatistics.idle.makeCurrent();
-      return;
-    }
-    sendStatusNotification(operation);
-    // perform the operation
-    try {
-      operation.perform(this);
-    } catch (exception, stackTrace) {
-      sendServerErrorNotification(
-          'Failed to perform operation: $operation', exception, stackTrace,
-          fatal: true);
-      if (rethrowExceptions) {
-        throw new AnalysisException('Unexpected exception during analysis',
-            new CaughtException(exception, stackTrace));
-      }
-      shutdown();
-    } finally {
-      if (_test_onOperationPerformedCompleter != null) {
-        _test_onOperationPerformedCompleter.complete(operation);
-        _test_onOperationPerformedCompleter = null;
-      }
-      if (!operationQueue.isEmpty) {
-        ServerPerformanceStatistics.intertask.makeCurrent();
-        _schedulePerformOperation();
-      } else {
-        if (generalAnalysisServices
-            .contains(GeneralAnalysisService.ANALYZED_FILES)) {
-          sendAnalysisNotificationAnalyzedFiles(this);
-        }
-        sendStatusNotification(null);
-        _scheduleAnalysisImplementedNotification();
-        if (_onAnalysisCompleteCompleter != null) {
-          _onAnalysisCompleteCompleter.complete();
-          _onAnalysisCompleteCompleter = null;
-        }
-        ServerPerformanceStatistics.idle.makeCurrent();
-      }
-    }
-  }
-
-  /**
    * Trigger reanalysis of all files in the given list of analysis [roots], or
    * everything if the analysis roots is `null`.
    */
   void reanalyze(List<Resource> roots) {
-    // Clear any operations that are pending.
-    if (roots == null) {
-      operationQueue.clear();
-    } else {
-      // TODO(brianwilkerson) All of the contexts returned by _getContexts will
-      // be null. If we are still using the operation queue, then this needs to
-      // be changed to use drivers.
-//      for (AnalysisContext context in _getContexts(roots)) {
-//        operationQueue.contextRemoved(context);
-//      }
-    }
     // Instruct the contextDirectoryManager to rebuild all contexts from
     // scratch.
     contextManager.refresh(roots);
   }
 
   /**
-   * Schedule cache consistency validation in [context].
-   * The most of the validation must be done asynchronously.
-   */
-  void scheduleCacheConsistencyValidation(AnalysisContext context) {
-    if (context is InternalAnalysisContext) {
-      CacheConsistencyValidator validator = context.cacheConsistencyValidator;
-      List<Source> sources = validator.getSourcesToComputeModificationTimes();
-      // Compute modification times and notify the validator asynchronously.
-      new Future(() async {
-        try {
-          List<int> modificationTimes =
-              await resourceProvider.getModificationTimes(sources);
-          bool cacheInconsistencyFixed = validator
-              .sourceModificationTimesComputed(sources, modificationTimes);
-          if (cacheInconsistencyFixed) {
-            scheduleOperation(new PerformAnalysisOperation(context, false));
-          }
-        } catch (exception, stackTrace) {
-          sendServerErrorNotification(
-              'Failed to check cache consistency', exception, stackTrace);
-        }
-      });
-    }
-  }
-
-  /**
-   * Schedules execution of the given [ServerOperation].
-   */
-  void scheduleOperation(ServerOperation operation) {
-    addOperation(operation);
-    _schedulePerformOperation();
-  }
-
-  /**
-   * Schedules analysis of the given context.
-   */
-  void schedulePerformAnalysisOperation(AnalysisContext context) {
-    _onAnalysisStartedController.add(true);
-    scheduleOperation(new PerformAnalysisOperation(context, false));
-  }
-
-  /**
-   * This method is called when analysis of the given [AnalysisContext] is
-   * done.
-   */
-  void sendContextAnalysisDoneNotifications(
-      AnalysisContext context, AnalysisDoneReason reason) {
-    Completer<AnalysisDoneReason> completer =
-        contextAnalysisDoneCompleters.remove(context);
-    if (completer != null) {
-      completer.complete(reason);
-    }
-  }
-
-  /**
    * Send the given [notification] to the client.
    */
   void sendNotification(Notification notification) {
     channel.sendNotification(notification);
   }
 
   /**
    * Send the given [response] to the client.
    */
   void sendResponse(Response response) {
@@ skipping 22 matching lines @@
             .toNotification());
 
     // remember the last few exceptions
     if (exception is CaughtException) {
       stackTrace ??= exception.stackTrace;
     }
     exceptions.add(new ServerException(message, exception, stackTrace, fatal));
   }
 
   /**
-   * Send status notification to the client. The `operation` is the operation
-   * being performed or `null` if analysis is complete.
-   */
-  void sendStatusNotification(ServerOperation operation) {
-    // Only send status when subscribed.
-    if (!serverServices.contains(ServerService.STATUS)) {
-      return;
-    }
-    // Only send status when it changes
-    bool isAnalyzing = operation != null;
-    if (statusAnalyzing == isAnalyzing) {
-      return;
-    }
-    statusAnalyzing = isAnalyzing;
-    AnalysisStatus analysis = new AnalysisStatus(isAnalyzing);
-    channel.sendNotification(
-        new ServerStatusParams(analysis: analysis).toNotification());
-  }
-
-  /**
    * Send status notification to the client. The state of analysis is given by
    * the [status] information.
    */
   void sendStatusNotificationNew(nd.AnalysisStatus status) {
     if (status.isAnalyzing) {
       _onAnalysisStartedController.add(true);
     }
     if (_onAnalysisCompleteCompleter != null && !status.isAnalyzing) {
       _onAnalysisCompleteCompleter.complete();
       _onAnalysisCompleteCompleter = null;
@@ skipping 112 matching lines @@
     }
     // Defer closing the channel and shutting down the instrumentation server so
     // that the shutdown response can be sent and logged.
     new Future(() {
       instrumentationService.shutdown();
       channel.close();
     });
   }
 
   /**
-   * Performs all scheduled analysis operations.
-   */
-  void test_performAllAnalysisOperations() {
-    while (true) {
-      ServerOperation operation = operationQueue.takeIf((operation) {
-        return operation is PerformAnalysisOperation;
-      });
-      if (operation == null) {
-        break;
-      }
-      operation.perform(this);
-    }
-  }
-
-  /**
    * Implementation for `analysis.updateContent`.
    */
   void updateContent(String id, Map<String, dynamic> changes) {
     changes.forEach((file, change) {
       // Prepare the new contents.
       String oldContents = fileContentOverlay[file];
       String newContents;
       if (change is AddContentOverlay) {
         newContents = change.content;
       } else if (change is ChangeContentOverlay) {
@@ skipping 108 matching lines @@
   }
 
   _scheduleAnalysisImplementedNotification() async {
     Set<String> files = analysisServices[AnalysisService.IMPLEMENTED];
     if (files != null) {
       scheduleImplementedNotification(this, files);
     }
   }
 
   /**
-   * Schedules [performOperation] execution.
-   */
-  void _schedulePerformOperation() {
-    if (performOperationPending) {
-      return;
-    }
-    /*
-     * TODO (danrubel) Rip out this workaround once the underlying problem
-     * is fixed. Currently, the VM and dart:io do not deliver content
-     * on stdin in a timely manner if the event loop is busy.
-     * To work around this problem, we delay for 1 millisecond
-     * every 25 milliseconds.
-     *
-     * To disable this workaround and see the underlying problem,
-     * set performOperationDelayFrequency to zero
-     */
-    int now = new DateTime.now().millisecondsSinceEpoch;
-    if (now > _nextPerformOperationDelayTime &&
-        performOperationDelayFrequency > 0) {
-      _nextPerformOperationDelayTime = now + performOperationDelayFrequency;
-      new Future.delayed(new Duration(milliseconds: 1), performOperation);
-    } else {
-      new Future(performOperation);
-    }
-    performOperationPending = true;
-  }
-
-  /**
    * Listen for context events and invalidate index.
    *
    * It is possible that this method will do more in the future, e.g. listening
    * for summary information and linking pre-indexed packages into the index,
    * but for now we only invalidate project specific index information.
    */
   void _setupIndexInvalidation() {
     if (index == null) {
       return;
     }
@@ skipping 452 matching lines @@
   /**
    * The [PerformanceTag] for time spent in server request handlers.
    */
   static PerformanceTag serverRequests = server.createChild('requests');
 
   /**
    * The [PerformanceTag] for time spent in split store microtasks.
    */
   static PerformanceTag splitStore = new PerformanceTag('splitStore');
 }