[CodeCompletion] Switch filter-rules and popular api to follow SE-0021 naming

We want inputs for function names to follow SE-0021 with the exception
that a function with no arguments is spelled `foo()` instead of `foo`,
because we have no type to disambiguate with and it's not ambiguous with
a call in this context.

Internally, we use a filter name without underscores because we don't
want to introduce spurious matches to the `_` character which might be
part of identifiers.

For now, continue to accept the old names to ease the transition.

rdar://problem/24350800

Author: benlangmuir

test/SourceKit/CodeComplete/Inputs/filter-rules/hideNames.json

@@ -4,8 +4,8 @@
     key.hide: 1,
     key.names: [
       "hideThis1()",
-      "hideThis2(:namedParam2:)",
-      "hideThis3()",
+      "hideThis2(_:namedParam2:)",
+      "hideThis3(namedParam1:_:)",
     ]
   },
   {

test/SourceKit/CodeComplete/complete_filter_rules.swift

@@ -6,7 +6,7 @@ import Foo
 struct TestHideName {
   func hideThis1() {}
   func hideThis2(_ x: Int, namedParam2: Int) {}
-  func hideThis3() {}
+  func hideThis3(namedParam1: Int, _ unnamedParam: Int) {}
   func hideThis4(namedParam1 x: Int, namedParam2: Int) {}
   func dontHideThisByName() {}
 

test/SourceKit/CodeComplete/complete_popular_api.swift.popular

@@ -1,4 +1,4 @@
-good(:p2:p3:p4:p5:)
+good(_:p2:p3:p4:p5:)
 good()
 xhappy
 EEModuleColor

tools/SourceKit/include/SourceKit/Core/LangSupport.h

@@ -157,7 +157,7 @@ struct FilterRule {
   };
   Kind kind;
   bool hide;
-  std::vector<StringRef> names;
+  std::vector<StringRef> names; ///< Must be null-terminated.
   std::vector<UIdent> uids;
 };
 

tools/SourceKit/lib/SwiftLang/SwiftCompletion.cpp

@@ -16,6 +16,7 @@
 #include "SourceKit/Support/Logging.h"
 #include "SourceKit/Support/UIdent.h"
 
+#include "swift/Basic/Fallthrough.h"
 #include "swift/Frontend/Frontend.h"
 #include "swift/Frontend/PrintingDiagnosticConsumer.h"
 #include "swift/IDE/CodeCompletionCache.h"
@@ -819,6 +820,40 @@ static void translateCodeCompletionOptions(OptionsDictionary &from,
   from.valueForOption(KeyTopNonLiteral, to.showTopNonLiteralResults);
 }
 
+/// Canonicalize a name that is in the format of a reference to a function into
+/// the name format used internally for filtering.
+///
+/// Returns true if the name is invalid.
+static bool canonicalizeFilterName(const char *origName,
+                                   SmallVectorImpl<char> &Result) {
+  assert(origName);
+  const char *p = origName;
+  char curr = '\0';
+  char prev;
+
+  // FIXME: disallow unnamed parameters without underscores `foo(::)`.
+  while (true) {
+    prev = curr;
+    curr = *p++;
+    switch (curr) {
+    case '\0':
+      return false; // Done.
+    case '_':
+      // Remove the _ underscore for an unnamed parameter.
+      if (prev == ':' || prev == '(') {
+        char next = *p;
+        if (next == ':' || next == ')')
+          continue;
+      }
+      SWIFT_FALLTHROUGH;
+    default:
+      Result.push_back(curr);
+      continue;
+    }
+  }
+  llvm_unreachable("exit is on null byte");
+}
+
 static void translateFilterRules(ArrayRef<FilterRule> rawFilterRules,
                                  CodeCompletion::FilterRules &filterRules) {
   for (auto &rule : rawFilterRules) {
@@ -828,7 +863,11 @@ static void translateFilterRules(ArrayRef<FilterRule> rawFilterRules,
       break;
     case FilterRule::Identifier:
       for (auto name : rule.names) {
-        filterRules.hideByName[name] = rule.hide;
+        SmallString<128> canonName;
+        // Note: name is null-terminated.
+        if (canonicalizeFilterName(name.data(), canonName))
+          continue;
+        filterRules.hideByName[canonName] = rule.hide;
       }
       break;
     case FilterRule::Module:
@@ -1201,10 +1240,16 @@ void SwiftLangSupport::codeCompleteSetPopularAPI(
   ThreadSafeRefCntPtr<SwiftPopularAPI> newPopularAPI(new SwiftPopularAPI);
   auto &nameToFactor = newPopularAPI->nameToFactor;
   for (unsigned i = 0, n = popularAPI.size(); i < n; ++i) {
-    nameToFactor[popularAPI[i]] = Factor(double(n - i) / n);
+    SmallString<64> name;
+    if (canonicalizeFilterName(popularAPI[i], name))
+      continue;
+    nameToFactor[name] = Factor(double(n - i) / n);
   }
   for (unsigned i = 0, n = unpopularAPI.size(); i < n; ++i) {
-    nameToFactor[unpopularAPI[i]] = Factor(-double(n - i) / n);
+    SmallString<64> name;
+    if (canonicalizeFilterName(unpopularAPI[i], name))
+      continue;
+    nameToFactor[name] = Factor(-double(n - i) / n);
   }
 
   PopularAPI = newPopularAPI; // replace the old popular API.