Issue 22157. Cancel a pending refactoring request on receiving a new one.

pkg/analysis_server/lib/src/edit/edit_domain.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 edit.domain;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/collections.dart';
@@ skipping 35 matching lines @@
    */
   SearchEngine searchEngine;
 
   _RefactoringManager refactoringManager;
 
   /**
    * Initialize a newly created handler to handle requests for the given [server].
    */
   EditDomainHandler(this.server) {
     searchEngine = server.searchEngine;
-    refactoringManager = new _RefactoringManager(server, searchEngine);
+    _newRefactoringManager();
   }
 
   Response format(Request request) {
 
     EditFormatParams params = new EditFormatParams.fromRequest(request);
     String file = params.file;
 
     engine.AnalysisContext context = server.getAnalysisContext(file);
     if (context == null) {
       return new Response.formatInvalidFile(request);
@@ skipping 118 matching lines @@
       String requestName = request.method;
       if (requestName == EDIT_FORMAT) {
         return format(request);
       } else if (requestName == EDIT_GET_ASSISTS) {
         return getAssists(request);
       } else if (requestName == EDIT_GET_AVAILABLE_REFACTORINGS) {
         return getAvailableRefactorings(request);
       } else if (requestName == EDIT_GET_FIXES) {
         return getFixes(request);
       } else if (requestName == EDIT_GET_REFACTORING) {
-        refactoringManager.getRefactoring(request);
-        return Response.DELAYED_RESPONSE;
+        return _getRefactoring(request);
       } else if (requestName == EDIT_SORT_MEMBERS) {
         return sortMembers(request);
       }
     } on RequestFailure catch (exception) {
       return exception.response;
     }
     return null;
   }
 
   Response sortMembers(Request request) {
@@ skipping 25 matching lines @@
       return new Response.sortMembersParseErrors(request, numScanParseErrors);
     }
     // do sort
     int fileStamp = context.getModificationStamp(source);
     String code = context.getContents(source).data;
     MemberSorter sorter = new MemberSorter(code, unit);
     List<SourceEdit> edits = sorter.sort();
     SourceFileEdit fileEdit = new SourceFileEdit(file, fileStamp, edits: edits);
     return new EditSortMembersResult(fileEdit).toResponse(request.id);
   }
