| // 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.manager; |
| |
| import 'dart:async'; |
| |
| import 'package:analysis_server/plugin/protocol/protocol.dart'; |
| import 'package:analysis_server/src/provisional/completion/completion_core.dart' |
| show CompletionContributor, CompletionContributorFactory, CompletionRequest, CompletionResult; |
| import 'package:analysis_server/src/services/completion/dart_completion_manager.dart'; |
| import 'package:analysis_server/src/services/search/search_engine.dart'; |
| import 'package:analyzer/src/generated/engine.dart'; |
| import 'package:analyzer/src/generated/source.dart'; |
| |
| /** |
| * Manages completion contributors for a given completion request. |
| */ |
| abstract class CompletionManager { |
| /** |
| * The context in which the completion was computed. |
| */ |
| final AnalysisContext context; |
| |
| /** |
| * The source in which the completion was computed. |
| */ |
| final Source source; |
| |
| /** |
| * The controller used for returning completion results. |
| */ |
| StreamController<CompletionResult> controller; |
| |
| CompletionManager(this.context, this.source); |
| |
| /** |
| * Create a manager for the given request. |
| */ |
| factory CompletionManager.create( |
| AnalysisContext context, |
| Source source, |
| SearchEngine searchEngine, |
| Iterable<CompletionContributor> newContributors) { |
| if (context != null) { |
| if (AnalysisEngine.isDartFileName(source.shortName)) { |
| return new DartCompletionManager.create( |
| context, searchEngine, source, newContributors); |
| } |
| } |
| return new NoOpCompletionManager(source); |
| } |
| |
| /** |
| * Compute and cache information in preparation for a possible code |
| * completion request sometime in the future. The default implementation |
| * of this method does nothing. Subclasses may override but should not |
| * count on this method being called before [computeSuggestions]. |
| * Return a future that completes when the cache is computed with a bool |
| * indicating success. |
| */ |
| Future<bool> computeCache() { |
| return new Future.value(true); |
| } |
| |
| /** |
| * Compute completion results for the given reqeust and append them to the stream. |
| * Clients should not call this method directly as it is automatically called |
| * when a client listens to the stream returned by [results]. |
| * Subclasses should override this method, append at least one result |
| * to the [controller], and close the controller stream once complete. |
| */ |
| void computeSuggestions(CompletionRequest request); |
| |
| /** |
| * Discard any pending operations. |
| * Subclasses may override but should call super.dispose |
| */ |
| void dispose() {} |
| |
| /** |
| * Generate a stream of code completion results. |
| */ |
| Stream<CompletionResult> results(CompletionRequest request) { |
| controller = new StreamController<CompletionResult>(onListen: () { |
| scheduleMicrotask(() { |
| computeSuggestions(request); |
| }); |
| }); |
| return controller.stream; |
| } |
| } |
| |
| /** |
| * Overall performance of a code completion operation. |
| */ |
| class CompletionPerformance { |
| final DateTime start = new DateTime.now(); |
| final Map<String, Duration> _startTimes = new Map<String, Duration>(); |
| final Stopwatch _stopwatch = new Stopwatch(); |
| final List<OperationPerformance> operations = <OperationPerformance>[]; |
| |
| Source source; |
| String snippet = ''; |
| int notificationCount = -1; |
| int suggestionCountFirst = -1; |
| int suggestionCountLast = -1; |
| Duration _firstNotification; |
| |
| CompletionPerformance() { |
| _stopwatch.start(); |
| } |
| |
| int get elapsedInMilliseconds => |
| operations.length > 0 ? operations.last.elapsed.inMilliseconds : 0; |
| |
| int get firstNotificationInMilliseconds => |
| _firstNotification != null ? _firstNotification.inMilliseconds : 0; |
| |
| String get startTimeAndMs => '${start.millisecondsSinceEpoch} - $start'; |
| |
| String get suggestionCount { |
| if (notificationCount < 1) return ''; |
| if (notificationCount == 1) return '$suggestionCountFirst'; |
| return '$suggestionCountFirst, $suggestionCountLast'; |
| } |
| |
| void complete([String tag = null]) { |
| _stopwatch.stop(); |
| _logDuration(tag != null ? tag : 'total time', _stopwatch.elapsed); |
| } |
| |
| logElapseTime(String tag, [f() = null]) { |
| Duration start; |
| Duration end = _stopwatch.elapsed; |
| var result; |
| if (f == null) { |
| start = _startTimes[tag]; |
| if (start == null) { |
| _logDuration(tag, null); |
| return null; |
| } |
| } else { |
| result = f(); |
| start = end; |
| end = _stopwatch.elapsed; |
| } |
| _logDuration(tag, end - start); |
| return result; |
| } |
| |
| void logFirstNotificationComplete(String tag) { |
| _firstNotification = _stopwatch.elapsed; |
| _logDuration(tag, _firstNotification); |
| } |
| |
| void logStartTime(String tag) { |
| _startTimes[tag] = _stopwatch.elapsed; |
| } |
| |
| void setContentsAndOffset(String contents, int offset) { |
| snippet = _computeSnippet(contents, offset); |
| } |
| |
| void _logDuration(String tag, Duration elapsed) { |
| operations.add(new OperationPerformance(tag, elapsed)); |
| } |
| |
| static String _computeSnippet(String contents, int offset) { |
| if (contents == null || |
| offset == null || |
| offset < 0 || |
| contents.length < offset) { |
| return '???'; |
| } |
| int start = offset; |
| while (start > 0) { |
| String ch = contents[start - 1]; |
| if (ch == '\r' || ch == '\n') { |
| break; |
| } |
| --start; |
| } |
| int end = offset; |
| while (end < contents.length) { |
| String ch = contents[end]; |
| if (ch == '\r' || ch == '\n') { |
| break; |
| } |
| ++end; |
| } |
| String prefix = contents.substring(start, offset); |
| String suffix = contents.substring(offset, end); |
| return '$prefix^$suffix'; |
| } |
| } |
| |
| /** |
| * Code completion result generated by an [CompletionManager]. |
| */ |
| class CompletionResultImpl implements CompletionResult { |
| /** |
| * The length of the text to be replaced if the remainder of the identifier |
| * containing the cursor is to be replaced when the suggestion is applied |
| * (that is, the number of characters in the existing identifier). |
| */ |
| final int replacementLength; |
| |
| /** |
| * The offset of the start of the text to be replaced. This will be different |
| * than the offset used to request the completion suggestions if there was a |
| * portion of an identifier before the original offset. In particular, the |
| * replacementOffset will be the offset of the beginning of said identifier. |
| */ |
| final int replacementOffset; |
| |
| /** |
| * The suggested completions. |
| */ |
| final List<CompletionSuggestion> suggestions; |
| |
| /** |
| * `true` if this is that last set of results that will be returned |
| * for the indicated completion. |
| */ |
| final bool last; |
| |
| CompletionResultImpl(this.replacementOffset, this.replacementLength, |
| this.suggestions, this.last); |
| |
| /** |
| * Return `true` if this is the last completion result that will be produced. |
| */ |
| bool get isLast => last; |
| } |
| |
| class NoOpCompletionManager extends CompletionManager { |
| NoOpCompletionManager(Source source) : super(null, source); |
| |
| @override |
| void computeSuggestions(CompletionRequest request) { |
| controller.add(new CompletionResultImpl(request.offset, 0, [], true)); |
| } |
| } |
| |
| /** |
| * The performance of an operation when computing code completion. |
| */ |
| class OperationPerformance { |
| /** |
| * The name of the operation |
| */ |
| final String name; |
| |
| /** |
| * The elapse time or `null` if undefined. |
| */ |
| final Duration elapsed; |
| |
| OperationPerformance(this.name, this.elapsed); |
| } |