[clangd] Take into account what is in the index (symbols, references, etc.) at indexes merge

[ArcsinX]

Summary

Current indexes merge logic skip data from the static index if the file is in the dynamic index, but sometimes the dynamic index does not contain references (e.g. preamble (dynamic) index vs background (static) index).
This problem is masked with the fact, that the preamble index file list consists of file URI's and other indexes file lists consist of file paths.
This patch introduces the index contents (symbols, references, etc.), which makes indexes merge more flexible and makes it able to use URI's for the index file list.

[ArcsinX]

Initial discussion https://reviews.llvm.org/D93683?id=313280#inline-875666

[ArcsinX]

Prevent crash in debug mode.

[sammccall]

Thanks for following up on this!

clang-tools-extra/clangd/index/FileIndex.cpp

269

I don't think it makes sense to specify this at index-build-time, should it be a constructor parameter instead?

This value describes all the data previously passed to update(), so we must always update() with the same type of data. So this is really tied to the identify of the FileSymbols, rather than the buildIndex operation.

437

Is this change related? It changes the key scheme for the preamble index from URIs to paths, but I'm not sure why.

Do we have multiple URIs pointing to the same path? What are they concretely?

clang-tools-extra/clangd/index/Index.h

85

This deserves a comment to motivate it... e.g.

Describes what data is covered by an index.
Indexes may contain symbols but not references from a file, etc.
This affects merging: if a staler index contains a reference but a
fresher one does not, we want to trust the fresher index *only*
if it actually includes references in general!

85

This name is a bit vague for my taste (because both "data" and "kind" tend to get attached to everything, they lose their meaning)

Maybe IndexContents? This is still vague but at least describes the relationship between the index and the e.g. Symbols.

98

I'd also consider explicit operator bool() so you can write if (Indexed(File) & IndexContents::References), but a question of taste.

[ArcsinX]

clang-tools-extra/clangd/index/FileIndex.cpp

437

This is the main thing in this patch. I will try to explain.
We use these keys to create the file list, which is used by indexedFiles().
Currently, the preamble index contains URI's instead of paths (as a file list), that leads to the function returned by PreambleIndex::indexedFiles() always return false (because we pass to this function paths, not URI's). So, we always take data from the preamble index (but maybe we should not in some cases).

[ArcsinX]

clang-tools-extra/clangd/index/FileIndex.cpp

437

