[clangd] Flatten out Symbol::Details. It was ill-conceived, sorry.

[hokein]

LGTM, note that this change will break our next internal integration.

[ioeric]

lg

clangd/CodeComplete.cpp

size_t overloadSet() const {
     {
       llvm::raw_svector_ostream OS(Scratch);
       D->printQualifiedName(OS);
     }
     return hash_combine(Scratch, headerToInsertIfNotPresent().getValueOr(""));
   }
 
   llvm::Optional<llvm::StringRef> headerToInsertIfNotPresent() const {
-    if (!IndexResult || !IndexResult->Detail ||
-        IndexResult->Detail->IncludeHeader.empty())
+    if (!IndexResult || IndexResult->IncludeHeader.empty())
       return llvm::None;
     if (SemaResult && SemaResult->Declaration) {
       // Avoid inserting new #include if the declaration is found in the current
       // file e.g. the symbol is forward declared.
       auto &SM = SemaResult->Declaration->getASTContext().getSourceManager();
       for (const Decl *RD : SemaResult->Declaration->redecls())
         if (SM.isInMainFile(SM.getExpansionLoc(RD->getBeginLoc())))
           return llvm::None;
     }
-    return IndexResult->Detail->IncludeHeader;
+    return IndexResult->IncludeHeader;
   }
 
   using Bundle = llvm::SmallVector<CompletionCandidate, 4>;
 };
 using ScoredBundle =
     std::pair<CompletionCandidate::Bundle, CodeCompletion::Scores>;
 struct ScoredBundleGreater {
   bool operator()(const ScoredBundle &L, const ScoredBundle &R) {
if (auto Inserted = C.headerToInsertIfNotPresent()) {
       if (Include) {
         Completion.Header = Include->first;
         if (Include->second)
           Completion.HeaderInsertion = Includes.insert(Include->first);
       } else
         log("Failed to generate include insertion edits for adding header "
             "(FileURI='{0}', IncludeHeader='{1}') into {2}",
             C.IndexResult->CanonicalDeclaration.FileURI,
-            C.IndexResult->Detail->IncludeHeader, FileName);
+            C.IndexResult->IncludeHeader, FileName);
     }
   }
 
   void add(const CompletionCandidate &C, CodeCompletionString *SemaCCS) {
     assert(bool(C.SemaResult) == bool(SemaCCS));
     Bundled.emplace_back();
     BundledEntry &S = Bundled.back();
     if (C.SemaResult) {
       getSignature(*SemaCCS, &S.Signature, &S.SnippetSuffix,
                    &Completion.RequiredQualifier);
       S.ReturnType = getReturnType(*SemaCCS);
     } else if (C.IndexResult) {
       S.Signature = C.IndexResult->Signature;
       S.SnippetSuffix = C.IndexResult->CompletionSnippetSuffix;
-      if (auto *D = C.IndexResult->Detail)
-        S.ReturnType = D->ReturnType;
+      S.ReturnType = C.IndexResult->ReturnType;
     }
     if (ExtractDocumentation && Completion.Documentation.empty()) {
-      if (C.IndexResult && C.IndexResult->Detail)
-        Completion.Documentation = C.IndexResult->Detail->Documentation;
+      if (C.IndexResult)
+        Completion.Documentation = C.IndexResult->Documentation;
       else if (C.SemaResult)
         Completion.Documentation = getDocComment(ASTCtx, *C.SemaResult,
                                                  /*CommentsFromHeader=*/false);
     }
     if (C.IsOverride)
       S.OverrideSuffix = true;
   }
 