+
+  Response _getRefactoring(Request request) {
+    if (refactoringManager.hasPendingRequest) {
+      refactoringManager.cancel();
+      _newRefactoringManager();
+    }
+    refactoringManager.getRefactoring(request);
+    return Response.DELAYED_RESPONSE;
+  }
+
+  /**
+   * Initializes [refactoringManager] with a new instance.
+   */
+  void _newRefactoringManager() {
+    refactoringManager = new _RefactoringManager(server, searchEngine);
+  }
 }
 
 
 /**
  * An object managing a single [Refactoring] instance.
  *
  * The instance is identified by its kind, file, offset and length.
  * It is initialized when the a set of parameters is given for the first time.
  * All subsequent requests are performed on this [Refactoring] instance.
  *
  * Once new set of parameters is received, the previous [Refactoring] instance
  * is invalidated and a new one is created and initialized.
  */
 class _RefactoringManager {
   static const List<RefactoringProblem> EMPTY_PROBLEM_LIST = const
       <RefactoringProblem>[
       ];
 
   final AnalysisServer server;
   final SearchEngine searchEngine;
+  StreamSubscription onAnalysisStartedSubscription;
 
   RefactoringKind kind;
   String file;
   int offset;
   int length;
   Refactoring refactoring;
   RefactoringFeedback feedback;
   RefactoringStatus initStatus;
   RefactoringStatus optionsStatus;
   RefactoringStatus finalStatus;
 
-  String requestId;
+  Request request;
   EditGetRefactoringResult result;
 
   _RefactoringManager(this.server, this.searchEngine) {
-    server.onAnalysisStarted.listen(_reset);
+    onAnalysisStartedSubscription = server.onAnalysisStarted.listen(_reset);
     _reset();
   }
 
+  /**
+   * Returns `true` if a response for the current request has not yet been sent.
+   */
+  bool get hasPendingRequest => request != null;
+
   bool get _hasFatalError {
     return initStatus.hasFatalError ||
         optionsStatus.hasFatalError ||
         finalStatus.hasFatalError;
   }
 
   /**
    * Checks if [refactoring] requires options.
    */
   bool get _requiresOptions {
     return refactoring is ExtractLocalRefactoring ||
         refactoring is ExtractMethodRefactoring ||
         refactoring is InlineMethodRefactoring ||
         refactoring is MoveFileRefactoring ||
         refactoring is RenameRefactoring;
   }
 
-  void getRefactoring(Request request) {
+  /**
+   * Cancels processing of the current request and cleans up.
+   */
+  void cancel() {
+    onAnalysisStartedSubscription.cancel();
+    server.sendResponse(new Response.refactoringRequestCancelled(request));
+    request = null;
+  }
+
+  void getRefactoring(Request _request) {
     // prepare for processing the request
-    requestId = request.id;
+    request = _request;
     result = new EditGetRefactoringResult(
         EMPTY_PROBLEM_LIST,
         EMPTY_PROBLEM_LIST,
         EMPTY_PROBLEM_LIST);
     // process the request
-    var params = new EditGetRefactoringParams.fromRequest(request);
+    var params = new EditGetRefactoringParams.fromRequest(_request);
     runZoned(() async {
       await _init(params.kind, params.file, params.offset, params.length);
       if (initStatus.hasFatalError) {
         feedback = null;
         _sendResultResponse();
         return;
       }
       // set options
       if (_requiresOptions) {
         if (params.options == null) {
@@ skipping 27 matching lines @@
       if (test_simulateRefactoringException_change) {
         throw 'A simulated refactoring exception - change.';
       }
       // create change
       result.change = await refactoring.createChange();
       result.potentialEdits = nullIfEmpty(refactoring.potentialEditIds);
       _sendResultResponse();
     }, onError: (exception, stackTrace) {
       server.instrumentationService.logException(exception, stackTrace);
       server.sendResponse(
-          new Response.serverError(request, exception, stackTrace));
+          new Response.serverError(_request, exception, stackTrace));
       _reset();
     });
   }
 
   /**
    * Initializes this context to perform a refactoring with the specified
    * parameters. The existing [Refactoring] is reused or created as needed.
    */
   Future _init(RefactoringKind kind, String file,
       int offset, int length) async {
@@ skipping 152 matching lines @@
     offset = null;
     length = null;
     refactoring = null;
     feedback = null;
     initStatus = new RefactoringStatus();
     optionsStatus = new RefactoringStatus();
     finalStatus = new RefactoringStatus();
   }
 
   void _sendResultResponse() {
+    // ignore if was cancelled
+    if (request == null) {
+      return;
+    }
+    // set feedback
     result.feedback = feedback;
     // set problems
     result.initialProblems = initStatus.problems;
     result.optionsProblems = optionsStatus.problems;
     result.finalProblems = finalStatus.problems;
     // send the response
-    server.sendResponse(result.toResponse(requestId));
+    server.sendResponse(result.toResponse(request.id));
     // done with this request
-    requestId = null;
+    request = null;
     result = null;
   }
 
   RefactoringStatus _setOptions(EditGetRefactoringParams params) {
     if (refactoring is ExtractLocalRefactoring) {
       ExtractLocalRefactoring extractRefactoring = refactoring;
       ExtractLocalVariableOptions extractOptions = params.options;
       extractRefactoring.name = extractOptions.name;
       extractRefactoring.extractAll = extractOptions.extractAll;
       return extractRefactoring.checkName();
@@ skipping 25 matching lines @@
     }
     if (refactoring is RenameRefactoring) {
       RenameRefactoring renameRefactoring = refactoring;
       RenameOptions renameOptions = params.options;
       renameRefactoring.newName = renameOptions.newName;
       return renameRefactoring.checkNewName();
     }
     return new RefactoringStatus();
   }
 }