[CodeCompletion] Add optional top-N results that precede literals

benlangmuir · benlangmuir · commit 5da090608996 · 2016-02-03T16:31:26.000-08:00
Experiment with having some locals or nominal members come first, but
only a few so that the literals are still predictably near the top.

Part of rdar://problem/23865118
diff --git a/test/SourceKit/CodeComplete/complete_sort_order.swift b/test/SourceKit/CodeComplete/complete_sort_order.swift
@@ -44,7 +44,6 @@ func test() {
 // CONTEXT: key.name: "__COLUMN__"
 
 // RUN: %complete-test -tok=STMT_0 %s | FileCheck %s -check-prefix=STMT
-// RUN: %complete-test -tok=EXPR_0 %s | FileCheck %s -check-prefix=EXPR
 func test1() {
   #^STMT_0^#
 }
@@ -56,6 +55,7 @@ func test1() {
 // STMT: func
 // STMT: foo(a: Int)
 
+// RUN: %complete-test -top=0 -tok=EXPR_0 %s | FileCheck %s -check-prefix=EXPR
 func test2() {
   (#^EXPR_0^#)
 }
@@ -70,3 +70,63 @@ func test2() {
 // EXPR: (values)
 // EXPR: nil
 // EXPR: foo(a: Int)
+
+// Top 1
+// RUN: %complete-test -top=1 -tok=EXPR_1 %s | FileCheck %s -check-prefix=EXPR_TOP_1
+func test3(x: Int) {
+  let y = x
+  let z = x
+  let zzz = x
+  (#^EXPR_1^#)
+}
+// EXPR_TOP_1: x
+// EXPR_TOP_1: 0
+// EXPR_TOP_1: "abc"
+// EXPR_TOP_1: true
+// EXPR_TOP_1: false
+// EXPR_TOP_1: [#Color(colorLiteralRed: Float, green: Float, blue: Float, alpha: Float)#]
+// EXPR_TOP_1: [#Image(imageLiteral: String)#]
+// EXPR_TOP_1: [values]
+// EXPR_TOP_1: [key: value]
+// EXPR_TOP_1: (values)
+// EXPR_TOP_1: nil
+// EXPR_TOP_1: y
+// EXPR_TOP_1: z
+// EXPR_TOP_1: zzz
+
+// Top 3
+// RUN: %complete-test -top=3 -tok=EXPR_2 %s | FileCheck %s -check-prefix=EXPR_TOP_3
+func test4(x: Int) {
+  let y = x
+  let z = x
+  let zzz = x
+  (#^EXPR_2^#)
+}
+// EXPR_TOP_3: x
+// EXPR_TOP_3: y
+// EXPR_TOP_3: z
+// EXPR_TOP_3: 0
+// EXPR_TOP_3: "abc"
+// EXPR_TOP_3: true
+// EXPR_TOP_3: false
+// EXPR_TOP_3: [#Color(colorLiteralRed: Float, green: Float, blue: Float, alpha: Float)#]
+// EXPR_TOP_3: [#Image(imageLiteral: String)#]
+// EXPR_TOP_3: [values]
+// EXPR_TOP_3: [key: value]
+// EXPR_TOP_3: (values)
+// EXPR_TOP_3: nil
+// EXPR_TOP_3: zzz
+
+// Top 3 with type matching
+// RUN: %complete-test -top=3 -tok=EXPR_3 %s | FileCheck %s -check-prefix=EXPR_TOP_3_TYPE_MATCH
+func test4(x: Int) {
+  let y: String = ""
+  let z: String = y
+  let zzz = x
+  let bar: Int = #^EXPR_3^#
+}
+// EXPR_TOP_3_TYPE_MATCH: x
+// EXPR_TOP_3_TYPE_MATCH: zzz
+// EXPR_TOP_3_TYPE_MATCH: 0
+// EXPR_TOP_3_TYPE_MATCH: y
+// EXPR_TOP_3_TYPE_MATCH: z
diff --git a/test/SourceKit/CodeComplete/complete_type_match.swift b/test/SourceKit/CodeComplete/complete_type_match.swift
@@ -1,9 +1,9 @@
-// RUN: %complete-test -tok=TOP_LEVEL_0 %s | FileCheck %s -check-prefix=TOP_LEVEL_0
-// RUN: %complete-test -tok=TOP_LEVEL_1 %s | FileCheck %s -check-prefix=TOP_LEVEL_1
-// RUN: %complete-test -tok=TOP_LEVEL_2 %s | FileCheck %s -check-prefix=TOP_LEVEL_2
-// RUN: %complete-test -tok=TOP_LEVEL_3 %s | FileCheck %s -check-prefix=TOP_LEVEL_3
-// RUN: %complete-test -group=none -tok=CROSS_CONTEXT_0 %s | FileCheck %s -check-prefix=CROSS_CONTEXT_0
-// RUN: %complete-test -group=none -tok=FROM_METHOD_0 %s | FileCheck %s -check-prefix=FROM_METHOD_0
+// RUN: %complete-test -top=0 -tok=TOP_LEVEL_0 %s | FileCheck %s -check-prefix=TOP_LEVEL_0
+// RUN: %complete-test -top=0 -tok=TOP_LEVEL_1 %s | FileCheck %s -check-prefix=TOP_LEVEL_1
+// RUN: %complete-test -top=0 -tok=TOP_LEVEL_2 %s | FileCheck %s -check-prefix=TOP_LEVEL_2
+// RUN: %complete-test -top=0 -tok=TOP_LEVEL_3 %s | FileCheck %s -check-prefix=TOP_LEVEL_3
+// RUN: %complete-test -top=0 -group=none -tok=CROSS_CONTEXT_0 %s | FileCheck %s -check-prefix=CROSS_CONTEXT_0
+// RUN: %complete-test -top=0 -group=none -tok=FROM_METHOD_0 %s | FileCheck %s -check-prefix=FROM_METHOD_0
 
 let valueA = [0]
 let valueS = ""
diff --git a/tools/SourceKit/lib/SwiftLang/CodeCompletionOrganizer.cpp b/tools/SourceKit/lib/SwiftLang/CodeCompletionOrganizer.cpp
@@ -742,6 +742,78 @@ static int compareLiterals(Item &a_, Item &b_) {
   return 0;
 }
 
+static bool isTopNonLiteralResult(Item &item, ResultBucket literalBucket) {
+  if (isa<Group>(item))
+    return true; // FIXME: should have a semantic context for groups.
+  auto *completion = cast<Result>(item).value;
+
+  switch (literalBucket) {
+  case ResultBucket::Literal:
+    return completion->getSemanticContext() <=
+           SemanticContextKind::CurrentNominal;
+  case ResultBucket::LiteralTypeMatch:
+    return completion->getExpectedTypeRelation() >= Completion::Convertible;
+  default:
+    llvm_unreachable("invalid literal bucket");
+  }
+}
+
+static void sortTopN(const Options &options, Group *group,
+                     bool hasExpectedTypes) {
+
+  auto &contents = group->contents;
+  if (contents.empty() || options.showTopNonLiteralResults == 0)
+    return;
+
+  auto best = getResultBucket(*contents[0], hasExpectedTypes);
+  if (best == ResultBucket::LiteralTypeMatch || best == ResultBucket::Literal) {
+
+    unsigned beginNewIndex = 0;
+    unsigned endNewIndex = 0;
+    for (unsigned i = 1; i < contents.size(); ++i) {
+      auto bucket = getResultBucket(*contents[i], hasExpectedTypes);
+      if (bucket < best) {
+        // This algorithm assumes we don't have both literal and
+        // literal-type-match at the start of the list.
+        assert(bucket != ResultBucket::Literal);
+        if (isTopNonLiteralResult(*contents[i], best)) {
+          beginNewIndex = i;
+          endNewIndex = beginNewIndex + 1;
+          for (; endNewIndex < contents.size() &&
+                 endNewIndex < beginNewIndex + options.showTopNonLiteralResults;
+               ++endNewIndex) {
+            if (!isTopNonLiteralResult(*contents[endNewIndex], best))
+              break;
+          }
+        }
+        break;
+      }
+    }
+
+    if (!beginNewIndex)
+      return;
+
+    assert(endNewIndex > beginNewIndex && endNewIndex < contents.size());
+
+    // Temporarily copy the first result to temporary storage.
+    SmallVector<Item *, 16> firstResults;
+    for (unsigned i = 0; i < endNewIndex; ++i) {
+      firstResults.push_back(contents[i].release());
+    }
+
+    // Swap the literals with the next few results.
+    for (unsigned ci = 0, i = beginNewIndex; i < endNewIndex; ++i, ++ci) {
+      assert(ci < contents.size() && !contents[ci]);
+      contents[ci] = std::unique_ptr<Item>(firstResults[i]);
+    }
+    unsigned topN = endNewIndex - beginNewIndex;
+    for (unsigned ci = topN, i = 0; i < beginNewIndex; ++i, ++ci) {
+      assert(ci < contents.size() && !contents[ci]);
+      contents[ci] = std::unique_ptr<Item>(firstResults[i]);
+    }
+  }
+}
+
 static void sortRecursive(const Options &options, Group *group,
                           bool hasExpectedTypes) {
   // Sort all of the subgroups first, and fill in the bucket for each result.
@@ -805,6 +877,8 @@ static void sortRecursive(const Options &options, Group *group,
 
 void CodeCompletionOrganizer::Impl::sort(Options options) {
   sortRecursive(options, rootGroup.get(), completionHasExpectedTypes);
+  if (options.showTopNonLiteralResults != 0)
+    sortTopN(options, rootGroup.get(), completionHasExpectedTypes);
 }
 
 void CodeCompletionOrganizer::Impl::groupStemsRecursive(
diff --git a/tools/SourceKit/lib/SwiftLang/CodeCompletionOrganizer.h b/tools/SourceKit/lib/SwiftLang/CodeCompletionOrganizer.h
@@ -39,6 +39,7 @@ struct Options {
   bool hideByNameStyle = true;
   bool fuzzyMatching = true;
   unsigned minFuzzyLength = 2;
+  unsigned showTopNonLiteralResults = 3;
 
   // Options for combining priorities. The defaults are chosen so that a fuzzy
   // match just breaks ties within a semantic context.  If semanticContextWeight
diff --git a/tools/SourceKit/lib/SwiftLang/SwiftCompletion.cpp b/tools/SourceKit/lib/SwiftLang/SwiftCompletion.cpp
@@ -783,6 +783,7 @@ static void translateCodeCompletionOptions(OptionsDictionary &from,
   static UIdent KeyAddInnerOperators("key.codecomplete.addinneroperators");
   static UIdent KeyAddInitsToTopLevel("key.codecomplete.addinitstotoplevel");
   static UIdent KeyFuzzyMatching("key.codecomplete.fuzzymatching");
+  static UIdent KeyTopNonLiteral("key.codecomplete.showtopnonliteralresults");
   static UIdent KeyContextWeight("key.codecomplete.sort.contextweight");
   static UIdent KeyFuzzyWeight("key.codecomplete.sort.fuzzyweight");
   static UIdent KeyPopularityBonus("key.codecomplete.sort.popularitybonus");
@@ -806,6 +807,7 @@ static void translateCodeCompletionOptions(OptionsDictionary &from,
   from.valueForOption(KeyFuzzyWeight, to.fuzzyMatchWeight);
   from.valueForOption(KeyPopularityBonus, to.popularityBonus);
   from.valueForOption(KeyHideByName, to.hideByNameStyle);
+  from.valueForOption(KeyTopNonLiteral, to.showTopNonLiteralResults);
 }
 
 static void translateFilterRules(ArrayRef<FilterRule> rawFilterRules,
diff --git a/tools/SourceKit/tools/complete-test/complete-test.cpp b/tools/SourceKit/tools/complete-test/complete-test.cpp
@@ -47,6 +47,7 @@ struct TestOptions {
   Optional<unsigned> hideUnderscores;
   Optional<bool> hideByName;
   Optional<bool> hideLowPriority;
+  Optional<unsigned> showTopNonLiteral;
   Optional<bool> fuzzyMatching;
   Optional<unsigned> fuzzyWeight;
   Optional<unsigned> popularityBonus;
@@ -91,6 +92,7 @@ static sourcekitd_uid_t KeyAddInitsToTopLevel;
 static sourcekitd_uid_t KeyFuzzyMatching;
 static sourcekitd_uid_t KeyFuzzyWeight;
 static sourcekitd_uid_t KeyPopularityBonus;
+static sourcekitd_uid_t KeyTopNonLiteral;
 static sourcekitd_uid_t KeyKind;
 static sourcekitd_uid_t KeyResults;
 static sourcekitd_uid_t KeyPopular;
@@ -224,6 +226,13 @@ static bool parseOptions(ArrayRef<const char *> args, TestOptions &options,
       options.unpopularAPI = value;
     } else if (opt == "filter-rules") {
       options.filterRulesJSON = value;
+    } else if (opt == "top") {
+      unsigned uval;
+      if (value.getAsInteger(10, uval)) {
+        error = "unrecognized integer value for -tope=";
+        return false;
+      }
+      options.showTopNonLiteral = uval;
     }
   }
 
@@ -302,6 +311,8 @@ static int skt_main(int argc, const char **argv) {
       sourcekitd_uid_get_from_cstr("key.codecomplete.sort.fuzzyweight");
   KeyPopularityBonus =
       sourcekitd_uid_get_from_cstr("key.codecomplete.sort.popularitybonus");
+  KeyTopNonLiteral =
+      sourcekitd_uid_get_from_cstr("key.codecomplete.showtopnonliteralresults");
   KeySourceFile = sourcekitd_uid_get_from_cstr("key.sourcefile");
   KeySourceText = sourcekitd_uid_get_from_cstr("key.sourcetext");
   KeyName = sourcekitd_uid_get_from_cstr("key.name");
@@ -609,6 +620,7 @@ static bool codeCompleteRequest(sourcekitd_uid_t requestUID, const char *name,
     addIntOption(KeyHideUnderscores, options.hideUnderscores);
     addIntOption(KeyFuzzyWeight, options.fuzzyWeight);
     addIntOption(KeyPopularityBonus, options.popularityBonus);
+    addIntOption(KeyTopNonLiteral, options.showTopNonLiteral);
 
     if (filterText)
       sourcekitd_request_dictionary_set_string(opts, KeyFilterText, filterText);