that leads to the function returned by PreambleIndex::indexedFiles() always return false (because we pass to this function paths, not URI's)

This is a bit incorrect.
We pass to this function URI, but this URI is converted to path. i.e. MemIndex::indexedFiles(), Dex::indexedFiles() expect that Files are paths, but they are URI's for the preamble index. That's why PreambleIndex::indexedFiles() always return false.

[sammccall]

clang-tools-extra/clangd/index/FileIndex.cpp

437

Oooh... I'm not sure how I misunderstood the original so much :-( And I missed it in this patch description as well, apologies.

My impression was that the file list was derived from the index data, rather than from the keys, which were always intended to be opaque/arbitrary.
(At various times, these have been filenames, URIs, and other things IIRC. And until relatively recently, the preamble index keys were the file the preamble was built from, not the file containing the symbol!)

It feels like using URIs extracted from symbols might not be *completely* robust. Because having CanonicalDeclaration etc set to a file might not line up exactly with the idea that we indexed the file. But we do use this partitioning for FileShardedIndex, so it has to work well enough.

The advantage of using the extracted URIs would be: also works for non-file-sharded indexes like --index-file, avoid a bunch of conversion between URI and path, and we get to keep the simpler/flexible design for FileSymbols where the key is opaque.

Does this seem feasible to you?

[ArcsinX]

clang-tools-extra/clangd/index/FileIndex.cpp

437

I also do not like these path <=> URI conversions. But what about empty files?, e.g.:

• open a file
• remove everything from this file
• the dynamic index has no symbols with definition/declaration from this file, so we do not have this file in the dynamic index file list.
• the static index has symbols with definition/declaration from this file, so we have this file in the static index file list.
• we will show stale results from the static index for this file.

Unsure, maybe it's ok to ignore the problem with empty files, seems this is the only case when the file was indexed, but we have no symbols located there.

Overall, I like the idea to use URI's instead of paths. I think we could implement it first as a separate patch and after that return to this one.

What do you think?

[sammccall]

clang-tools-extra/clangd/index/FileIndex.cpp

437

Right, completely empty files are going to be mishandled., in the same way that before your changes we mishandled files that had no results from the query.

I do still think this is the way to go though, because:

• completely empty files are much rarer
• again this is a peer to an FileShardedIndex issue where empty files get no shards. Therefore *within* the dynamic index, we'll never clear out the symbols for a file while the file is emptied
• having SymbolCollector explicitly the files indexed is the principled solution to both problems, and that seems feasible for us to do at some point.

Overall, I like the idea to use URI's instead of paths. I think we could implement it first as a separate patch and after that return to this one.

That sounds great if you don't mind!
(Is there a reason we can't land the rest of this patch as-is already?)

[ArcsinX]

• Set IdxContents at FileSymbols object breation instead of at FileSymbols::buildIndex() call.
• Revert change of the preamble index key scheme
• Add comment for IndexContents
• IndexDataKind => IndexContents

[ArcsinX]

clang-tools-extra/clangd/index/FileIndex.cpp

437

(Is there a reason we can't land the rest of this patch as-is already?)

Seems we have no reason =)

clang-tools-extra/clangd/index/Index.h

98

Unsure how I can do this =(
I could not add operator bool() as a method for enum class.
I see these solutions:

• keep it as is
• implement bool operator !(IndexContents) and use !!
• make IndexContents to be struct/class
• add a function with a simple name instead of operator bool

[ArcsinX]

clang-tools-extra/clangd/index/FileIndex.cpp

437

Overall, I like the idea to use URI's instead of paths. I think we could implement it first as a separate patch and after that return to this one.

Seems we need to land this patch first. Without index contents it's impossible to use URI's everywhere in the index file list (because the preamble index does not contain references, but without this patch we do not have this information at indexes merge).

[sammccall]

Sorry, forgot to stamp this!

clang-tools-extra/clangd/index/FileIndex.cpp

417

seems we include relations too?

420

(this should take into account CollectMainFileRefs, but actually if you sync to HEAD it's always true now)

clang-tools-extra/clangd/index/FileIndex.h

74

It seems error-prone to have a default here.
(I guess it's for making tests shorter? Are there enough callsites for it to matter?)

If we must have a default, All seems to make more sense than None.

[ArcsinX]

• Remove default value of IdxContents in FileSymbols constructor.
• Fix index contents for the preamble index (Symbols => Symbols|Relations).
• Rebase

[ArcsinX]

Thank you for review.

clang-tools-extra/clangd/index/Background.cpp

 
 } // namespace
 
 BackgroundIndex::BackgroundIndex(
     const ThreadsafeFS &TFS, const GlobalCompilationDatabase &CDB,
     BackgroundIndexStorage::Factory IndexStorageFactory, Options Opts)
     : SwapIndex(std::make_unique<MemIndex>()), TFS(TFS), CDB(CDB),
       ContextProvider(std::move(Opts.ContextProvider)),
+      IndexedSymbols(IndexContents::All),
       Rebuilder(this, &IndexedSymbols, Opts.ThreadPoolSize),
       IndexStorageFactory(std::move(IndexStorageFactory)),
       Queue(std::move(Opts.OnProgress)),
       CommandsChanged(
           CDB.watch([&](const std::vector<std::string> &ChangedFiles) {
             enqueue(ChangedFiles);
           })) {
   assert(Opts.ThreadPoolSize > 0 && "Thread pool size can't be zero.");

clang-tools-extra/clangd/index/FileIndex.h

 /// stores a pointer pointing to the newest snapshot, and an outdated snapshot
 /// is deleted by the last owner of the snapshot, either this class or the
 /// symbol index.
 ///
 /// The snapshot semantics keeps critical sections minimal since we only need
 /// locking when we swap or obtain references to snapshots.
 class FileSymbols {
 public:
+  FileSymbols(IndexContents IdxContents);
   /// Updates all slabs associated with the \p Key.
   /// If either is nullptr, corresponding data for \p Key will be removed.
   /// If CountReferences is true, \p Refs will be used for counting references
   /// during merging.
   void update(llvm::StringRef Key, std::unique_ptr<SymbolSlab> Symbols,
               std::unique_ptr<RefSlab> Refs,
               std::unique_ptr<RelationSlab> Relations, bool CountReferences);
 
   /// The index keeps the slabs alive.
   /// Will count Symbol::References based on number of references in the main
   /// files, while building the index with DuplicateHandling::Merge option.
   /// Version is populated with an increasing sequence counter.
   std::unique_ptr<SymbolIndex>
   buildIndex(IndexType,
              DuplicateHandling DuplicateHandle = DuplicateHandling::PickOne,
              size_t *Version = nullptr);
 
   void profile(MemoryTree &MT) const;
 
 private:
+  IndexContents IdxContents;
+
   struct RefSlabAndCountReferences {
     std::shared_ptr<RefSlab> Slab;
     bool CountReferences = false;
   };
   mutable std::mutex Mutex;
 
   size_t Version = 0;
   llvm::StringMap<std::shared_ptr<SymbolSlab>> SymbolsSnapshot;

clang-tools-extra/clangd/index/FileIndex.cpp

std::vector<Decl *> DeclsToIndex(
       AST.getTranslationUnitDecl()->decls().begin(),
       AST.getTranslationUnitDecl()->decls().end());
   return indexSymbols(AST, std::move(PP), DeclsToIndex,
                       /*MainFileMacros=*/nullptr, Includes,
                       /*IsIndexMainAST=*/false, Version,
                       /*CollectMainFileRefs=*/false);
 }
 
+FileSymbols::FileSymbols(IndexContents IdxContents)
+    : IdxContents(IdxContents) {}
+
 void FileSymbols::update(llvm::StringRef Key,
                          std::unique_ptr<SymbolSlab> Symbols,
                          std::unique_ptr<RefSlab> Refs,
                          std::unique_ptr<RelationSlab> Relations,
                          bool CountReferences) {
   std::lock_guard<std::mutex> Lock(Mutex);
   ++Version;
   if (!Symbols)
void FileSymbols::update(llvm::StringRef Key,
   if (!Relations)
     RelationsSnapshot.erase(Key);
   else
     RelationsSnapshot[Key] = std::move(Relations);
 }
 
 std::unique_ptr<SymbolIndex>
 FileSymbols::buildIndex(IndexType Type, DuplicateHandling DuplicateHandle,
                         size_t *Version) {
   std::vector<std::shared_ptr<SymbolSlab>> SymbolSlabs;
   std::vector<std::shared_ptr<RefSlab>> RefSlabs;
   std::vector<std::shared_ptr<RelationSlab>> RelationSlabs;
   llvm::StringSet<> Files;
   std::vector<RefSlab *> MainFileRefs;
   {
     std::lock_guard<std::mutex> Lock(Mutex);
     for (const auto &FileAndSymbols : SymbolsSnapshot) {
FileSymbols::buildIndex(IndexType Type, DuplicateHandling DuplicateHandle,
   for (const auto &RefSlab : RefSlabs)
     StorageSize += RefSlab->bytes();
 
   // Index must keep the slabs and contiguous ranges alive.
   switch (Type) {
   case IndexType::Light:
     return std::make_unique<MemIndex>(
         llvm::make_pointee_range(AllSymbols), std::move(AllRefs),
-        std::move(AllRelations), std::move(Files),
+        std::move(AllRelations), std::move(Files), IdxContents,
         std::make_tuple(std::move(SymbolSlabs), std::move(RefSlabs),
                         std::move(RefsStorage), std::move(SymsStorage)),
         StorageSize);
   case IndexType::Heavy:
     return std::make_unique<dex::Dex>(
         llvm::make_pointee_range(AllSymbols), std::move(AllRefs),
-        std::move(AllRelations), std::move(Files),
+        std::move(AllRelations), std::move(Files), IdxContents,
         std::make_tuple(std::move(SymbolSlabs), std::move(RefSlabs),
                         std::move(RefsStorage), std::move(SymsStorage)),
         StorageSize);
   }
   llvm_unreachable("Unknown clangd::IndexType");
 }
 
 void FileSymbols::profile(MemoryTree &MT) const {
void FileSymbols::profile(MemoryTree &MT) const {
   for (const auto &RelSlab : RelationsSnapshot) {
     MT.detail(RelSlab.first())
         .child("relations")
         .addUsage(RelSlab.second->bytes());
   }
 }
 
 FileIndex::FileIndex()
     : MergedIndex(&MainFileIndex, &PreambleIndex),
+      PreambleSymbols(IndexContents::Symbols | IndexContents::Relations),
       PreambleIndex(std::make_unique<MemIndex>()),
+      MainFileSymbols(IndexContents::All),
       MainFileIndex(std::make_unique<MemIndex>()) {}
 
 void FileIndex::updatePreamble(PathRef Path, llvm::StringRef Version,
                                ASTContext &AST,
                                std::shared_ptr<Preprocessor> PP,
                                const CanonicalIncludes &Includes) {
   IndexFileIn IF;
   std::tie(IF.Symbols, std::ignore, IF.Relations) =
       indexHeaderSymbols(Version, AST, std::move(PP), Includes);
   FileShardedIndex ShardedIndex(std::move(IF));
   for (auto Uri : ShardedIndex.getAllSources()) {
     auto IF = ShardedIndex.getShard(Uri);
     // We are using the key received from ShardedIndex, so it should always
     // exist.
     assert(IF);
     PreambleSymbols.update(
         Uri, std::make_unique<SymbolSlab>(std::move(*IF->Symbols)),
         std::make_unique<RefSlab>(),
         std::make_unique<RelationSlab>(std::move(*IF->Relations)),
         /*CountReferences=*/false);
   }
   size_t IndexVersion = 0;
   auto NewIndex = PreambleSymbols.buildIndex(
       IndexType::Heavy, DuplicateHandling::PickOne, &IndexVersion);
   {

clang-tools-extra/clangd/index/Index.h

 
 struct RelationsRequest {
   llvm::DenseSet<SymbolID> Subjects;
   RelationKind Predicate;
   /// If set, limit the number of relations returned from the index.
   llvm::Optional<uint32_t> Limit;
 };
 
+/// Describes what data is covered by an index.
+///
+/// Indexes may contain symbols but not references from a file, etc.
+/// This affects merging: if a staler index contains a reference but a fresher
+/// one does not, we want to trust the fresher index *only* if it actually
+/// includes references in general.
+enum class IndexContents : uint8_t {
+  None = 0,
+  Symbols = 1 << 1,
+  References = 1 << 2,
+  Relations = 1 << 3,
+  All = Symbols | References | Relations
+};
+
+inline constexpr IndexContents operator&(IndexContents L, IndexContents R) {
+  return static_cast<IndexContents>(static_cast<uint8_t>(L) &
+                                    static_cast<uint8_t>(R));
+}
+
+inline constexpr IndexContents operator|(IndexContents L, IndexContents R) {
+  return static_cast<IndexContents>(static_cast<uint8_t>(L) |
+                                    static_cast<uint8_t>(R));
+}
+
 /// Interface for symbol indexes that can be used for searching or
 /// matching symbols among a set of symbols based on names or unique IDs.
 class SymbolIndex {
 public:
   virtual ~SymbolIndex() = default;
 
   /// Matches symbols in the index fuzzily and applies \p Callback on
   /// each matched symbol before returning.
public:
   /// each.
   virtual void relations(
       const RelationsRequest &Req,
       llvm::function_ref<void(const SymbolID &Subject, const Symbol &Object)>
           Callback) const = 0;
 
   /// Returns function which checks if the specified file was used to build this
   /// index or not. The function must only be called while the index is alive.
-  virtual llvm::unique_function<bool(llvm::StringRef) const>
+  virtual llvm::unique_function<IndexContents(llvm::StringRef) const>
   indexedFiles() const = 0;
 
   /// Returns estimated size of index (in bytes).
   virtual size_t estimateMemoryUsage() const = 0;
 };
 
 // Delegating implementation of SymbolIndex whose delegate can be swapped out.
 class SwapIndex : public SymbolIndex {
public:
   void lookup(const LookupRequest &,
               llvm::function_ref<void(const Symbol &)>) const override;
   bool refs(const RefsRequest &,
             llvm::function_ref<void(const Ref &)>) const override;
   void relations(const RelationsRequest &,
                  llvm::function_ref<void(const SymbolID &, const Symbol &)>)
       const override;
 
-  llvm::unique_function<bool(llvm::StringRef) const>
+  llvm::unique_function<IndexContents(llvm::StringRef) const>
   indexedFiles() const override;
 
   size_t estimateMemoryUsage() const override;
 
 private:
   std::shared_ptr<SymbolIndex> snapshot() const;
   mutable std::mutex Mutex;
   std::shared_ptr<SymbolIndex> Index;
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_INDEX_H

clang-tools-extra/clangd/index/Index.cpp

bool SwapIndex::refs(const RefsRequest &R,
   return snapshot()->refs(R, CB);
 }
 void SwapIndex::relations(
     const RelationsRequest &R,
     llvm::function_ref<void(const SymbolID &, const Symbol &)> CB) const {
   return snapshot()->relations(R, CB);
 }
 
-llvm::unique_function<bool(llvm::StringRef) const>
+llvm::unique_function<IndexContents(llvm::StringRef) const>
 SwapIndex::indexedFiles() const {
   // The index snapshot should outlive this method return value.
   auto SnapShot = snapshot();
   auto IndexedFiles = SnapShot->indexedFiles();
   return [KeepAlive{std::move(SnapShot)},
           IndexContainsFile{std::move(IndexedFiles)}](llvm::StringRef File) {
     return IndexContainsFile(File);
   };
 }
 
 size_t SwapIndex::estimateMemoryUsage() const {
   return snapshot()->estimateMemoryUsage();
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/index/MemIndex.h

MemIndex(SymbolRange &&Symbols, RefRange &&Refs, RelationRange &&Relations,
     KeepAlive = std::shared_ptr<void>(
         std::make_shared<Payload>(std::move(BackingData)), nullptr);
     this->BackingDataSize = BackingDataSize;
   }
 
   template <typename SymbolRange, typename RefRange, typename RelationRange,
             typename FileRange, typename Payload>
   MemIndex(SymbolRange &&Symbols, RefRange &&Refs, RelationRange &&Relations,
-           FileRange &&Files, Payload &&BackingData, size_t BackingDataSize)
+           FileRange &&Files, IndexContents IdxContents, Payload &&BackingData,
+           size_t BackingDataSize)
       : MemIndex(std::forward<SymbolRange>(Symbols),
                  std::forward<RefRange>(Refs),
                  std::forward<RelationRange>(Relations),
                  std::forward<Payload>(BackingData), BackingDataSize) {
     this->Files = std::forward<FileRange>(Files);
+    this->IdxContents = IdxContents;
   }
 
   /// Builds an index from slabs. The index takes ownership of the data.
   static std::unique_ptr<SymbolIndex> build(SymbolSlab Symbols, RefSlab Refs,
                                             RelationSlab Relations);
 
   bool
   fuzzyFind(const FuzzyFindRequest &Req,
             llvm::function_ref<void(const Symbol &)> Callback) const override;
 
   void lookup(const LookupRequest &Req,
               llvm::function_ref<void(const Symbol &)> Callback) const override;
 
   bool refs(const RefsRequest &Req,
             llvm::function_ref<void(const Ref &)> Callback) const override;
 
   void relations(const RelationsRequest &Req,
                  llvm::function_ref<void(const SymbolID &, const Symbol &)>
                      Callback) const override;
 
-  llvm::unique_function<bool(llvm::StringRef) const>
+  llvm::unique_function<IndexContents(llvm::StringRef) const>
   indexedFiles() const override;
 
   size_t estimateMemoryUsage() const override;
 
 private:
   // Index is a set of symbols that are deduplicated by symbol IDs.
   llvm::DenseMap<SymbolID, const Symbol *> Index;
   // A map from symbol ID to symbol refs, support query by IDs.
   llvm::DenseMap<SymbolID, llvm::ArrayRef<Ref>> Refs;
   // A map from (subject, predicate) pair to objects.
   static_assert(sizeof(RelationKind) == sizeof(uint8_t),
                 "RelationKind should be of same size as a uint8_t");
   llvm::DenseMap<std::pair<SymbolID, uint8_t>, std::vector<SymbolID>> Relations;
   // Set of files which were used during this index build.
   llvm::StringSet<> Files;
+  // Contents of the index (symbols, references, etc.)
+  IndexContents IdxContents;
   std::shared_ptr<void> KeepAlive; // poor man's move-only std::any
   // Size of memory retained by KeepAlive.
   size_t BackingDataSize = 0;
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_MEMINDEX_H

clang-tools-extra/clangd/index/MemIndex.cpp

if (It != Relations.end()) {
           LookupReq.IDs.insert(Obj);
         }
       }
     }
     lookup(LookupReq, [&](const Symbol &Object) { Callback(Subject, Object); });
   }
 }
 
-llvm::unique_function<bool(llvm::StringRef) const>
+llvm::unique_function<IndexContents(llvm::StringRef) const>
 MemIndex::indexedFiles() const {
   return [this](llvm::StringRef FileURI) {
     auto Path = URI::resolve(FileURI);
     if (!Path) {
       llvm::consumeError(Path.takeError());
-      return false;
+      return IndexContents::None;
     }
-    return Files.contains(*Path);
+    return Files.contains(*Path) ? IdxContents : IndexContents::None;
   };
 }
 
 size_t MemIndex::estimateMemoryUsage() const {
   return Index.getMemorySize() + Refs.getMemorySize() +
          Relations.getMemorySize() + BackingDataSize;
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/index/Merge.h

bool fuzzyFind(const FuzzyFindRequest &,
                  llvm::function_ref<void(const Symbol &)>) const override;
   void lookup(const LookupRequest &,
               llvm::function_ref<void(const Symbol &)>) const override;
   bool refs(const RefsRequest &,
             llvm::function_ref<void(const Ref &)>) const override;
   void relations(const RelationsRequest &,
                  llvm::function_ref<void(const SymbolID &, const Symbol &)>)
       const override;
-  llvm::unique_function<bool(llvm::StringRef) const>
+  llvm::unique_function<IndexContents(llvm::StringRef) const>
   indexedFiles() const override;
   size_t estimateMemoryUsage() const override {
     return Dynamic->estimateMemoryUsage() + Static->estimateMemoryUsage();
   }
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_MERGE_H

clang-tools-extra/clangd/index/Merge.cpp

bool MergedIndex::fuzzyFind(
   SymbolSlab Dyn = std::move(DynB).build();
 
   llvm::DenseSet<SymbolID> SeenDynamicSymbols;
   {
     auto DynamicContainsFile = Dynamic->indexedFiles();
     More |= Static->fuzzyFind(Req, [&](const Symbol &S) {
       // We expect the definition to see the canonical declaration, so it seems
       // to be enough to check only the definition if it exists.
-      if (DynamicContainsFile(S.Definition ? S.Definition.FileURI
-                                           : S.CanonicalDeclaration.FileURI))
+      if ((DynamicContainsFile(S.Definition ? S.Definition.FileURI
+                                            : S.CanonicalDeclaration.FileURI) &
+           IndexContents::Symbols) != IndexContents::None)
         return;
       auto DynS = Dyn.find(S.ID);
       ++StaticCount;
       if (DynS == Dyn.end())
         return Callback(S);
       ++MergedCount;
       SeenDynamicSymbols.insert(S.ID);
       Callback(mergeSymbol(*DynS, S));
void MergedIndex::lookup(
   Dynamic->lookup(Req, [&](const Symbol &S) { B.insert(S); });
 
   auto RemainingIDs = Req.IDs;
   {
     auto DynamicContainsFile = Dynamic->indexedFiles();
     Static->lookup(Req, [&](const Symbol &S) {
       // We expect the definition to see the canonical declaration, so it seems
       // to be enough to check only the definition if it exists.
-      if (DynamicContainsFile(S.Definition ? S.Definition.FileURI
-                                           : S.CanonicalDeclaration.FileURI))
+      if ((DynamicContainsFile(S.Definition ? S.Definition.FileURI
+                                            : S.CanonicalDeclaration.FileURI) &
+           IndexContents::Symbols) != IndexContents::None)
         return;
       const Symbol *Sym = B.find(S.ID);
       RemainingIDs.erase(S.ID);
       if (!Sym)
         Callback(S);
       else
         Callback(mergeSymbol(*Sym, S));
     });
More |= Dynamic->refs(Req, [&](const Ref &O) {
     --Remaining;
   });
   if (Remaining == 0 && More)
     return More;
   auto DynamicContainsFile = Dynamic->indexedFiles();
   // We return less than Req.Limit if static index returns more refs for dirty
   // files.
   bool StaticHadMore = Static->refs(Req, [&](const Ref &O) {
-    if (DynamicContainsFile(O.Location.FileURI))
+    if ((DynamicContainsFile(O.Location.FileURI) & IndexContents::References) !=
+        IndexContents::None)
       return; // ignore refs that have been seen from dynamic index.
     if (Remaining == 0) {
       More = true;
       return;
     }
     --Remaining;
     Callback(O);
   });
   return More || StaticHadMore;
 }
 
-llvm::unique_function<bool(llvm::StringRef) const>
+llvm::unique_function<IndexContents(llvm::StringRef) const>
 MergedIndex::indexedFiles() const {
   return [DynamicContainsFile{Dynamic->indexedFiles()},
           StaticContainsFile{Static->indexedFiles()}](llvm::StringRef FileURI) {
-    return DynamicContainsFile(FileURI) || StaticContainsFile(FileURI);
+    return DynamicContainsFile(FileURI) | StaticContainsFile(FileURI);
   };
 }
 
 void MergedIndex::relations(
     const RelationsRequest &Req,
     llvm::function_ref<void(const SymbolID &, const Symbol &)> Callback) const {
   uint32_t Remaining =
       Req.Limit.getValueOr(std::numeric_limits<uint32_t>::max());

clang-tools-extra/clangd/index/ProjectAware.cpp

public:
   fuzzyFind(const FuzzyFindRequest &Req,
             llvm::function_ref<void(const Symbol &)> Callback) const override;
 
   /// Query all indexes while prioritizing the associated one (if any).
   void relations(const RelationsRequest &Req,
                  llvm::function_ref<void(const SymbolID &, const Symbol &)>
                      Callback) const override;
 
-  llvm::unique_function<bool(llvm::StringRef) const>
+  llvm::unique_function<IndexContents(llvm::StringRef) const>
   indexedFiles() const override;
 
   ProjectAwareIndex(IndexFactory Gen) : Gen(std::move(Gen)) {}
 
 private:
   // Returns the index associated with current context, if any.
   SymbolIndex *getIndex() const;
 

 void ProjectAwareIndex::relations(
     const RelationsRequest &Req,
     llvm::function_ref<void(const SymbolID &, const Symbol &)> Callback) const {
   trace::Span Tracer("ProjectAwareIndex::relations");
   if (auto *Idx = getIndex())
     return Idx->relations(Req, Callback);
 }
 
-llvm::unique_function<bool(llvm::StringRef) const>
+llvm::unique_function<IndexContents(llvm::StringRef) const>
 ProjectAwareIndex::indexedFiles() const {
   trace::Span Tracer("ProjectAwareIndex::indexedFiles");
   if (auto *Idx = getIndex())
     return Idx->indexedFiles();
-  return [](llvm::StringRef) { return false; };
+  return [](llvm::StringRef) { return IndexContents::None; };
 }
 
 SymbolIndex *ProjectAwareIndex::getIndex() const {
   const auto &C = Config::current();
   if (!C.Index.External)
     return nullptr;
   const auto &External = *C.Index.External;
   std::lock_guard<std::mutex> Lock(Mu);

clang-tools-extra/clangd/index/dex/Dex.h

Dex(SymbolRange &&Symbols, RefsRange &&Refs, RelationsRange &&Relations,
     KeepAlive = std::shared_ptr<void>(
         std::make_shared<Payload>(std::move(BackingData)), nullptr);
     this->BackingDataSize = BackingDataSize;
   }
 
   template <typename SymbolRange, typename RefsRange, typename RelationsRange,
             typename FileRange, typename Payload>
   Dex(SymbolRange &&Symbols, RefsRange &&Refs, RelationsRange &&Relations,
-      FileRange &&Files, Payload &&BackingData, size_t BackingDataSize)
+      FileRange &&Files, IndexContents IdxContents, Payload &&BackingData,
+      size_t BackingDataSize)
       : Dex(std::forward<SymbolRange>(Symbols), std::forward<RefsRange>(Refs),
             std::forward<RelationsRange>(Relations),
             std::forward<Payload>(BackingData), BackingDataSize) {
     this->Files = std::forward<FileRange>(Files);
+    this->IdxContents = IdxContents;
   }
 
   /// Builds an index from slabs. The index takes ownership of the slab.
   static std::unique_ptr<SymbolIndex> build(SymbolSlab, RefSlab, RelationSlab);
 
   bool
   fuzzyFind(const FuzzyFindRequest &Req,
             llvm::function_ref<void(const Symbol &)> Callback) const override;
 
   void lookup(const LookupRequest &Req,
               llvm::function_ref<void(const Symbol &)> Callback) const override;
 
   bool refs(const RefsRequest &Req,
             llvm::function_ref<void(const Ref &)> Callback) const override;
 
   void relations(const RelationsRequest &Req,
                  llvm::function_ref<void(const SymbolID &, const Symbol &)>
                      Callback) const override;
 
-  llvm::unique_function<bool(llvm::StringRef) const>
+  llvm::unique_function<IndexContents(llvm::StringRef) const>
   indexedFiles() const override;
 
   size_t estimateMemoryUsage() const override;
 
 private:
   void buildIndex();
   std::unique_ptr<Iterator> iterator(const Token &Tok) const;
   std::unique_ptr<Iterator>
private:
   dex::Corpus Corpus;
   llvm::DenseMap<SymbolID, llvm::ArrayRef<Ref>> Refs;
   static_assert(sizeof(RelationKind) == sizeof(uint8_t),
                 "RelationKind should be of same size as a uint8_t");
   llvm::DenseMap<std::pair<SymbolID, uint8_t>, std::vector<SymbolID>> Relations;
   std::shared_ptr<void> KeepAlive; // poor man's move-only std::any
   // Set of files which were used during this index build.
   llvm::StringSet<> Files;
+  // Contents of the index (symbols, references, etc.)
+  IndexContents IdxContents;
   // Size of memory retained by KeepAlive.
   size_t BackingDataSize = 0;
 };
 
 /// Returns Search Token for a number of parent directories of given Path.
 /// Should be used within the index build process.
 ///
 /// This function is exposed for testing only.
 std::vector<std::string> generateProximityURIs(llvm::StringRef URIPath);
 
 } // namespace dex
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEX_DEX_H

clang-tools-extra/clangd/index/dex/Dex.cpp

if (It != Relations.end()) {
           LookupReq.IDs.insert(Object);
         }
       }
     }
     lookup(LookupReq, [&](const Symbol &Object) { Callback(Subject, Object); });
   }
 }
 
-llvm::unique_function<bool(llvm::StringRef) const> Dex::indexedFiles() const {
+llvm::unique_function<IndexContents(llvm::StringRef) const>
+Dex::indexedFiles() const {
   return [this](llvm::StringRef FileURI) {
     auto Path = URI::resolve(FileURI);
     if (!Path) {
       llvm::consumeError(Path.takeError());
-      return false;
+      return IndexContents::None;
     }
-    return Files.contains(*Path);
+    return Files.contains(*Path) ? IdxContents : IndexContents::None;
   };
 }
 
 size_t Dex::estimateMemoryUsage() const {
   size_t Bytes = Symbols.size() * sizeof(const Symbol *);
   Bytes += SymbolQuality.size() * sizeof(float);
   Bytes += LookupTable.getMemorySize();
   Bytes += InvertedIndex.getMemorySize();

clang-tools-extra/clangd/index/remote/Client.cpp

relations(const clangd::RelationsRequest &Request,
                 Callback) const override {
     streamRPC(Request, &remote::v1::SymbolIndex::Stub::Relations,
               // Unpack protobuf Relation.
               [&](std::pair<SymbolID, clangd::Symbol> SubjectAndObject) {
                 Callback(SubjectAndObject.first, SubjectAndObject.second);
               });
   }
 
-  llvm::unique_function<bool(llvm::StringRef) const>
+  llvm::unique_function<IndexContents(llvm::StringRef) const>
   indexedFiles() const override {
-    // FIXME: For now we always return "false" regardless of whether the file
-    //        was indexed or not. A possible implementation could be based on
-    //        the idea that we do not want to send a request at every
+    // FIXME: For now we always return IndexContents::None regardless of whether
+    //        the file was indexed or not. A possible implementation could be
+    //        based on the idea that we do not want to send a request at every
     //        call of a function returned by IndexClient::indexedFiles().
-    return [](llvm::StringRef) { return false; };
+    return [](llvm::StringRef) { return IndexContents::None; };
   }
 
   // IndexClient does not take any space since the data is stored on the
   // server.
   size_t estimateMemoryUsage() const override { return 0; }
 
 private:
   std::unique_ptr<remote::v1::SymbolIndex::Stub> Stub;

clang-tools-extra/clangd/unittests/BackgroundIndexTests.cpp

TEST_F(BackgroundIndexTest, Reindex) {
   EXPECT_EQ(1u, runFuzzyFind(Idx, "theOldFunction").size());
   EXPECT_EQ(0u, runFuzzyFind(Idx, "theNewFunction").size());
   EXPECT_EQ(OldShard, Storage.lookup(testPath("A.cc")));
 }
 
 class BackgroundIndexRebuilderTest : public testing::Test {
 protected:
   BackgroundIndexRebuilderTest()
-      : Target(std::make_unique<MemIndex>()),
+      : Source(IndexContents::All), Target(std::make_unique<MemIndex>()),
         Rebuilder(&Target, &Source, /*Threads=*/10) {
     // Prepare FileSymbols with TestSymbol in it, for checkRebuild.
     TestSymbol.ID = SymbolID("foo");
   }
 
   // Perform Action and determine whether it rebuilt the index or not.
   bool checkRebuild(std::function<void()> Action) {
     // Update name so we can tell if the index updates.

clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp

bool refs(const RefsRequest &,
             llvm::function_ref<void(const Ref &)>) const override {
     return false;
   }
 
   void relations(const RelationsRequest &,
                  llvm::function_ref<void(const SymbolID &, const Symbol &)>)
       const override {}
 
-  llvm::unique_function<bool(llvm::StringRef) const>
+  llvm::unique_function<IndexContents(llvm::StringRef) const>
   indexedFiles() const override {
-    return [](llvm::StringRef) { return false; };
+    return [](llvm::StringRef) { return IndexContents::None; };
   }
 
   // This is incorrect, but IndexRequestCollector is not an actual index and it
   // isn't used in production code.
   size_t estimateMemoryUsage() const override { return 0; }
 
   const std::vector<FuzzyFindRequest> consumeRequests(size_t Num) const {
     std::unique_lock<std::mutex> Lock(Mut);

clang-tools-extra/clangd/unittests/DexTests.cpp

 
 TEST(DexIndex, IndexedFiles) {
   SymbolSlab Symbols;
   RefSlab Refs;
   auto Size = Symbols.bytes() + Refs.bytes();
   auto Data = std::make_pair(std::move(Symbols), std::move(Refs));
   llvm::StringSet<> Files = {testPath("foo.cc"), testPath("bar.cc")};
   Dex I(std::move(Data.first), std::move(Data.second), RelationSlab(),
-        std::move(Files), std::move(Data), Size);
+        std::move(Files), IndexContents::All, std::move(Data), Size);
   auto ContainsFile = I.indexedFiles();
-  EXPECT_TRUE(ContainsFile("unittest:///foo.cc"));
-  EXPECT_TRUE(ContainsFile("unittest:///bar.cc"));
-  EXPECT_FALSE(ContainsFile("unittest:///foobar.cc"));
+  EXPECT_EQ(ContainsFile("unittest:///foo.cc"), IndexContents::All);
+  EXPECT_EQ(ContainsFile("unittest:///bar.cc"), IndexContents::All);
+  EXPECT_EQ(ContainsFile("unittest:///foobar.cc"), IndexContents::None);
 }
 
 TEST(DexTest, PreferredTypesBoosting) {
   auto Sym1 = symbol("t1");
   Sym1.Type = "T1";
   auto Sym2 = symbol("t2");
   Sym2.Type = "T2";
 

clang-tools-extra/clangd/unittests/FileIndexTests.cpp

 std::unique_ptr<RelationSlab> relSlab(llvm::ArrayRef<const Relation> Rels) {
   RelationSlab::Builder RelBuilder;
   for (auto &Rel : Rels)
     RelBuilder.insert(Rel);
   return std::make_unique<RelationSlab>(std::move(RelBuilder).build());
 }
 
 TEST(FileSymbolsTest, UpdateAndGet) {
-  FileSymbols FS;
+  FileSymbols FS(IndexContents::All);
   EXPECT_THAT(runFuzzyFind(*FS.buildIndex(IndexType::Light), ""), IsEmpty());
 
   FS.update("f1", numSlab(1, 3), refSlab(SymbolID("1"), "f1.cc"), nullptr,
             false);
   EXPECT_THAT(runFuzzyFind(*FS.buildIndex(IndexType::Light), ""),
               UnorderedElementsAre(QName("1"), QName("2"), QName("3")));
   EXPECT_THAT(getRefs(*FS.buildIndex(IndexType::Light), SymbolID("1")),
               RefsAre({FileURI("f1.cc")}));
 }
 
 TEST(FileSymbolsTest, Overlap) {
-  FileSymbols FS;
+  FileSymbols FS(IndexContents::All);
   FS.update("f1", numSlab(1, 3), nullptr, nullptr, false);
   FS.update("f2", numSlab(3, 5), nullptr, nullptr, false);
   for (auto Type : {IndexType::Light, IndexType::Heavy})
     EXPECT_THAT(runFuzzyFind(*FS.buildIndex(Type), ""),
                 UnorderedElementsAre(QName("1"), QName("2"), QName("3"),
                                      QName("4"), QName("5")));
 }
 
 TEST(FileSymbolsTest, MergeOverlap) {
-  FileSymbols FS;
+  FileSymbols FS(IndexContents::All);
   auto OneSymboSlab = [](Symbol Sym) {
     SymbolSlab::Builder S;
     S.insert(Sym);
     return std::make_unique<SymbolSlab>(std::move(S).build());
   };
   auto X1 = symbol("x");
   X1.CanonicalDeclaration.FileURI = "file:///x1";
   auto X2 = symbol("x");
   X2.Definition.FileURI = "file:///x2";
 
   FS.update("f1", OneSymboSlab(X1), nullptr, nullptr, false);
   FS.update("f2", OneSymboSlab(X2), nullptr, nullptr, false);
   for (auto Type : {IndexType::Light, IndexType::Heavy})
     EXPECT_THAT(
         runFuzzyFind(*FS.buildIndex(Type, DuplicateHandling::Merge), "x"),
         UnorderedElementsAre(
             AllOf(QName("x"), DeclURI("file:///x1"), DefURI("file:///x2"))));
 }
 
 TEST(FileSymbolsTest, SnapshotAliveAfterRemove) {
-  FileSymbols FS;
+  FileSymbols FS(IndexContents::All);
 
   SymbolID ID("1");
   FS.update("f1", numSlab(1, 3), refSlab(ID, "f1.cc"), nullptr, false);
 
   auto Symbols = FS.buildIndex(IndexType::Light);
   EXPECT_THAT(runFuzzyFind(*Symbols, ""),
               UnorderedElementsAre(QName("1"), QName("2"), QName("3")));
   EXPECT_THAT(getRefs(*Symbols, ID), RefsAre({FileURI("f1.cc")}));
TEST(FileIndexTest, MergeMainFileSymbols) {
   auto Symbols = runFuzzyFind(Index, "");
   // Check foo is merged, foo in Cpp wins (as we see the definition there).
   EXPECT_THAT(Symbols, ElementsAre(AllOf(DeclURI("unittest:///foo.h"),
                                          DefURI("unittest:///foo.cpp"),
                                          hasOrign(SymbolOrigin::Merge))));
 }
 
 TEST(FileSymbolsTest, CountReferencesNoRefSlabs) {
-  FileSymbols FS;
+  FileSymbols FS(IndexContents::All);
   FS.update("f1", numSlab(1, 3), nullptr, nullptr, true);
   FS.update("f2", numSlab(1, 3), nullptr, nullptr, false);
   EXPECT_THAT(
       runFuzzyFind(*FS.buildIndex(IndexType::Light, DuplicateHandling::Merge),
                    ""),
       UnorderedElementsAre(AllOf(QName("1"), NumReferences(0u)),
                            AllOf(QName("2"), NumReferences(0u)),
                            AllOf(QName("3"), NumReferences(0u))));
 }
 
 TEST(FileSymbolsTest, CountReferencesWithRefSlabs) {
-  FileSymbols FS;
+  FileSymbols FS(IndexContents::All);
   FS.update("f1cpp", numSlab(1, 3), refSlab(SymbolID("1"), "f1.cpp"), nullptr,
             true);
   FS.update("f1h", numSlab(1, 3), refSlab(SymbolID("1"), "f1.h"), nullptr,
             false);
   FS.update("f2cpp", numSlab(1, 3), refSlab(SymbolID("2"), "f2.cpp"), nullptr,
             true);
   FS.update("f2h", numSlab(1, 3), refSlab(SymbolID("2"), "f2.h"), nullptr,
             false);
TEST(FileIndexTest, Profile) {
   ASSERT_THAT(MT.child("main_file").children(),
               UnorderedElementsAre(Pair("index", _), Pair("slabs", _)));
 
   ASSERT_THAT(MT.child("preamble").child("index").total(), Gt(0U));
   ASSERT_THAT(MT.child("main_file").child("index").total(), Gt(0U));
 }
 
 TEST(FileSymbolsTest, Profile) {
-  FileSymbols FS;
+  FileSymbols FS(IndexContents::All);
   FS.update("f1", numSlab(1, 2), nullptr, nullptr, false);
   FS.update("f2", nullptr, refSlab(SymbolID("1"), "f1"), nullptr, false);
   FS.update("f3", nullptr, nullptr,
             relSlab({{SymbolID("1"), RelationKind::BaseOf, SymbolID("2")}}),
             false);
   llvm::BumpPtrAllocator Alloc;
   MemoryTree MT(&Alloc);
   FS.profile(MT);

clang-tools-extra/clangd/unittests/IndexTests.cpp

 
 TEST(MemIndexTest, IndexedFiles) {
   SymbolSlab Symbols;
   RefSlab Refs;
   auto Size = Symbols.bytes() + Refs.bytes();
   auto Data = std::make_pair(std::move(Symbols), std::move(Refs));
   llvm::StringSet<> Files = {testPath("foo.cc"), testPath("bar.cc")};
   MemIndex I(std::move(Data.first), std::move(Data.second), RelationSlab(),
-             std::move(Files), std::move(Data), Size);
+             std::move(Files), IndexContents::All, std::move(Data), Size);
   auto ContainsFile = I.indexedFiles();
-  EXPECT_TRUE(ContainsFile("unittest:///foo.cc"));
-  EXPECT_TRUE(ContainsFile("unittest:///bar.cc"));
-  EXPECT_FALSE(ContainsFile("unittest:///foobar.cc"));
+  EXPECT_EQ(ContainsFile("unittest:///foo.cc"), IndexContents::All);
+  EXPECT_EQ(ContainsFile("unittest:///bar.cc"), IndexContents::All);
+  EXPECT_EQ(ContainsFile("unittest:///foobar.cc"), IndexContents::None);
 }
 
 TEST(MemIndexTest, TemplateSpecialization) {
   SymbolSlab::Builder B;
 
   Symbol S = symbol("TempSpec");
   S.ID = SymbolID("1");
   B.insert(S);

 
 TEST(MergeIndexTest, IndexedFiles) {
   SymbolSlab DynSymbols;
   RefSlab DynRefs;
   auto DynSize = DynSymbols.bytes() + DynRefs.bytes();
   auto DynData = std::make_pair(std::move(DynSymbols), std::move(DynRefs));
   llvm::StringSet<> DynFiles = {testPath("foo.cc")};
   MemIndex DynIndex(std::move(DynData.first), std::move(DynData.second),
-                    RelationSlab(), std::move(DynFiles), std::move(DynData),
-                    DynSize);
+                    RelationSlab(), std::move(DynFiles), IndexContents::Symbols,
+                    std::move(DynData), DynSize);
   SymbolSlab StaticSymbols;
   RefSlab StaticRefs;
   auto StaticData =
       std::make_pair(std::move(StaticSymbols), std::move(StaticRefs));
-  llvm::StringSet<> StaticFiles = {testPath("bar.cc")};
-  MemIndex StaticIndex(std::move(StaticData.first),
-                       std::move(StaticData.second), RelationSlab(),
-                       std::move(StaticFiles), std::move(StaticData),
-                       StaticSymbols.bytes() + StaticRefs.bytes());
+  llvm::StringSet<> StaticFiles = {testPath("foo.cc"), testPath("bar.cc")};
+  MemIndex StaticIndex(
+      std::move(StaticData.first), std::move(StaticData.second), RelationSlab(),
+      std::move(StaticFiles), IndexContents::References, std::move(StaticData),
   MergedIndex Merge(&DynIndex, &StaticIndex);
 
   auto ContainsFile = Merge.indexedFiles();
-  EXPECT_TRUE(ContainsFile("unittest:///foo.cc"));
-  EXPECT_TRUE(ContainsFile("unittest:///bar.cc"));
-  EXPECT_FALSE(ContainsFile("unittest:///foobar.cc"));
+  EXPECT_EQ(ContainsFile("unittest:///foo.cc"),
+            IndexContents::Symbols | IndexContents::References);
+  EXPECT_EQ(ContainsFile("unittest:///bar.cc"), IndexContents::References);
+  EXPECT_EQ(ContainsFile("unittest:///foobar.cc"), IndexContents::None);
 }
 
 TEST(MergeIndexTest, NonDocumentation) {
   using index::SymbolKind;
   Symbol L, R;
   L.ID = R.ID = SymbolID("x");
   L.Definition.FileURI = "file:/x.h";
   R.Documentation = "Forward declarations because x.h is too big to include";

clang-tools-extra/clangd/unittests/RenameTests.cpp

 TEST(CrossFileRenameTests, DirtyBuffer) {
   Annotations FooCode("class [[Foo]] {};");
   std::string FooPath = testPath("foo.cc");
   Annotations FooDirtyBuffer("class [[Foo]] {};\n// this is dirty buffer");
   Annotations BarCode("void [[Bar]]() {}");
   std::string BarPath = testPath("bar.cc");
   // Build the index, the index has "Foo" references from foo.cc and "Bar"
   // references from bar.cc.
-  FileSymbols FSymbols;
+  FileSymbols FSymbols(IndexContents::All);
   FSymbols.update(FooPath, nullptr, buildRefSlab(FooCode, "Foo", FooPath),
                   nullptr, false);
   FSymbols.update(BarPath, nullptr, buildRefSlab(BarCode, "Bar", BarPath),
                   nullptr, false);
   auto Index = FSymbols.buildIndex(IndexType::Light);
 
   Annotations MainCode("class  [[Fo^o]] {};");
   auto MainFilePath = testPath("main.cc");
class PaginationIndex : public SymbolIndex {
     void
     lookup(const LookupRequest &Req,
            llvm::function_ref<void(const Symbol &)> Callback) const override {}
 
     void relations(const RelationsRequest &Req,
                    llvm::function_ref<void(const SymbolID &, const Symbol &)>
                        Callback) const override {}
 
-    llvm::unique_function<bool(llvm::StringRef) const>
+    llvm::unique_function<IndexContents(llvm::StringRef) const>
     indexedFiles() const override {
-      return [](llvm::StringRef) { return false; };
+      return [](llvm::StringRef) { return IndexContents::None; };
     }
 
     size_t estimateMemoryUsage() const override { return 0; }
   } PIndex;
   Results = rename({MainCode.point(),
                     NewName,
                     AST,
                     MainFilePath,
public:
     }
     void lookup(const LookupRequest &,
                 llvm::function_ref<void(const Symbol &)>) const override {}
 
     void relations(const RelationsRequest &,
                    llvm::function_ref<void(const SymbolID &, const Symbol &)>)
         const override {}
 
-    llvm::unique_function<bool(llvm::StringRef) const>
+    llvm::unique_function<IndexContents(llvm::StringRef) const>
     indexedFiles() const override {
-      return [](llvm::StringRef) { return false; };
+      return [](llvm::StringRef) { return IndexContents::None; };
     }
 
     size_t estimateMemoryUsage() const override { return 0; }
     Ref ReturnedRef;
   } DIndex(XRefInBarCC);
   llvm::StringRef NewName = "newName";
   auto Results = rename({MainCode.point(),
                          NewName,