[clangd] Remove FilterText from the index.

[sammccall]

Summary

It's almost always identical to Name, and in fact we never used it (we used name
instead).
The only case where they differ is objc method selectors (foo: vs foo:bar:).
We can live with the former for both name and filterText, so I've made that
change too.

[sammccall]

use foo: instead of foo:bar: for name.

[ioeric]

lgtm

clangd/CodeComplete.cpp

CompletionItem build(StringRef FileName, const CompletionItemScores &Scores,
                        llvm::StringRef SemaDocComment) const {
     assert(bool(SemaResult) == bool(SemaCCS));
     CompletionItem I;
     bool InsertingInclude = false; // Whether a new #include will be added.
     if (SemaResult) {
       I.kind = toCompletionItemKind(SemaResult->Kind, SemaResult->Declaration);
       getLabelAndInsertText(*SemaCCS, &I.label, &I.insertText,
                             Opts.EnableSnippets);
-      I.filterText = getFilterText(*SemaCCS);
+      if (const char* Text = SemaCCS->getTypedText())
+        I.filterText = Text;
       I.documentation = formatDocumentation(*SemaCCS, SemaDocComment);
       I.detail = getDetail(*SemaCCS);
     }
     if (IndexResult) {
       if (I.kind == CompletionItemKind::Missing)
         I.kind = toCompletionItemKind(IndexResult->SymInfo.Kind);
       // FIXME: reintroduce a way to show the index source for debugging.
       if (I.label.empty())

clangd/CodeCompletionStrings.h

 ///        it should be obtained via getDocComment or getParameterDocComment.
 std::string formatDocumentation(const CodeCompletionString &CCS,
                                 llvm::StringRef DocComment);
 
 /// Gets detail to be used as the detail field in an LSP completion item. This
 /// is usually the return type of a function.
 std::string getDetail(const CodeCompletionString &CCS);
 
-/// Gets the piece of text that the user is expected to type to match the
-/// code-completion string, typically a keyword or the name of a declarator or
-/// macro.
-std::string getFilterText(const CodeCompletionString &CCS);
-
 } // namespace clangd
 } // namespace clang
 
 #endif

clangd/CodeCompletionStrings.cpp

case CodeCompletionString::CK_ResultType:
       return Chunk.Text;
     default:
       break;
     }
   }
   return "";
 }
 
-std::string getFilterText(const CodeCompletionString &CCS) {
-  for (const auto &Chunk : CCS) {
-    switch (Chunk.Kind) {
-    case CodeCompletionString::CK_TypedText:
-      // There's always exactly one CK_TypedText chunk.
-      return Chunk.Text;
-    default:
-      break;
-    }
-  }
-  return "";
-}
-
 } // namespace clangd
 } // namespace clang

clangd/index/Index.h

struct Symbol {
   unsigned References = 0;
   /// Whether or not this symbol is meant to be used for the code completion.
   /// See also isIndexedForCodeCompletion().
   bool IsIndexedForCodeCompletion = false;
   /// A brief description of the symbol that can be displayed in the completion
   /// candidate list. For example, "Foo(X x, Y y) const" is a label for a
   /// function.
   llvm::StringRef CompletionLabel;
-  /// The piece of text that the user is expected to type to match the
-  /// code-completion string, typically a keyword or the name of a declarator or
-  /// macro.
-  llvm::StringRef CompletionFilterText;
   /// What to insert when completing this symbol (plain text version).
   llvm::StringRef CompletionPlainInsertText;
   /// What to insert when completing this symbol (snippet version). This is
   /// empty if it is the same as the plain insert text above.
   llvm::StringRef CompletionSnippetInsertText;
 
