[clangd] Clear the semantic of RefSlab::size.

[hokein]

Summary

The RefSlab::size can easily cause confusions, it returns the number of
different symbols, rahter than the number of all references.

• add numRefs() method and cache it, since calculating it everytime is nontrivial.
• clear misused places.

[sammccall]

Adding numRefs() and fixing occurrences makes sense.
However I think size() needs to stay - it's an important part of the "container" concept, and e.g. GTest relies on it.

[hokein]

• reserve the size name, added a comment indicating its senmatic.

[hokein]

In D53389#1268250, @sammccall wrote:

Adding numRefs() and fixing occurrences makes sense.
However I think size() needs to stay - it's an important part of the "container" concept, and e.g. GTest relies on it.

OK, and I added a comment for this method to avoid future confusion.

clangd/index/Background.cpp

if (!Action->BeginSourceFile(*Clang, Input))
     return createStringError(llvm::inconvertibleErrorCode(),
                              "BeginSourceFile() failed");
   if (!Action->Execute())
     return createStringError(llvm::inconvertibleErrorCode(),
                              "Execute() failed");
   Action->EndSourceFile();
 
   log("Indexed {0} ({1} symbols, {2} refs)", Inputs.CompileCommand.Filename,
-      Symbols.size(), Refs.size());
+      Symbols.size(), Refs.numRefs());
   SPAN_ATTACH(Tracer, "symbols", int(Symbols.size()));
-  SPAN_ATTACH(Tracer, "refs", int(Refs.size()));
+  SPAN_ATTACH(Tracer, "refs", int(Refs.numRefs()));
   // FIXME: partition the symbols by file rather than TU, to avoid duplication.
   IndexedSymbols.update(AbsolutePath,
                         llvm::make_unique<SymbolSlab>(std::move(Symbols)),
                         llvm::make_unique<RefSlab>(std::move(Refs)));
   FileHash[AbsolutePath] = Hash;
 
   // FIXME: this should rebuild once-in-a-while, not after every file.
   //       At that point we should use Dex, too.
   vlog("Rebuilding automatic index");
   reset(IndexedSymbols.buildIndex(IndexType::Light));
   return Error::success();
 }
 
 } // namespace clangd
 } // namespace clang

clangd/index/FileIndex.cpp

