process sorter analysis request(s)

pkg/analysis_server/lib/src/services/completion/dart_completion_manager.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 services.completion.dart;
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart';
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/provisional/completion/completion_core.dart'
-    show CompletionRequest;
+    show AnalysisRequest, CompletionRequest;
 import 'package:analysis_server/src/provisional/completion/completion_dart.dart'
     as newApi;
 import 'package:analysis_server/src/provisional/completion/dart/completion_target.dart';
 import 'package:analysis_server/src/services/completion/arglist_contributor.dart';
 import 'package:analysis_server/src/services/completion/combinator_contributor.dart';
 import 'package:analysis_server/src/services/completion/common_usage_computer.dart';
 import 'package:analysis_server/src/services/completion/completion_manager.dart';
 import 'package:analysis_server/src/services/completion/contribution_sorter.dart';
 import 'package:analysis_server/src/services/completion/dart_completion_cache.dart';
 import 'package:analysis_server/src/services/completion/imported_reference_contributor.dart';
 import 'package:analysis_server/src/services/completion/keyword_contributor.dart';
 import 'package:analysis_server/src/services/completion/local_reference_contributor.dart';
 import 'package:analysis_server/src/services/completion/optype.dart';
 import 'package:analysis_server/src/services/completion/prefixed_element_contributor.dart';
 import 'package:analysis_server/src/services/completion/uri_contributor.dart';
 import 'package:analysis_server/src/services/search/search_engine.dart';
 import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/src/cancelable_future.dart';
+import 'package:analyzer/src/context/context.dart'
+    show AnalysisFutureHelper, AnalysisContextImpl;
 import 'package:analyzer/src/generated/ast.dart';
-import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/engine.dart' hide AnalysisContextImpl;
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/task/model.dart';
 
 const int DART_RELEVANCE_COMMON_USAGE = 1200;
 const int DART_RELEVANCE_DEFAULT = 1000;
 const int DART_RELEVANCE_HIGH = 2000;
 const int DART_RELEVANCE_INHERITED_ACCESSOR = 1057;
 const int DART_RELEVANCE_INHERITED_FIELD = 1058;
 const int DART_RELEVANCE_INHERITED_METHOD = 1057;
 const int DART_RELEVANCE_KEYWORD = 1055;
 const int DART_RELEVANCE_LOCAL_ACCESSOR = 1057;
 const int DART_RELEVANCE_LOCAL_FIELD = 1058;
@@ skipping 130 matching lines @@
           }
         }
       }
 
       List<DartCompletionContributor> todo = new List.from(contributors);
       todo.removeWhere((DartCompletionContributor c) {
         return performance.logElapseTime('computeFast ${c.runtimeType}', () {
           return c.computeFast(request);
         });
       });
-      // TODO(danrubel) Process the AnalysisRequest returned by the
-      // contribution sorter. At this point, the target unit has been fully
-      // resolved, thus no need for additional resolution, but in the future...
-      contributionSorter.sort(request, request.suggestions);
-
+      _processAnalysisRequest(request,
+          contributionSorter.sort(request, request.suggestions));
+      // TODO (danrubel) if request is obsolete
+      // (processAnalysisRequest returns false)
+      // then send empty results
       if (todo.isEmpty) {
         sendResults(request, todo.isEmpty);

[Brian Wilkerson, 2015/11/17 15:11:37]

If I understand correctly, this will only work if the `sort` method returns
`null`. If it actually needed additional results we would end up sending the
results before the results could be computed. If that's true, we should fail
quickly until we've implemented the rest of the support for it.

And this will necessitate that every method that could eventually invoke this
method be made asynchronous. Is it really worth while in order to allow sorting
to request additional results? Would it be better / possible to allow the
suggestions to capture enough information that we don't need more data in order
to sort them?

[danrubel, 2015/11/17 18:35:44]

Correct. Per discussion, I will be adding support for this over the next several
CLs as I incrementally convert all contributors to the new API.
The _processAnalysisRequest method will be used to process every analysis
request for every contributor. Requests for analysis from the sorter will be
handled in the same way after contributors. In addition, the computeFast and
computeFull methods will be combined into a single compute suggestions method.
Given this, I think supporting the sorter in this way will add only minimal
complexity.

       }
       return todo;
     });
   }
 
   /**
    * If there is remaining work to be done, then wait for the unit to be
    * resolved and request that each remaining contributor finish their work.
    * Return a [Future] that completes when the last notification has been sent.
    */
@@ skipping 17 matching lines @@
         int count = todo.length;
         todo.forEach((DartCompletionContributor c) {
           String name = c.runtimeType.toString();
           String completeTag = 'computeFull $name complete';
           performance.logStartTime(completeTag);
           performance.logElapseTime('computeFull $name', () {
             c.computeFull(request).then((bool changed) {
               performance.logElapseTime(completeTag);
               bool last = --count == 0;
               if (changed || last) {
-                // TODO(danrubel) Process the AnalysisRequest returned by the
-                // contribution sorter. At this point, the target unit has been
-                // fully resolved, thus no need for additional resolution,
-                // but in the future...
-                contributionSorter.sort(request, request.suggestions);
+                _processAnalysisRequest(request,
+                    contributionSorter.sort(request, request.suggestions));
+                // TODO (danrubel) if request is obsolete
+                // (processAnalysisRequest returns false)
+                // then send empty results
                 sendResults(request, last);
               }
             });
           });
         });
       });
     });
   }
 
   @override
@@ skipping 37 matching lines @@
     Source libSource = libraries[0];
     assert(libSource != null);
     return context
         .computeResolvedCompilationUnitAsync(source, libSource)
         .catchError((_) {
       // This source file is not scheduled for analysis, so a resolved
       // compilation unit is never going to get computed.
       return null;
     }, test: (e) => e is AnalysisNotScheduledError);
   }
+
+  /**
+   * Process the analysis [analysis] and any subsequent requests.
+   * Return a [Future] that returns `true`
+   * once all analysis requests have been processed
+   * or `false` if the original completion request is obsolete
+   * and processing requests was terminated before finished.
+   */
+  Future<bool> _processAnalysisRequest(
+      CompletionRequest request, AnalysisRequest analysis) {
+    // Return if no additional analysis is necessary
+    if (analysis == null) {
+      return new Future.value(true);
+    }
+
+    // Check to see if the result is already cached
+    var cachedValue = context.getResult(analysis.target, analysis.descriptor);
+    if (cachedValue != null) {
+      return _processAnalysisRequest(
+          request, analysis.callback(request, cachedValue));
+    }
+
+    // TODO (danrubel) determine when completion request is obsolete
+    // and analysis should be terminated before requesting additional analysis
+
+    // Request additional analysis
+    return new AnalysisFutureHelper((context as AnalysisContextImpl),
+        analysis.target, analysis.descriptor).computeAsync().then((value) {
+      return _processAnalysisRequest(
+          request, analysis.callback(request, cachedValue));
+    });
+  }
 }
 
 /**
  * The context in which the completion is requested.
  */
 class DartCompletionRequest extends CompletionRequestImpl {
   /**
    * Cached information from a prior code completion operation.
    */
   final DartCompletionCache cache;
@@ skipping 195 matching lines @@
 
   @override
   CompletionTarget get target => request.target;
 
   @override
   CompilationUnit get unit => request.unit;
 
   @override
   String toString() => 'wrapped $request';
 }