   /// Optional symbol details that are not required to be set. For example, an
   /// index fuzzy match can return a large number of symbol candidates, and it

clangd/index/Index.cpp

static void own(Symbol &S, DenseSet<StringRef> &Strings,
 
   // We need to copy every StringRef field onto the arena.
   Intern(S.Name);
   Intern(S.Scope);
   Intern(S.CanonicalDeclaration.FileURI);
   Intern(S.Definition.FileURI);
 
   Intern(S.CompletionLabel);
-  Intern(S.CompletionFilterText);
   Intern(S.CompletionPlainInsertText);
   Intern(S.CompletionSnippetInsertText);
 
   if (S.Detail) {
     // Copy values of StringRefs into arena.
     auto *Detail = Arena.Allocate<Symbol::Details>();
     *Detail = *S.Detail;
     // Intern the actual strings.

clangd/index/Merge.cpp

mergeSymbol(const Symbol &L, const Symbol &R, Symbol::Details *Scratch) {
   // (It might be missing in O too, but that's a no-op).
   if (!S.Definition)
     S.Definition = O.Definition;
   if (!S.CanonicalDeclaration)
     S.CanonicalDeclaration = O.CanonicalDeclaration;
   S.References += O.References;
   if (S.CompletionLabel == "")
     S.CompletionLabel = O.CompletionLabel;
-  if (S.CompletionFilterText == "")
-    S.CompletionFilterText = O.CompletionFilterText;
   if (S.CompletionPlainInsertText == "")
     S.CompletionPlainInsertText = O.CompletionPlainInsertText;
   if (S.CompletionSnippetInsertText == "")
     S.CompletionSnippetInsertText = O.CompletionSnippetInsertText;
 
   if (O.Detail) {
     if (S.Detail) {
       // Copy into scratch space so we can merge.

clangd/index/SymbolCollector.cpp

const Symbol *SymbolCollector::addDeclaration(const NamedDecl &ND,
   Policy.SuppressUnwrittenScope = true;
   ND.printQualifiedName(OS, Policy);
   OS.flush();
   assert(!StringRef(QName).startswith("::"));
 
   Symbol S;
   S.ID = std::move(ID);
   std::tie(S.Scope, S.Name) = splitQualifiedName(QName);
+  // FIXME: this returns foo:bar: for objective-C methods, we prefer only foo:
+  // for consistency with CodeCompletionString and a clean name/signature split.
 
   S.IsIndexedForCodeCompletion = isIndexedForCodeCompletion(ND, Ctx);
   S.SymInfo = index::getSymbolInfo(&ND);
   std::string FileURI;
   if (auto DeclLoc =
           getSymbolLocation(ND, SM, Opts, ASTCtx->getLangOpts(), FileURI))
     S.CanonicalDeclaration = *DeclLoc;
 
const Symbol *SymbolCollector::addDeclaration(const NamedDecl &ND,
   std::string Label;
   std::string SnippetInsertText;
   std::string IgnoredLabel;
   std::string PlainInsertText;
   getLabelAndInsertText(*CCS, &Label, &SnippetInsertText,
                         /*EnableSnippets=*/true);
   getLabelAndInsertText(*CCS, &IgnoredLabel, &PlainInsertText,
                         /*EnableSnippets=*/false);
-  std::string FilterText = getFilterText(*CCS);
   std::string Documentation =
       formatDocumentation(*CCS, getDocComment(Ctx, SymbolCompletion,
                                               /*CommentsFromHeaders=*/true));
   std::string CompletionDetail = getDetail(*CCS);
 
   std::string Include;
   if (Opts.CollectIncludePath && shouldCollectIncludePath(S.SymInfo.Kind)) {
     // Use the expansion location to get the #include header since this is
     // where the symbol is exposed.
     if (auto Header = getIncludeHeader(
             QName, SM, SM.getExpansionLoc(ND.getLocation()), Opts))
       Include = std::move(*Header);
   }
-  S.CompletionFilterText = FilterText;
   S.CompletionLabel = Label;
   S.CompletionPlainInsertText = PlainInsertText;
   S.CompletionSnippetInsertText = SnippetInsertText;
   Symbol::Details Detail;
   Detail.Documentation = Documentation;
   Detail.CompletionDetail = CompletionDetail;
   Detail.IncludeHeader = Include;
   S.Detail = &Detail;

clangd/index/SymbolYAML.cpp

static void mapping(IO &IO, Symbol &Sym) {
     IO.mapRequired("SymInfo", Sym.SymInfo);
     IO.mapOptional("CanonicalDeclaration", Sym.CanonicalDeclaration,
                    SymbolLocation());
     IO.mapOptional("Definition", Sym.Definition, SymbolLocation());
     IO.mapOptional("References", Sym.References, 0u);
     IO.mapOptional("IsIndexedForCodeCompletion", Sym.IsIndexedForCodeCompletion,
                    false);
     IO.mapRequired("CompletionLabel", Sym.CompletionLabel);
-    IO.mapRequired("CompletionFilterText", Sym.CompletionFilterText);
     IO.mapRequired("CompletionPlainInsertText", Sym.CompletionPlainInsertText);
 
     IO.mapOptional("CompletionSnippetInsertText",
                    Sym.CompletionSnippetInsertText);
     IO.mapOptional("Detail", NDetail->Opt);
   }
 };
 

unittests/clangd/CodeCompletionStringsTests.cpp

 };
 
 TEST_F(CompletionStringTest, Detail) {
   Builder.AddResultTypeChunk("result");
   Builder.AddResultTypeChunk("redundant result no no");
   EXPECT_EQ(getDetail(*Builder.TakeString()), "result");
 }
 
-TEST_F(CompletionStringTest, FilterText) {
-  Builder.AddTypedTextChunk("typed");
-  Builder.AddTypedTextChunk("redundant typed no no");
-  auto *S = Builder.TakeString();
-  EXPECT_EQ(getFilterText(*S), "typed");
-}
-
 TEST_F(CompletionStringTest, Documentation) {
   Builder.addBriefComment("This is ignored");
   EXPECT_EQ(formatDocumentation(*Builder.TakeString(), "Is this brief?"),
             "Is this brief?");
 }
 
 TEST_F(CompletionStringTest, DocumentationWithAnnotation) {
   Builder.addBriefComment("This is ignored");
TEST_F(CompletionStringTest, FunctionSnippet) {
   labelAndInsertText(*CCS);
   EXPECT_EQ(Label, "Foo(p1, p2)");
   EXPECT_EQ(InsertText, "Foo");
 
   labelAndInsertText(*CCS, /*EnableSnippets=*/true);
   EXPECT_EQ(Label, "Foo(p1, p2)");
   EXPECT_EQ(InsertText, "Foo(${1:p1}, ${2:p2})");
   EXPECT_EQ(formatDocumentation(*CCS, "Foo's comment"), "Foo's comment");
-  EXPECT_EQ(getFilterText(*CCS), "Foo");
 }
 
 TEST_F(CompletionStringTest, EscapeSnippet) {
   Builder.AddTypedTextChunk("Foo");
   Builder.AddChunk(CodeCompletionString::CK_LeftParen);
   Builder.AddPlaceholderChunk("$p}1\\");
   Builder.AddChunk(CodeCompletionString::CK_RightParen);