update code completion suggestion relevance based on common usage

pkg/analysis_server/lib/src/services/completion/common_usage_computer.dart

Index: pkg/analysis_server/lib/src/services/completion/common_usage_computer.dart
diff --git a/pkg/analysis_server/lib/src/services/completion/common_usage_computer.dart b/pkg/analysis_server/lib/src/services/completion/common_usage_computer.dart
new file mode 100644
index 0000000000000000000000000000000000000000..2735aff902ad7711097b092aa625261a0a7a8b14
--- /dev/null
+++ b/pkg/analysis_server/lib/src/services/completion/common_usage_computer.dart
@@ -0,0 +1,141 @@
+// Copyright (c) 2015, 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.computer.dart.relevance;
+
+import 'package:analysis_server/src/protocol_server.dart' as protocol;
+import 'package:analysis_server/src/protocol_server.dart' show
+    CompletionSuggestion, CompletionSuggestionKind;
+import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
+import 'package:analyzer/src/generated/ast.dart';
+import 'package:analyzer/src/generated/element.dart';
+
+/**
+ * Return a map of <library>.<classname> to an ordered list of method names,
+ * field names, getter names, and named constructors.
+ * The names are ordered from most relevant to least relevant.
+ * Names not listed are considered equally less relevant than those listed.
+ */
+Map<String, List<String>> get selectorRelevance => {
+  // Sample implementation which updates the relevance of the following
+  // new Random().nextInt(...)
+  // new Random().nextDouble(...)
+  // new Random().nextBool() - not commonly used thus omitted from list
+  'dart.math.Random': ['nextInt', 'nextDouble'],
+  'dart.async.Future': ['value', 'wait'],

[lukechurch, 2015/02/13 11:23:01]

Lets not land a change that affects something as important as 'Future' until the
actual signal is in. Otherwise it will make doing the analysis to determine the
impact un-necessarily complicated.

If you wanted to add a second partial sorting rule, consider:
dart.core.Set : [firstWhere, takeWhile, skipWhile]

[danrubel, 2015/02/15 04:53:41]

Good point. To better address this I've added a constructor to
CommonUsageComputer with which I can inject a specific map for testing. This
default selector map will not have any entries, and I'll have you fill it in
with the actual values when you have them.

+};
+
+/**
+ * A computer for adjusting the relevance of completions computed by others
+ * based upon common Dart usage patterns.
+ */
+class CommonUsageComputer {
+
+  /**
+   * Adjusts the relevance based on the given completion context.
+   * The compilation unit and completion node
+   * in the given completion context may not be resolved.
+   * This method should execute quickly and not block waiting for any analysis.
+   */
+  void computeFast(DartCompletionRequest request) {
+    _update(request);
+  }
+
+  /**
+   * Adjusts the relevance based on the given completion context.
+   * The compilation unit and completion node
+   * in the given completion context are resolved.
+   */
+  void computeFull(DartCompletionRequest request) {
+    _update(request);
+  }
+
+  /**
+   * Adjusts the relevance based on the given completion context.
+   * The compilation unit and completion node
+   * in the given completion context may not be resolved.
+   */
+  void _update(DartCompletionRequest request) {
+    var visitor = new _BestTypeVisitor(request.target.entity);
+    DartType type = request.target.containingNode.accept(visitor);
+    if (type != null) {
+      Element typeElem = type.element;
+      if (typeElem != null) {
+        LibraryElement libElem =
+            typeElem.getAncestor((p) => p is LibraryElement);
+        if (libElem != null) {
+          _updateMethodRelevance(request, type, libElem);
+        }
+      }
+    }
+  }
+
+  /**
+   * Adjusts the relevance of all method suggestions based upon the given
+   * target type and library.
+   */
+  void _updateMethodRelevance(DartCompletionRequest request, DartType type,
+      LibraryElement libElem) {
+    String typeName = type.name;
+    List<String> selectors = selectorRelevance['${libElem.name}.${typeName}'];
+    if (selectors != null) {
+      for (CompletionSuggestion suggestion in request.suggestions) {
+        protocol.Element element = suggestion.element;
+        if (element != null &&
+            (element.kind == protocol.ElementKind.CONSTRUCTOR ||
+                element.kind == protocol.ElementKind.METHOD) &&
+            suggestion.kind == CompletionSuggestionKind.INVOCATION &&
+            suggestion.declaringType == typeName) {
+          int index = selectors.indexOf(suggestion.completion);
+          if (index != -1) {
+            suggestion.relevance = DART_RELEVANCE_COMMON_USAGE - index;
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * An [AstVisitor] used to determine the best [DartType] of a node.
+ */
+class _BestTypeVisitor extends GeneralizingAstVisitor {

[lukechurch, 2015/02/13 11:23:01]

This seems more generally useful than only for doing completion ordering?

[danrubel, 2015/02/15 04:53:41]

Agreed, but I'm not planning major refactoring until after 1.9.

+  final entity;
+
+  _BestTypeVisitor(this.entity);
+
+  DartType visitConstructorName(ConstructorName node) {
+    if (node.period != null && node.name == entity) {
+      TypeName typeName = node.type;
+      if (typeName != null) {
+        return typeName.type;
+      }
+    }
+    return null;
+  }
+
+  DartType visitNode(AstNode node) {
+    return null;
+  }
+
+  DartType visitPrefixedIdentifier(PrefixedIdentifier node) {
+    if (node.identifier == entity) {
+      SimpleIdentifier prefix = node.prefix;
+      if (prefix != null) {
+        return prefix.bestType;
+      }
+    }
+    return null;
+  }
+
+  DartType visitPropertyAccess(PropertyAccess node) {
+    if (node.propertyName == entity) {
+      Expression target = node.realTarget;
+      if (target != null) {
+        return target.bestType;
+      }
+    }
+    return null;
+  }
+}