void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
     if (Index) {
       LookupRequest IndexRequest;
       for (const auto &S : ScoredSignatures) {
         if (!S.IDForDoc)
           continue;
         IndexRequest.IDs.insert(*S.IDForDoc);
       }
       Index->lookup(IndexRequest, [&](const Symbol &S) {
-        if (!S.Detail || S.Detail->Documentation.empty())
-          return;
-        FetchedDocs[S.ID] = S.Detail->Documentation;
+        if (!S.Documentation.empty())
+          FetchedDocs[S.ID] = S.Documentation;
       });
       log("SigHelp: requested docs for {0} symbols from the index, got {1} "
           "symbols with non-empty docs in the response",
           IndexRequest.IDs.size(), FetchedDocs.size());
     }
 
     std::sort(
         ScoredSignatures.begin(), ScoredSignatures.end(),

clangd/global-symbol-builder/GlobalSymbolBuilderMain.cpp

public:
   void consumeSymbols(SymbolSlab Symbols) override {
     for (const auto &Sym : Symbols)
       Executor.getExecutionContext()->reportResult(Sym.ID.str(),
                                                    SymbolToYAML(Sym));
   }
 
   SymbolSlab mergeResults() override {
     SymbolSlab::Builder UniqueSymbols;
-    llvm::BumpPtrAllocator Arena;
-    Symbol::Details Scratch;
     Executor.getToolResults()->forEachResult(
         [&](llvm::StringRef Key, llvm::StringRef Value) {
-          Arena.Reset();
-          llvm::yaml::Input Yin(Value, &Arena);
-          auto Sym = clang::clangd::SymbolFromYAML(Yin, Arena);
+          llvm::yaml::Input Yin(Value);
+          auto Sym = clang::clangd::SymbolFromYAML(Yin);
           clang::clangd::SymbolID ID;
           Key >> ID;
           if (const auto *Existing = UniqueSymbols.find(ID))
-            UniqueSymbols.insert(mergeSymbol(*Existing, Sym, &Scratch));
+            UniqueSymbols.insert(mergeSymbol(*Existing, Sym));
           else
             UniqueSymbols.insert(Sym);
         });
     return std::move(UniqueSymbols).build();
   }
 
 private:
   ToolExecutor &Executor;
 };
 
 /// Merges symbols for each translation unit as soon as the file is processed.
 /// Optimal choice for standalone tools.
 class OnTheFlyConsumer : public SymbolsConsumer {
 public:
   void consumeSymbols(SymbolSlab Symbols) override {
     std::lock_guard<std::mutex> Lock(Mut);
     for (auto &&Sym : Symbols) {
-      Symbol::Details Scratch;
       if (const auto *Existing = Result.find(Sym.ID))
-        Result.insert(mergeSymbol(*Existing, Sym, &Scratch));
+        Result.insert(mergeSymbol(*Existing, Sym));
       else
         Result.insert(Sym);
     }
   }
 
   SymbolSlab mergeResults() override {
     std::lock_guard<std::mutex> Lock(Mut);
     return std::move(Result).build();

clangd/index/Index.h

struct Symbol {
   SymbolOrigin Origin = SymbolOrigin::Unknown;
   /// A brief description of the symbol that can be appended in the completion
   /// candidate list. For example, "(X x, Y y) const" is a function signature.
   llvm::StringRef Signature;
   /// What to insert when completing this symbol, after the symbol name.
   /// This is in LSP snippet syntax (e.g. "({$0})" for a no-args function).
   /// (When snippets are disabled, the symbol name alone is used).
   llvm::StringRef CompletionSnippetSuffix;
-
-  /// 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
-  /// is preferable to send only core symbol information in the batched results
-  /// and have clients resolve full symbol information for a specific candidate
-  /// if needed.
-  struct Details {
-    /// Documentation including comment for the symbol declaration.
-    llvm::StringRef Documentation;
-    /// Type when this symbol is used in an expression. (Short display form).
-    /// e.g. return type of a function, or type of a variable.
-    llvm::StringRef ReturnType;
-    /// This can be either a URI of the header to be #include'd for this symbol,
-    /// or a literal header quoted with <> or "" that is suitable to be included
-    /// directly. When this is a URI, the exact #include path needs to be
-    /// calculated according to the URI scheme.
-    ///
-    /// This is a canonical include for the symbol and can be different from
-    /// FileURI in the CanonicalDeclaration.
-    llvm::StringRef IncludeHeader;
-  };
-
-  // Optional details of the symbol.
-  const Details *Detail = nullptr;
 
   // FIXME: add all occurrences support.
   // FIXME: add extra fields for index scoring signals.
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Symbol &S);
 
 // Computes query-independent quality score for a Symbol.
 // This currently falls in the range [1, ln(#indexed documents)].

clangd/index/Index.cpp

static void own(Symbol &S, llvm::UniqueStringSaver &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.Signature);
   Intern(S.CompletionSnippetSuffix);
-
-  if (S.Detail) {
-    // Copy values of StringRefs into arena.
-    auto *Detail = Arena.Allocate<Symbol::Details>();
-    *Detail = *S.Detail;
-    // Intern the actual strings.
-    Intern(Detail->Documentation);
-    Intern(Detail->ReturnType);
-    Intern(Detail->IncludeHeader);
-    // Replace the detail pointer with our copy.
-    S.Detail = Detail;
-  }
+  Intern(S.Documentation);
+  Intern(S.ReturnType);
+  Intern(S.IncludeHeader);
 }
 
 void SymbolSlab::Builder::insert(const Symbol &S) {
   auto R = SymbolIndex.try_emplace(S.ID, Symbols.size());
   if (R.second) {
     Symbols.push_back(S);
     own(Symbols.back(), UniqueStrings, Arena);
   } else {

clangd/index/Merge.h

 #include "Index.h"
 
 namespace clang {
 namespace clangd {
 
 // Merge symbols L and R, preferring data from L in case of conflict.
 // The two symbols must have the same ID.
 // Returned symbol may contain data owned by either source.
-Symbol mergeSymbol(const Symbol &L, const Symbol &R, Symbol::Details *Scratch);
+Symbol mergeSymbol(const Symbol &L, const Symbol &R);
 
 // mergedIndex returns a composite index based on two provided Indexes:
 //  - the Dynamic index covers few files, but is relatively up-to-date.
 //  - the Static index covers a bigger set of files, but is relatively stale.
 // The returned index attempts to combine results, and avoid duplicates.
 std::unique_ptr<SymbolIndex> mergeIndex(const SymbolIndex *Dynamic,
                                         const SymbolIndex *Static);
 
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_MERGE_H

clangd/index/Merge.cpp

bool fuzzyFind(const FuzzyFindRequest &Req,
      //    b) if it's in the dynamic slab, merge it and yield the result
      //  3) now yield all the dynamic symbols we haven't processed.
      bool More = false; // We'll be incomplete if either source was.
      SymbolSlab::Builder DynB;
      More |= Dynamic->fuzzyFind(Req, [&](const Symbol &S) { DynB.insert(S); });
      SymbolSlab Dyn = std::move(DynB).build();
 
      DenseSet<SymbolID> SeenDynamicSymbols;
-     Symbol::Details Scratch;
      More |= Static->fuzzyFind(Req, [&](const Symbol &S) {
        auto DynS = Dyn.find(S.ID);
        if (DynS == Dyn.end())
          return Callback(S);
        SeenDynamicSymbols.insert(S.ID);
-       Callback(mergeSymbol(*DynS, S, &Scratch));
+       Callback(mergeSymbol(*DynS, S));
      });
      for (const Symbol &S : Dyn)
        if (!SeenDynamicSymbols.count(S.ID))
          Callback(S);
      return More;
   }
 
   void
   lookup(const LookupRequest &Req,
          llvm::function_ref<void(const Symbol &)> Callback) const override {
     SymbolSlab::Builder B;
 
     Dynamic->lookup(Req, [&](const Symbol &S) { B.insert(S); });
 
     auto RemainingIDs = Req.IDs;
-    Symbol::Details Scratch;
     Static->lookup(Req, [&](const Symbol &S) {
       const Symbol *Sym = B.find(S.ID);
       RemainingIDs.erase(S.ID);
       if (!Sym)
         Callback(S);
       else
-        Callback(mergeSymbol(*Sym, S, &Scratch));
+        Callback(mergeSymbol(*Sym, S));
     });
     for (const auto &ID : RemainingIDs)
       if (const Symbol *Sym = B.find(ID))
         Callback(*Sym);
   }
 
   void findOccurrences(const OccurrencesRequest &Req,
                        llvm::function_ref<void(const SymbolOccurrence &)>
                            Callback) const override {
     log("findOccurrences is not implemented.");
   }
 
   size_t estimateMemoryUsage() const override {
     return Dynamic->estimateMemoryUsage() + Static->estimateMemoryUsage();
   }
 
 private:
   const SymbolIndex *Dynamic, *Static;
 };
 } // namespace
 
-Symbol
-mergeSymbol(const Symbol &L, const Symbol &R, Symbol::Details *Scratch) {
+Symbol mergeSymbol(const Symbol &L, const Symbol &R) {
   assert(L.ID == R.ID);
   // We prefer information from TUs that saw the definition.
   // Classes: this is the def itself. Functions: hopefully the header decl.
   // If both did (or both didn't), continue to prefer L over R.
   bool PreferR = R.Definition && !L.Definition;
   Symbol S = PreferR ? R : L;        // The target symbol we're merging into.
   const Symbol &O = PreferR ? L : R; // The "other" less-preferred symbol.
 
   // For each optional field, fill it from O if missing in S.
   // (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.Signature == "")
     S.Signature = O.Signature;
   if (S.CompletionSnippetSuffix == "")
     S.CompletionSnippetSuffix = O.CompletionSnippetSuffix;
-
-  if (O.Detail) {
-    if (S.Detail) {
-      // Copy into scratch space so we can merge.
-      *Scratch = *S.Detail;
-      if (Scratch->Documentation == "")
-        Scratch->Documentation = O.Detail->Documentation;
-      if (Scratch->ReturnType == "")
-        Scratch->ReturnType = O.Detail->ReturnType;
-      if (Scratch->IncludeHeader == "")
-        Scratch->IncludeHeader = O.Detail->IncludeHeader;
-      S.Detail = Scratch;
-    } else
-      S.Detail = O.Detail;
-  }
+  if (S.Documentation == "")
+    S.Documentation = O.Documentation;
+  if (S.ReturnType == "")
+    S.ReturnType = O.ReturnType;
+  if (S.IncludeHeader == "")
+    S.IncludeHeader = O.IncludeHeader;
 
   S.Origin |= O.Origin | SymbolOrigin::Merge;
   return S;
 }
 
 std::unique_ptr<SymbolIndex> mergeIndex(const SymbolIndex *Dynamic,
                                         const SymbolIndex *Static) {
   return llvm::make_unique<MergedIndex>(Dynamic, Static);
 }
 
 } // namespace clangd
 } // namespace clang

clangd/index/SymbolCollector.cpp

bool SymbolCollector::handleMacroOccurence(const IdentifierInfo *Name,
   if (Opts.CollectIncludePath && shouldCollectIncludePath(S.SymInfo.Kind)) {
     if (auto Header =
             getIncludeHeader(Name->getName(), SM,
                              SM.getExpansionLoc(MI->getDefinitionLoc()), Opts))
       Include = std::move(*Header);
   }
   S.Signature = Signature;
   S.CompletionSnippetSuffix = SnippetSuffix;
-  Symbol::Details Detail;
-  Detail.IncludeHeader = Include;
-  S.Detail = &Detail;
+  S.IncludeHeader = Include;
   Symbols.insert(S);
   return true;
 }
 
 void SymbolCollector::finish() {
   // At the end of the TU, add 1 to the refcount of all referenced symbols.
   auto IncRef = [this](const SymbolID &ID) {
     if (const auto *S = Symbols.find(ID)) {
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.Signature = Signature;
   S.CompletionSnippetSuffix = SnippetSuffix;
-  Symbol::Details Detail;
-  Detail.Documentation = Documentation;
-  Detail.ReturnType = ReturnType;
-  Detail.IncludeHeader = Include;
-  S.Detail = &Detail;
+  S.Documentation = Documentation;
+  S.ReturnType = ReturnType;
+  S.IncludeHeader = Include;
 
   S.Origin = Opts.Origin;
   Symbols.insert(S);
   return Symbols.find(S.ID);
 }
 
 void SymbolCollector::addDefinition(const NamedDecl &ND,
                                     const Symbol &DeclSym) {

clangd/index/SymbolYAML.h

 
 namespace clang {
 namespace clangd {
 
 // Read symbols from a YAML-format string.
 SymbolSlab symbolsFromYAML(llvm::StringRef YAMLContent);
 
 // Read one symbol from a YAML-stream.
-// The arena must be the Input's context! (i.e. yaml::Input Input(Text, &Arena))
-// The returned symbol is backed by both Input and Arena.
-Symbol SymbolFromYAML(llvm::yaml::Input &Input, llvm::BumpPtrAllocator &Arena);
+// The returned symbol is backed by Input.
+Symbol SymbolFromYAML(llvm::yaml::Input &Input);
 
 // Convert a single symbol to YAML-format string.
 // The YAML result is safe to concatenate.
 std::string SymbolToYAML(Symbol Sym);
 
 // Convert symbols to a YAML-format string.
 // The YAML result is safe to concatenate if you have multiple symbol slabs.
 void SymbolsToYAML(const SymbolSlab &Symbols, llvm::raw_ostream &OS);
 
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SYMBOL_FROM_YAML_H

clangd/index/SymbolYAML.cpp

 template <> struct MappingTraits<SymbolInfo> {
   static void mapping(IO &io, SymbolInfo &SymInfo) {
     // FIXME: expose other fields?
     io.mapRequired("Kind", SymInfo.Kind);
     io.mapRequired("Lang", SymInfo.Lang);
   }
 };
 
-template <> struct MappingTraits<Symbol::Details> {
-  static void mapping(IO &io, Symbol::Details &Detail) {
-    io.mapOptional("Documentation", Detail.Documentation);
-    io.mapOptional("ReturnType", Detail.ReturnType);
-    io.mapOptional("IncludeHeader", Detail.IncludeHeader);
-  }
-};
-
-// A YamlIO normalizer for fields of type "const T*" allocated on an arena.
-// Normalizes to Optional<T>, so traits should be provided for T.
-template <typename T> struct ArenaPtr {
-  ArenaPtr(IO &) {}
-  ArenaPtr(IO &, const T *D) {
-    if (D)
-      Opt = *D;
-  }
-
-  const T *denormalize(IO &IO) {
-    assert(IO.getContext() && "Expecting an arena (as context) to allocate "
-                              "data for read symbols.");
-    if (!Opt)
-      return nullptr;
-    return new (*static_cast<llvm::BumpPtrAllocator *>(IO.getContext()))
-        T(std::move(*Opt)); // Allocate a copy of Opt on the arena.
-  }
-
-  llvm::Optional<T> Opt;
-};
-
 template <> struct MappingTraits<Symbol> {
   static void mapping(IO &IO, Symbol &Sym) {
     MappingNormalization<NormalizedSymbolID, SymbolID> NSymbolID(IO, Sym.ID);
-    MappingNormalization<ArenaPtr<Symbol::Details>, const Symbol::Details *>
-        NDetail(IO, Sym.Detail);
     IO.mapRequired("ID", NSymbolID->HexString);
     IO.mapRequired("Name", Sym.Name);
     IO.mapRequired("Scope", Sym.Scope);
     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.mapOptional("Signature", Sym.Signature);
     IO.mapOptional("CompletionSnippetSuffix", Sym.CompletionSnippetSuffix);
-    IO.mapOptional("Detail", NDetail->Opt);
+    IO.mapOptional("Documentation", Sym.Documentation);
+    IO.mapOptional("ReturnType", Sym.ReturnType);
+    IO.mapOptional("IncludeHeader", Sym.IncludeHeader);
   }
 };
 
 template <> struct ScalarEnumerationTraits<SymbolLanguage> {
   static void enumeration(IO &IO, SymbolLanguage &Value) {
     IO.enumCase(Value, "C", SymbolLanguage::C);
     IO.enumCase(Value, "Cpp", SymbolLanguage::CXX);
     IO.enumCase(Value, "ObjC", SymbolLanguage::ObjC);

 
 } // namespace yaml
 } // namespace llvm
 
 namespace clang {
 namespace clangd {
 
 SymbolSlab symbolsFromYAML(llvm::StringRef YAMLContent) {
-  // Store data of pointer fields (excl. `StringRef`) like `Detail`.
-  llvm::BumpPtrAllocator Arena;
-  llvm::yaml::Input Yin(YAMLContent, &Arena);
+  llvm::yaml::Input Yin(YAMLContent);
   std::vector<Symbol> S;
   Yin >> S;
 
   SymbolSlab::Builder Syms;
   for (auto &Sym : S)
     Syms.insert(Sym);
   return std::move(Syms).build();
 }
 
-Symbol SymbolFromYAML(llvm::yaml::Input &Input, llvm::BumpPtrAllocator &Arena) {
-  // We could grab Arena out of Input, but it'd be a huge hazard for callers.
-  assert(Input.getContext() == &Arena);
+Symbol SymbolFromYAML(llvm::yaml::Input &Input) {
   Symbol S;
   Input >> S;
   return S;
 }
 
 void SymbolsToYAML(const SymbolSlab& Symbols, llvm::raw_ostream &OS) {
   llvm::yaml::Output Yout(OS);
   for (Symbol S : Symbols) // copy: Yout<< requires mutability.

unittests/clangd/CodeCompleteTests.cpp

TEST(CompletionTest, IncludeInsertionPreprocessorIntegrationTests) {
   std::string Subdir = testPath("sub");
   std::string SearchDirArg = (llvm::Twine("-I") + Subdir).str();
   CDB.ExtraClangFlags = {SearchDirArg.c_str()};
   std::string BarHeader = testPath("sub/bar.h");
   FS.Files[BarHeader] = "";
 
   IgnoreDiagnostics DiagConsumer;
   ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
-  Symbol::Details Scratch;
   auto BarURI = URI::createFile(BarHeader).toString();
   Symbol Sym = cls("ns::X");
   Sym.CanonicalDeclaration.FileURI = BarURI;
-  Scratch.IncludeHeader = BarURI;
-  Sym.Detail = &Scratch;
+  Sym.IncludeHeader = BarURI;
   // Shoten include path based on search dirctory and insert.
   auto Results = completions(Server,
                              R"cpp(
           int main() { ns::^ }
       )cpp",
                              {Sym});
   EXPECT_THAT(Results.Completions,
               ElementsAre(AllOf(Named("X"), InsertInclude("\"bar.h\""))));

 }
 
 TEST(CompletionTest, NoIncludeInsertionWhenDeclFoundInFile) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
 
   IgnoreDiagnostics DiagConsumer;
   ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
-  Symbol::Details Scratch;
   Symbol SymX = cls("ns::X");
   Symbol SymY = cls("ns::Y");
   std::string BarHeader = testPath("bar.h");
   auto BarURI = URI::createFile(BarHeader).toString();
   SymX.CanonicalDeclaration.FileURI = BarURI;
   SymY.CanonicalDeclaration.FileURI = BarURI;
-  Scratch.IncludeHeader = "<bar>";
-  SymX.Detail = &Scratch;
-  SymY.Detail = &Scratch;
+  SymX.IncludeHeader = "<bar>";
+  SymY.IncludeHeader = "<bar>";
   // Shoten include path based on search dirctory and insert.
   auto Results = completions(Server,
                              R"cpp(
           namespace ns {
             class X;
             class Y {}
           }
           int main() { ns::^ }
TEST(CompletionTest, OverloadBundling) {
 
   // Non-member completions are bundled, including index+sema.
   Symbol NoArgsGFunc = func("GFuncC");
   EXPECT_THAT(
       completions(Context + "int y = GFunc^", {NoArgsGFunc}, Opts).Completions,
       UnorderedElementsAre(Labeled("GFuncC(…)"), Labeled("GFuncD(int)")));
 
   // Differences in header-to-insert suppress bundling.
-  Symbol::Details Detail;
   std::string DeclFile = URI::createFile(testPath("foo")).toString();
   NoArgsGFunc.CanonicalDeclaration.FileURI = DeclFile;
-  Detail.IncludeHeader = "<foo>";
-  NoArgsGFunc.Detail = &Detail;
+  NoArgsGFunc.IncludeHeader = "<foo>";
   EXPECT_THAT(
       completions(Context + "int y = GFunc^", {NoArgsGFunc}, Opts).Completions,
       UnorderedElementsAre(AllOf(Named("GFuncC"), InsertInclude("<foo>")),
                            Labeled("GFuncC(int)"), Labeled("GFuncD(int)")));
 
   // Examine a bundled completion in detail.
   auto A =
       completions(Context + "int y = X().a^", {}, Opts).Completions.front();
StringRef Sig3 = R"cpp(
     }
   )cpp";
 
   EXPECT_THAT(signatures(Sig3).signatures,
               ElementsAre(Sig("foo(T, U) -> void", {"T", "U"})));
 }
 
 TEST(SignatureHelpTest, IndexDocumentation) {
-  Symbol::Details DocDetails;
-  DocDetails.Documentation = "Doc from the index";
-
   Symbol Foo0 = sym("foo", index::SymbolKind::Function, "@F@\\0#");
-  Foo0.Detail = &DocDetails;
+  Foo0.Documentation = "Doc from the index";
   Symbol Foo1 = sym("foo", index::SymbolKind::Function, "@F@\\0#I#");
-  Foo1.Detail = &DocDetails;
+  Foo1.Documentation = "Doc from the index";
   Symbol Foo2 = sym("foo", index::SymbolKind::Function, "@F@\\0#I#I#");
 
   StringRef Sig0 = R"cpp(
     int foo();
     int foo(double);
 
     void test() {
       foo(^);

unittests/clangd/FileIndexTests.cpp

 TEST(FileIndexTest, NoIncludeCollected) {
   FileIndex M;
   update(M, "f", "class string {};");
 
   FuzzyFindRequest Req;
   Req.Query = "";
   bool SeenSymbol = false;
   M.fuzzyFind(Req, [&](const Symbol &Sym) {
-    EXPECT_TRUE(Sym.Detail->IncludeHeader.empty());
+    EXPECT_TRUE(Sym.IncludeHeader.empty());
     SeenSymbol = true;
   });
   EXPECT_TRUE(SeenSymbol);
 }
 
 TEST(FileIndexTest, TemplateParamsInLabel) {
   auto Source = R"cpp(
 template <class Ty>

unittests/clangd/IndexTests.cpp

TEST(MergeTest, Merge) {
   L.ID = R.ID = SymbolID("hello");
   L.Name = R.Name = "Foo";                           // same in both
   L.CanonicalDeclaration.FileURI = "file:///left.h"; // differs
   R.CanonicalDeclaration.FileURI = "file:///right.h";
   L.References = 1;
   R.References = 2;
   L.Signature = "()";                   // present in left only
   R.CompletionSnippetSuffix = "{$1:0}"; // present in right only
-  Symbol::Details DetL, DetR;
-  DetL.ReturnType = "DetL";
-  DetR.ReturnType = "DetR";
-  DetR.Documentation = "--doc--";
-  L.Detail = &DetL;
-  R.Detail = &DetR;
+  R.Documentation = "--doc--";
   L.Origin = SymbolOrigin::Dynamic;
   R.Origin = SymbolOrigin::Static;
 
-  Symbol::Details Scratch;
-  Symbol M = mergeSymbol(L, R, &Scratch);
+  Symbol M = mergeSymbol(L, R);
   EXPECT_EQ(M.Name, "Foo");
   EXPECT_EQ(M.CanonicalDeclaration.FileURI, "file:///left.h");
   EXPECT_EQ(M.References, 3u);
   EXPECT_EQ(M.Signature, "()");
   EXPECT_EQ(M.CompletionSnippetSuffix, "{$1:0}");
-  ASSERT_TRUE(M.Detail);
-  EXPECT_EQ(M.Detail->ReturnType, "DetL");
-  EXPECT_EQ(M.Detail->Documentation, "--doc--");
+  EXPECT_EQ(M.Documentation, "--doc--");
   EXPECT_EQ(M.Origin,
             SymbolOrigin::Dynamic | SymbolOrigin::Static | SymbolOrigin::Merge);
 }
 
 TEST(MergeTest, PreferSymbolWithDefn) {
   Symbol L, R;
-  Symbol::Details Scratch;
 
   L.ID = R.ID = SymbolID("hello");
   L.CanonicalDeclaration.FileURI = "file:/left.h";
   R.CanonicalDeclaration.FileURI = "file:/right.h";
   L.Name = "left";
   R.Name = "right";
 
-  Symbol M = mergeSymbol(L, R, &Scratch);
+  Symbol M = mergeSymbol(L, R);
   EXPECT_EQ(M.CanonicalDeclaration.FileURI, "file:/left.h");
   EXPECT_EQ(M.Definition.FileURI, "");
   EXPECT_EQ(M.Name, "left");
 
   R.Definition.FileURI = "file:/right.cpp"; // Now right will be favored.
-  M = mergeSymbol(L, R, &Scratch);
+  M = mergeSymbol(L, R);
   EXPECT_EQ(M.CanonicalDeclaration.FileURI, "file:/right.h");
   EXPECT_EQ(M.Definition.FileURI, "file:/right.cpp");
   EXPECT_EQ(M.Name, "right");
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

unittests/clangd/SymbolCollectorTests.cpp

 using testing::Not;
 using testing::UnorderedElementsAre;
 using testing::UnorderedElementsAreArray;
 
 // GMock helpers for matching Symbol.
 MATCHER_P(Labeled, Label, "") {
   return (arg.Name + arg.Signature).str() == Label;
 }
-MATCHER(HasReturnType, "") {
-  return arg.Detail && !arg.Detail->ReturnType.empty();
-}
-MATCHER_P(ReturnType, D, "") {
-  return arg.Detail && arg.Detail->ReturnType == D;
-}
-MATCHER_P(Doc, D, "") { return arg.Detail && arg.Detail->Documentation == D; }
+MATCHER(HasReturnType, "") { return !arg.ReturnType.empty(); }
+MATCHER_P(ReturnType, D, "") { return arg.ReturnType == D; }
+MATCHER_P(Doc, D, "") { return arg.Documentation == D; }
 MATCHER_P(Snippet, S, "") {
   return (arg.Name + arg.CompletionSnippetSuffix).str() == S;
 }
 MATCHER_P(QName, Name, "") { return (arg.Scope + arg.Name).str() == Name; }
 MATCHER_P(DeclURI, P, "") { return arg.CanonicalDeclaration.FileURI == P; }
 MATCHER_P(DefURI, P, "") { return arg.Definition.FileURI == P; }
-MATCHER_P(IncludeHeader, P, "") {
-  return arg.Detail && arg.Detail->IncludeHeader == P;
-}
+MATCHER_P(IncludeHeader, P, "") { return arg.IncludeHeader == P; }
 MATCHER_P(DeclRange, Pos, "") {
   return std::tie(arg.CanonicalDeclaration.Start.Line,
                   arg.CanonicalDeclaration.Start.Column,
                   arg.CanonicalDeclaration.End.Line,
                   arg.CanonicalDeclaration.End.Column) ==
          std::tie(Pos.start.line, Pos.start.character, Pos.end.line,
                   Pos.end.character);
 }
CanonicalDeclaration:
   FileURI:        file:///path/foo.h
   Start:
     Line: 1
     Column: 0
   End:
     Line: 1
     Column: 1
 IsIndexedForCodeCompletion:    true
-Detail:
-  Documentation:    'Foo doc'
-  ReturnType:    'int'
 ...
 )";
   const std::string YAML2 = R"(
 ---
 ID: 057557CEBF6E6B2DD437FBF60CC58F352D1DF858
 Name:   'Foo2'
 Scope:   'clang::'
 SymInfo: