[clangd] Add "str()" method to SymbolID.

[hokein]

Summary

This is a convenient function when we try to get std::string of
SymbolID.

[ioeric]

lgtm with a nit

clangd/index/Index.h

72

I think Sam wants to reduce the size to 20 bytes. Maybe just drop the "40-bytes" part?

[hokein]

clangd/index/Index.h

72

The comment clarifies the current behavior of the method, I prefer to keep it. We can change it at the time when we reduce the size :)

clangd/global-symbol-builder/GlobalSymbolBuilderMain.cpp

public:
         return WrapperFrontendAction::CreateASTConsumer(CI, InFile);
       }
 
       void EndSourceFileAction() override {
         WrapperFrontendAction::EndSourceFileAction();
 
         auto Symbols = Collector->takeSymbols();
         for (const auto &Sym : Symbols) {
-          std::string IDStr;
-          llvm::raw_string_ostream OS(IDStr);
-          OS << Sym.ID;
-          Ctx->reportResult(OS.str(), SymbolToYAML(Sym));
+          Ctx->reportResult(Sym.ID.str(), SymbolToYAML(Sym));
         }
       }
 
     private:
       tooling::ExecutionContext *Ctx;
       std::shared_ptr<SymbolCollector> Collector;
       std::unique_ptr<CanonicalIncludes> Includes;
       std::unique_ptr<CommentHandler> PragmaHandler;

clangd/index/Index.h

public:
 
   bool operator==(const SymbolID &Sym) const {
     return HashValue == Sym.HashValue;
   }
   bool operator<(const SymbolID &Sym) const {
     return HashValue < Sym.HashValue;
   }
 
+  // Returns a 40-bytes hex encoded string.
+  std::string str() const;
+
 private:
   static constexpr unsigned HashByteLength = 20;
 
   friend llvm::hash_code hash_value(const SymbolID &ID) {
     // We already have a good hash, just return the first bytes.
     static_assert(sizeof(size_t) <= HashByteLength, "size_t longer than SHA1!");
     size_t Result;
     memcpy(&Result, ID.HashValue.data(), sizeof(size_t));

clangd/index/Index.cpp

 SymbolID::SymbolID(StringRef USR)
     : HashValue(SHA1::hash(arrayRefFromStringRef(USR))) {}
 
 raw_ostream &operator<<(raw_ostream &OS, const SymbolID &ID) {
   OS << toHex(toStringRef(ID.HashValue));
   return OS;
 }
 
+std::string SymbolID::str() const {
+  std::string ID;
+  llvm::raw_string_ostream OS(ID);
+  OS << *this;
+  return OS.str();
+}
+
 void operator>>(StringRef Str, SymbolID &ID) {
   std::string HexString = fromHex(Str);
   assert(HexString.size() == ID.HashValue.size());
   std::copy(HexString.begin(), HexString.end(), ID.HashValue.begin());
 }
 
 raw_ostream &operator<<(raw_ostream &OS, const Symbol &S) {
   return OS << S.Scope << S.Name;