'Extract Local' and 'Inline Local' refactoring need only single file analysis.

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/plugin/edit/assist/assist_core.dart';
 import 'package:analysis_server/plugin/edit/fix/fix_core.dart';
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/collections.dart';
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/protocol_server.dart' hide Element;
 import 'package:analysis_server/src/services/correction/assist.dart';
 import 'package:analysis_server/src/services/correction/fix.dart';
 import 'package:analysis_server/src/services/correction/organize_directives.dart';
 import 'package:analysis_server/src/services/correction/sort_members.dart';
 import 'package:analysis_server/src/services/correction/status.dart';
 import 'package:analysis_server/src/services/refactoring/refactoring.dart';
 import 'package:analysis_server/src/services/search/search_engine.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart' as engine;
 import 'package:analyzer/src/generated/engine.dart' as engine;
 import 'package:analyzer/src/generated/error.dart' as engine;
 import 'package:analyzer/src/generated/parser.dart' as engine;
 import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/task/dart.dart';
 import 'package:dart_style/dart_style.dart';
 
+int test_resetCount = 0;
+
 bool test_simulateRefactoringException_change = false;
 bool test_simulateRefactoringException_final = false;
 bool test_simulateRefactoringException_init = false;
 
 bool test_simulateRefactoringReset_afterCreateChange = false;
 bool test_simulateRefactoringReset_afterFinalConditions = false;
 bool test_simulateRefactoringReset_afterInitialConditions = false;
 
 /**
  * Instances of the class [EditDomainHandler] implement a [RequestHandler]
@@ skipping 328 matching lines @@
  *
  * 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;
+  StreamSubscription subscriptionToReset;
 
   RefactoringKind kind;
   String file;
   int offset;
   int length;
   Refactoring refactoring;
   RefactoringFeedback feedback;
   RefactoringStatus initStatus;
   RefactoringStatus optionsStatus;
   RefactoringStatus finalStatus;
 
   Request request;
   EditGetRefactoringResult result;
 
   _RefactoringManager(this.server, this.searchEngine) {
-    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;
   }
 
   /**
    * Cancels processing of the current request and cleans up.
    */
   void cancel() {
-    onAnalysisStartedSubscription.cancel();
+    subscriptionToReset?.cancel();
+    subscriptionToReset = null;
     server.sendResponse(new Response.refactoringRequestCancelled(request));
     request = null;
   }
 
   void getRefactoring(Request _request) {
     // prepare for processing the request
     request = _request;
     result = new EditGetRefactoringResult(
         EMPTY_PROBLEM_LIST, EMPTY_PROBLEM_LIST, EMPTY_PROBLEM_LIST);
     // process the request
@@ skipping 49 matching lines @@
         cancel();
       } else {
         server.instrumentationService.logException(exception, stackTrace);
         server.sendResponse(
             new Response.serverError(_request, exception, stackTrace));
       }
       _reset();
     });
   }
 