indexSymbols(ASTContext &AST, std::shared_ptr<Preprocessor> PP,
   const auto &SM = AST.getSourceManager();
   const auto *MainFileEntry = SM.getFileEntryForID(SM.getMainFileID());
   std::string FileName = MainFileEntry ? MainFileEntry->getName() : "";
 
   auto Syms = Collector.takeSymbols();
   auto Refs = Collector.takeRefs();
   vlog("index AST for {0} (main={1}): \n"
        "  symbol slab: {2} symbols, {3} bytes\n"
-       "  ref slab: {4} symbols, {5} bytes",
+       "  ref slab: {4} symbols, {5} refs, {6} bytes",
        FileName, IsIndexMainAST, Syms.size(), Syms.bytes(), Refs.size(),
-       Refs.bytes());
+       Refs.numRefs(), Refs.bytes());
   return {std::move(Syms), std::move(Refs)};
 }
 
 std::pair<SymbolSlab, RefSlab>
 indexMainDecls(ParsedAST &AST, llvm::ArrayRef<std::string> URISchemes) {
   return indexSymbols(AST.getASTContext(), AST.getPreprocessorPtr(),
                       AST.getLocalTopLevelDecls(),
                       /*IsIndexMainAST=*/true, URISchemes);

clangd/index/Index.h

public:
   using iterator = const_iterator;
 
   RefSlab() = default;
   RefSlab(RefSlab &&Slab) = default;
   RefSlab &operator=(RefSlab &&RHS) = default;
 
   const_iterator begin() const { return Refs.begin(); }
   const_iterator end() const { return Refs.end(); }
+  /// Gets the number of symbols.
   size_t size() const { return Refs.size(); }
+  size_t numRefs() const { return NumRefs; }
   bool empty() const { return Refs.empty(); }
 
   size_t bytes() const {
     return sizeof(*this) + Arena.getTotalMemory() +
            sizeof(value_type) * Refs.size();
   }
 
   // RefSlab::Builder is a mutable container that can 'freeze' to RefSlab.
   class Builder {
   public:
     Builder() : UniqueStrings(Arena) {}
     // Adds a ref to the slab. Deep copy: Strings will be owned by the slab.
     void insert(const SymbolID &ID, const Ref &S);
     // Consumes the builder to finalize the slab.
     RefSlab build() &&;
 
   private:
     llvm::BumpPtrAllocator Arena;
     llvm::UniqueStringSaver UniqueStrings; // Contents on the arena.
     llvm::DenseMap<SymbolID, std::vector<Ref>> Refs;
   };
 
 private:
-  RefSlab(std::vector<value_type> Refs, llvm::BumpPtrAllocator Arena)
-      : Arena(std::move(Arena)), Refs(std::move(Refs)) {}
+  RefSlab(std::vector<value_type> Refs, llvm::BumpPtrAllocator Arena,
+          size_t NumRefs)
+      : Arena(std::move(Arena)), Refs(std::move(Refs)), NumRefs(NumRefs) {}
 
   llvm::BumpPtrAllocator Arena;
   std::vector<value_type> Refs;
+  // Number of all references.
+  size_t NumRefs = 0;
 };
 
 struct FuzzyFindRequest {
   /// \brief A query string for the fuzzy find. This is matched against symbols'
   /// un-qualified identifiers and should not contain qualifiers like "::".
   std::string Query;
   /// \brief If this is non-empty, symbols must be in at least one of the scopes
   /// (e.g. namespaces) excluding nested scopes. For example, if a scope "xyz::"

clangd/index/Index.cpp

void RefSlab::Builder::insert(const SymbolID &ID, const Ref &S) {
   M.back().Location.FileURI = UniqueStrings.save(M.back().Location.FileURI);
 }
 
 RefSlab RefSlab::Builder::build() && {
   // We can reuse the arena, as it only has unique strings and we need them all.
   // Reallocate refs on the arena to reduce waste and indirections when reading.
   std::vector<std::pair<SymbolID, ArrayRef<Ref>>> Result;
   Result.reserve(Refs.size());
+  size_t NumRefs = 0;
   for (auto &Sym : Refs) {
     auto &SymRefs = Sym.second;
     llvm::sort(SymRefs);
     // FIXME: do we really need to dedup?
     SymRefs.erase(std::unique(SymRefs.begin(), SymRefs.end()), SymRefs.end());
 
+    NumRefs += SymRefs.size();
     auto *Array = Arena.Allocate<Ref>(SymRefs.size());
     std::uninitialized_copy(SymRefs.begin(), SymRefs.end(), Array);
     Result.emplace_back(Sym.first, ArrayRef<Ref>(Array, SymRefs.size()));
   }
-  return RefSlab(std::move(Result), std::move(Arena));
+  return RefSlab(std::move(Result), std::move(Arena), NumRefs);
 }
 
 void SwapIndex::reset(std::unique_ptr<SymbolIndex> Index) {
   // Keep the old index alive, so we don't destroy it under lock (may be slow).
   std::shared_ptr<SymbolIndex> Pin;
   {
     std::lock_guard<std::mutex> Lock(Mutex);
     Pin = std::move(this->Index);

clangd/index/Serialization.cpp

if (auto I = readIndexFile(Buffer->get()->getBuffer())) {
       if (I->Refs)
         Refs = std::move(*I->Refs);
     } else {
       llvm::errs() << "Bad Index: " << llvm::toString(I.takeError()) << "\n";
       return nullptr;
     }
   }
 
-  size_t SymSize = Symbols.size();
-  size_t RefSize = Refs.size();
+  size_t NumSym = Symbols.size();
+  size_t NumRefs = Refs.numRefs();
+
   trace::Span Tracer("BuildIndex");
   auto Index =
       UseDex ? dex::Dex::build(std::move(Symbols), std::move(Refs), URISchemes)
              : MemIndex::build(std::move(Symbols), std::move(Refs));
   vlog("Loaded {0} from {1} with estimated memory usage {2} bytes\n"
-       "  - number of symbos: {3}\n"
+       "  - number of symbols: {3}\n"
        "  - number of refs: {4}\n",
        UseDex ? "Dex" : "MemIndex", SymbolFilename,
-       Index->estimateMemoryUsage(),
-       SymSize, RefSize);
+       Index->estimateMemoryUsage(), NumSym, NumRefs);
   return Index;
 }
 
 } // namespace clangd
 } // namespace clang