+  /**
+   * Perform enough analysis to be able to perform refactoring of the given
+   * [kind] in the given [file].
+   */
+  Future<Null> _analyzeForRefactoring(String file, RefactoringKind kind) async {
+    // "Extract Local" and "Inline Local" refactorings need only local analysis.
+    if (kind == RefactoringKind.EXTRACT_LOCAL_VARIABLE ||
+        kind == RefactoringKind.INLINE_LOCAL_VARIABLE) {
+      ContextSourcePair pair = server.getContextSourcePair(file);
+      engine.AnalysisContext context = pair.context;
+      Source source = pair.source;
+      if (context != null && source != null) {
+        if (context.computeResult(source, SOURCE_KIND) == SourceKind.LIBRARY) {
+          await context.computeResolvedCompilationUnitAsync(source, source);
+          return;
+        }
+      }
+    }
+    // A refactoring for which we cannot optimize analysis.
+    // So, wait for full analysis.
+    await server.onAnalysisComplete;
+  }
+
   void _checkForReset_afterCreateChange() {
     if (test_simulateRefactoringReset_afterCreateChange) {
       _reset();
     }
     if (refactoring == null) {
       throw new _ResetError();
     }
   }
 
   void _checkForReset_afterFinalConditions() {
@@ skipping 13 matching lines @@
       throw new _ResetError();
     }
   }
 
   /**
    * 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 {
-    await server.onAnalysisComplete;
+    await _analyzeForRefactoring(file, kind);
     // check if we can continue with the existing Refactoring instance
     if (this.kind == kind &&
         this.file == file &&
         this.offset == offset &&
         this.length == length) {
       return;
     }
     _reset();
     this.kind = kind;
     this.file = file;
     this.offset = offset;
     this.length = length;
     // simulate an exception
     if (test_simulateRefactoringException_init) {
       throw 'A simulated refactoring exception - init.';
     }
     // create a new Refactoring instance
     if (kind == RefactoringKind.CONVERT_GETTER_TO_METHOD) {
       List<Element> elements = server.getElementsAtOffset(file, offset);
       if (elements.isNotEmpty) {
         Element element = elements[0];
         if (element is ExecutableElement) {
+          _resetOnAnalysisStarted();
           refactoring =
               new ConvertGetterToMethodRefactoring(searchEngine, element);
         }
       }
     }
     if (kind == RefactoringKind.CONVERT_METHOD_TO_GETTER) {
       List<Element> elements = server.getElementsAtOffset(file, offset);
       if (elements.isNotEmpty) {
         Element element = elements[0];
         if (element is ExecutableElement) {
+          _resetOnAnalysisStarted();
           refactoring =
               new ConvertMethodToGetterRefactoring(searchEngine, element);
         }
       }
     }
     if (kind == RefactoringKind.EXTRACT_LOCAL_VARIABLE) {
       List<CompilationUnit> units = server.getResolvedCompilationUnits(file);
       if (units.isNotEmpty) {
+        _resetOnFileResolutionChanged(file);
         refactoring = new ExtractLocalRefactoring(units[0], offset, length);
         feedback = new ExtractLocalVariableFeedback(
             <String>[], <int>[], <int>[],
             coveringExpressionOffsets: <int>[],
             coveringExpressionLengths: <int>[]);
       }
     }
     if (kind == RefactoringKind.EXTRACT_METHOD) {
       List<CompilationUnit> units = server.getResolvedCompilationUnits(file);
       if (units.isNotEmpty) {
+        _resetOnAnalysisStarted();
         refactoring = new ExtractMethodRefactoring(
             searchEngine, units[0], offset, length);
         feedback = new ExtractMethodFeedback(offset, length, '', <String>[],
             false, <RefactoringMethodParameter>[], <int>[], <int>[]);
       }
     }
     if (kind == RefactoringKind.INLINE_LOCAL_VARIABLE) {
       List<CompilationUnit> units = server.getResolvedCompilationUnits(file);
       if (units.isNotEmpty) {
+        _resetOnFileResolutionChanged(file);
         refactoring =
             new InlineLocalRefactoring(searchEngine, units[0], offset);
       }
     }
     if (kind == RefactoringKind.INLINE_METHOD) {
       List<CompilationUnit> units = server.getResolvedCompilationUnits(file);
       if (units.isNotEmpty) {
+        _resetOnAnalysisStarted();
         refactoring =
             new InlineMethodRefactoring(searchEngine, units[0], offset);
       }
     }
     if (kind == RefactoringKind.MOVE_FILE) {
+      _resetOnAnalysisStarted();
       ContextSourcePair contextSource = server.getContextSourcePair(file);
       engine.AnalysisContext context = contextSource.context;
       Source source = contextSource.source;
       refactoring = new MoveFileRefactoring(
           server.resourceProvider, searchEngine, context, source, file);
     }
     if (kind == RefactoringKind.RENAME) {
       List<AstNode> nodes = server.getNodesAtOffset(file, offset);
       List<Element> elements = server.getElementsOfNodes(nodes);
       if (nodes.isNotEmpty && elements.isNotEmpty) {
         AstNode node = nodes[0];
         Element element = elements[0];
         if (element is FieldFormalParameterElement) {
           element = (element as FieldFormalParameterElement).field;
         }
         // climb from "Class" in "new Class.named()" to "Class.named"
         if (node.parent is TypeName && node.parent.parent is ConstructorName) {
           ConstructorName constructor = node.parent.parent;
           node = constructor;
           element = constructor.staticElement;
         }
         // do create the refactoring
+        _resetOnAnalysisStarted();
         refactoring = new RenameRefactoring(searchEngine, element);
         feedback =
             new RenameFeedback(node.offset, node.length, 'kind', 'oldName');
       }
     }
     if (refactoring == null) {
       initStatus =
           new RefactoringStatus.fatal('Unable to create a refactoring');
       return;
     }
@@ skipping 37 matching lines @@
       }
     }
     if (refactoring is RenameRefactoring) {
       RenameRefactoring refactoring = this.refactoring;
       RenameFeedback feedback = this.feedback;
       feedback.elementKindName = refactoring.elementKindName;
       feedback.oldName = refactoring.oldName;
     }
   }
 
-  void _reset([engine.AnalysisContext context]) {
+  void _reset() {
+    test_resetCount++;
     kind = null;
     offset = null;
     length = null;
     refactoring = null;
     feedback = null;
     initStatus = new RefactoringStatus();
     optionsStatus = new RefactoringStatus();
     finalStatus = new RefactoringStatus();
+    subscriptionToReset?.cancel();
+    subscriptionToReset = null;
+  }
+
+  void _resetOnAnalysisStarted() {
+    subscriptionToReset = server.onAnalysisStarted.listen((_) => _reset());

[Brian Wilkerson, 2016/08/22 23:32:23]

Should we assert that `subscriptionToReset` is null before we assign it, here
and below?

[scheglov, 2016/08/23 01:55:28]

Well, we need to at least cancel the current subscription, if it exists.
Done.

+  }
+
+  /**
+   * We're performing a refactoring that affects only the given [file].
+   * So, when the [file] resolution is changed, we need to reset refactoring.
+   * But when any other file is changed or analyzer, we can continue.
+   */
+  void _resetOnFileResolutionChanged(String file) {
+    engine.AnalysisContext context = server.getAnalysisContext(file);
+    subscriptionToReset =
+        context?.onResultChanged(RESOLVED_UNIT)?.listen((event) {
+      Source targetSource = event.target.source;
+      if (targetSource?.fullName == file) {
+        _reset();
+      }
+    });
   }
 
   void _sendResultResponse() {
     // ignore if was cancelled
     if (request == null) {
       return;
     }
     // set feedback
     result.feedback = feedback;
     // set problems
@@ skipping 48 matching lines @@
     }
     return new RefactoringStatus();
   }
 }
 
 /**
  * [_RefactoringManager] throws instances of this class internally to stop
  * processing in a manager that was reset.
  */
 class _ResetError {}