[clangd] Use our own relation kind.

[hokein]

Summary

Move the RelationKind from Serialization.h to Relation.h. This patch doesn't
introduce any breaking changes.

[merge_guards_bot]

Bulid results are available at http://results.llvm-merge-guard.org/Phabricator-37

See http://jenkins.llvm-merge-guard.org/job/Phabricator/37/ for more details.

[hokein]

update a style comment.

[merge_guards_bot]

Bulid results are available at http://results.llvm-merge-guard.org/Phabricator-38

See http://jenkins.llvm-merge-guard.org/job/Phabricator/38/ for more details.

[kadircet]

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

72–73

can we rather use uint8_t in here instead of RelationKind to get rid of the DenseMapInfo specialization completely?

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

22

is this clang-formatted ?

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

88

could you also delete definitions of these two functions?

[hokein]

address comments.

[hokein]

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

72–73

Yes, done.

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

22

yes, note that I'm leaving a trailing "," on purpose, to prevent clang-format the whole structure into one-line.

[kadircet]

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

95–96

static_cast<>

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

74

"RelationKind should be of same size as a uint8_t"

llvm/include/llvm/ADT/DenseMapInfo.h

70

s/unsign/unsigned/

74

s/unsigned/unsigned char/
s/char/unsigned char/

76

s/char/unsigned char/

[hokein]

address comments.

[hokein]

fix a missing static_cast.

[hokein]

more static_cast

[merge_guards_bot]

Bulid results are available at http://results.llvm-merge-guard.org/Phabricator-40

See http://jenkins.llvm-merge-guard.org/job/Phabricator/40/ for more details.

[kadircet]

Thanks, LGTM

[merge_guards_bot]

Bulid results are available at http://results.llvm-merge-guard.org/Phabricator-41

See http://jenkins.llvm-merge-guard.org/job/Phabricator/41/ for more details.

[merge_guards_bot]

Bulid results are available at http://results.llvm-merge-guard.org/Phabricator-43

See http://jenkins.llvm-merge-guard.org/job/Phabricator/43/ for more details.

[merge_guards_bot]

Bulid results are available at http://results.llvm-merge-guard.org/Phabricator-42

See http://jenkins.llvm-merge-guard.org/job/Phabricator/42/ for more details.

clang-tools-extra/clangd/XRefs.cpp

 #include "FormattedString.h"
 #include "Logger.h"
 #include "ParsedAST.h"
 #include "Protocol.h"
 #include "SourceCode.h"
 #include "URI.h"
 #include "index/Index.h"
 #include "index/Merge.h"
+#include "index/Relation.h"
 #include "index/SymbolCollector.h"
 #include "index/SymbolLocation.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/PrettyPrinter.h"
symbolToTypeHierarchyItem(const Symbol &S, const SymbolIndex *Index,
   return std::move(THI);
 }
 
 static void fillSubTypes(const SymbolID &ID,
                          std::vector<TypeHierarchyItem> &SubTypes,
                          const SymbolIndex *Index, int Levels, PathRef TUPath) {
   RelationsRequest Req;
   Req.Subjects.insert(ID);
-  Req.Predicate = index::SymbolRole::RelationBaseOf;
+  Req.Predicate = RelationKind::BaseOf;
   Index->relations(Req, [&](const SymbolID &Subject, const Symbol &Object) {
     if (Optional<TypeHierarchyItem> ChildSym =
             symbolToTypeHierarchyItem(Object, Index, TUPath)) {
       if (Levels > 1) {
         ChildSym->children.emplace();
         fillSubTypes(Object.ID, *ChildSym->children, Index, Levels - 1, TUPath);
       }
       SubTypes.emplace_back(std::move(*ChildSym));

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

struct RefsRequest {
   /// If set, limit the number of refers returned from the index. The index may
   /// choose to return less than this, e.g. it tries to avoid returning stale
   /// results.
   llvm::Optional<uint32_t> Limit;
 };
 
 struct RelationsRequest {
   llvm::DenseSet<SymbolID> Subjects;
-  index::SymbolRole Predicate;
+  RelationKind Predicate;
   /// If set, limit the number of relations returned from the index.
   llvm::Optional<uint32_t> Limit;
 };
 
 /// 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:

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

public:
   // All symbols and refs must outlive this index.
   template <typename SymbolRange, typename RefRange, typename RelationRange>
   MemIndex(SymbolRange &&Symbols, RefRange &&Refs, RelationRange &&Relations) {
     for (const Symbol &S : Symbols)
       Index[S.ID] = &S;
     for (const std::pair<SymbolID, llvm::ArrayRef<Ref>> &R : Refs)
       this->Refs.try_emplace(R.first, R.second.begin(), R.second.end());
     for (const Relation &R : Relations)
-      this->Relations[std::make_pair(R.Subject, R.Predicate)].push_back(
-          R.Object);
+      this->Relations[std::make_pair(R.Subject,
+                                     static_cast<uint8_t>(R.Predicate))]
+          .push_back(R.Object);
   }
   // Symbols are owned by BackingData, Index takes ownership.
   template <typename SymbolRange, typename RefRange, typename RelationRange,
             typename Payload>
   MemIndex(SymbolRange &&Symbols, RefRange &&Refs, RelationRange &&Relations,
            Payload &&BackingData, size_t BackingDataSize)
       : MemIndex(std::forward<SymbolRange>(Symbols),
                  std::forward<RefRange>(Refs),
public:
 
   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.
-  llvm::DenseMap<std::pair<SymbolID, index::SymbolRole>, std::vector<SymbolID>>
-      Relations;
+  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
   // 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

 
 void MemIndex::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());
   for (const SymbolID &Subject : Req.Subjects) {
     LookupRequest LookupReq;
-    auto It = Relations.find(std::make_pair(Subject, Req.Predicate));
+    auto It = Relations.find(
+        std::make_pair(Subject, static_cast<uint8_t>(Req.Predicate)));
     if (It != Relations.end()) {
       for (const auto &Obj : It->second) {
         if (Remaining > 0) {
           --Remaining;
           LookupReq.IDs.insert(Obj);
         }
       }
     }

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

 #include "clang/Index/IndexSymbol.h"
 #include "llvm/ADT/iterator_range.h"
 #include <cstdint>
 #include <utility>
 
 namespace clang {
 namespace clangd {
 
+enum class RelationKind : uint8_t {
+  BaseOf,
+};
+
 /// Represents a relation between two symbols.
 /// For an example "A is a base class of B" may be represented
-/// as { Subject = A, Predicate = RelationBaseOf, Object = B }.
+/// as { Subject = A, Predicate = BaseOf, Object = B }.
 struct Relation {
   SymbolID Subject;
-  index::SymbolRole Predicate;
+  RelationKind Predicate;
   SymbolID Object;
 
   bool operator==(const Relation &Other) const {
     return std::tie(Subject, Predicate, Object) ==
            std::tie(Other.Subject, Other.Predicate, Other.Object);
   }
   // SPO order
   bool operator<(const Relation &Other) const {
public:
   bool empty() const { return Relations.empty(); }
 
   size_t bytes() const {
     return sizeof(*this) + sizeof(value_type) * Relations.capacity();
   }
 
   /// Lookup all relations matching the given subject and predicate.
   llvm::iterator_range<iterator> lookup(const SymbolID &Subject,
-                                        index::SymbolRole Predicate) const;
+                                        RelationKind Predicate) const;
 
   /// RelationSlab::Builder is a mutable container that can 'freeze' to
   /// RelationSlab.
   class Builder {
   public:
     /// Adds a relation to the slab.
     void insert(const Relation &R) { Relations.push_back(R); }
 
RelationSlab(std::vector<Relation> Relations)
       : Relations(std::move(Relations)) {}
 
   std::vector<Relation> Relations;
 };
 
 } // namespace clangd
 } // namespace clang
 
-namespace llvm {
-
-// Support index::SymbolRole as a DenseMap key for the purpose of looking up
-// relations.
-template <> struct DenseMapInfo<clang::index::SymbolRole> {
-  static inline clang::index::SymbolRole getEmptyKey() {
-    // Choose an enumerator that's not a relation.
-    return clang::index::SymbolRole::Declaration;
-  }
-
-  static inline clang::index::SymbolRole getTombstoneKey() {
-    // Choose another enumerator that's not a relation.
-    return clang::index::SymbolRole::Definition;
-  }
-
-  static unsigned getHashValue(const clang::index::SymbolRole &Key) {
-    return hash_value(Key);
-  }
-
-  static bool isEqual(const clang::index::SymbolRole &LHS,
-                      const clang::index::SymbolRole &RHS) {
-    return LHS == RHS;
-  }
-};
-
-} // namespace llvm
-
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_RELATION_H

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

 //===--- Relation.cpp --------------------------------------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Relation.h"
 
 #include <algorithm>
 
 namespace clang {
 namespace clangd {
 
 llvm::iterator_range<RelationSlab::iterator>
-RelationSlab::lookup(const SymbolID &Subject,
-                     index::SymbolRole Predicate) const {
+RelationSlab::lookup(const SymbolID &Subject, RelationKind Predicate) const {
   auto IterPair = std::equal_range(Relations.begin(), Relations.end(),
                                    Relation{Subject, Predicate, SymbolID{}},
                                    [](const Relation &A, const Relation &B) {
                                      return std::tie(A.Subject, A.Predicate) <
                                             std::tie(B.Subject, B.Predicate);
                                    });
   return {IterPair.first, IterPair.second};
 }

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

 std::string toYAML(const std::pair<SymbolID, ArrayRef<Ref>> &);
 std::string toYAML(const Relation &);
 
 // Build an in-memory static index from an index file.
 // The size should be relatively small, so data can be managed in memory.
 std::unique_ptr<SymbolIndex> loadIndex(llvm::StringRef Filename,
                                        bool UseDex = true);
 
-// Used for serializing SymbolRole as used in Relation.
-enum class RelationKind : uint8_t { BaseOf };
-RelationKind symbolRoleToRelationKind(index::SymbolRole);
-index::SymbolRole relationKindToSymbolRole(RelationKind);
-
 } // namespace clangd
 } // namespace clang
 
 #endif

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

 
 namespace clang {
 namespace clangd {
 namespace {
 llvm::Error makeError(const llvm::Twine &Msg) {
   return llvm::make_error<llvm::StringError>(Msg,
                                              llvm::inconvertibleErrorCode());
 }
-} // namespace
-
-RelationKind symbolRoleToRelationKind(index::SymbolRole Role) {
-  // SymbolRole is used to record relations in the index.
-  // Only handle the relations we actually store currently.
-  // If we start storing more relations, this list can be expanded.
-  switch (Role) {
-  case index::SymbolRole::RelationBaseOf:
-    return RelationKind::BaseOf;
-  default:
-    llvm_unreachable("Unsupported symbol role");
-  }
-}
-
-index::SymbolRole relationKindToSymbolRole(RelationKind Kind) {
-  switch (Kind) {
-  case RelationKind::BaseOf:
-    return index::SymbolRole::RelationBaseOf;
-  }
-  llvm_unreachable("Invalid relation kind");
-}
-
-namespace {
 
 // IO PRIMITIVES
 // We use little-endian 32 bit ints, sometimes with variable-length encoding.
 //
 // Variable-length int encoding (varint) uses the bottom 7 bits of each byte
 // to encode the number, and the top bit to indicate whether more bytes follow.
 // e.g. 9a 2f means [0x1a and keep reading, 0x2f and stop].
 // This represents 0x1a | 0x2f<<7 = 6042.

 // A relations section is a flat list of relations. Each relation has:
 //  - SymbolID (subject): 8 bytes
 //  - relation kind (predicate): 1 byte
 //  - SymbolID (object): 8 bytes
 // In the future, we might prefer a packed representation if the need arises.
 
 void writeRelation(const Relation &R, llvm::raw_ostream &OS) {
   OS << R.Subject.raw();
-  RelationKind Kind = symbolRoleToRelationKind(R.Predicate);
-  OS.write(static_cast<uint8_t>(Kind));
+  OS.write(static_cast<uint8_t>(R.Predicate));
   OS << R.Object.raw();
 }
 
 Relation readRelation(Reader &Data) {
   SymbolID Subject = Data.consumeID();
-  index::SymbolRole Predicate =
-      relationKindToSymbolRole(static_cast<RelationKind>(Data.consume8()));
+  RelationKind Predicate = static_cast<RelationKind>(Data.consume8());
   SymbolID Object = Data.consumeID();
   return {Subject, Predicate, Object};
 }
 
 struct InternedCompileCommand {
   llvm::StringRef Directory;
   std::vector<llvm::StringRef> CommandLine;
 };

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

for (const auto &R : Relations) {
     // TODO: There may be cases where the object decl is not indexed for some
     // reason. Those cases should probably be removed in due course, but for
     // now there are two possible ways to handle it:
     //   (A) Avoid storing the relation in such cases.
     //   (B) Store it anyways. Clients will likely lookup() the SymbolID
     //       in the index and find nothing, but that's a situation they
     //       probably need to handle for other reasons anyways.
     // We currently do (B) because it's simpler.
-    this->Relations.insert(
-        Relation{ID, index::SymbolRole::RelationBaseOf, *ObjectID});
+    this->Relations.insert(Relation{ID, RelationKind::BaseOf, *ObjectID});
   }
 }
 
 void SymbolCollector::setIncludeLocation(const Symbol &S, SourceLocation Loc) {
   if (Opts.CollectIncludePath)
     if (shouldCollectIncludePath(S.SymInfo.Kind))
       // Use the expansion location to get the #include header since this is
       // where the symbol is exposed.

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

static void mapping(IO &IO, Ref &R) {
     MappingNormalization<NormalizedRefKind, RefKind> NKind(IO, R.Kind);
     IO.mapRequired("Kind", NKind->Kind);
     IO.mapRequired("Location", R.Location);
   }
 };
 
 struct NormalizedSymbolRole {
   NormalizedSymbolRole(IO &) {}
-  NormalizedSymbolRole(IO &IO, SymbolRole R) {
-    Kind = static_cast<uint8_t>(clang::clangd::symbolRoleToRelationKind(R));
+  NormalizedSymbolRole(IO &IO, RelationKind R) {
+    Kind = static_cast<uint8_t>(R);
   }
 
-  SymbolRole denormalize(IO &IO) {
-    return clang::clangd::relationKindToSymbolRole(
-        static_cast<RelationKind>(Kind));
-  }
+  RelationKind denormalize(IO &IO) { return static_cast<RelationKind>(Kind); }
 
   uint8_t Kind = 0;
 };
 
 template <> struct MappingTraits<SymbolID> {
   static void mapping(IO &IO, SymbolID &ID) {
     MappingNormalization<NormalizedSymbolID, SymbolID> NSymbolID(IO, ID);
     IO.mapRequired("ID", NSymbolID->HexString);
   }
 };
 
 template <> struct MappingTraits<Relation> {
   static void mapping(IO &IO, Relation &Relation) {
-    MappingNormalization<NormalizedSymbolRole, SymbolRole> NRole(
+    MappingNormalization<NormalizedSymbolRole, RelationKind> NRole(
         IO, Relation.Predicate);
     IO.mapRequired("Subject", Relation.Subject);
     IO.mapRequired("Predicate", NRole->Kind);
     IO.mapRequired("Object", Relation.Object);
   }
 };
 
 template <> struct MappingTraits<VariantEntry> {

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

 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEX_DEX_H
 
 #include "Iterator.h"
 #include "PostingList.h"
 #include "Token.h"
 #include "Trigram.h"
 #include "index/Index.h"
 #include "index/MemIndex.h"
+#include "index/Relation.h"
 #include "index/SymbolCollector.h"
 
 namespace clang {
 namespace clangd {
 namespace dex {
 
 /// In-memory Dex trigram-based index implementation.
 // FIXME(kbobyrev): Introduce serialization and deserialization of the symbol
 // index so that it can be loaded from the disk. Since static index is not
 // changed frequently, it's safe to assume that it has to be built only once
 // (when the clangd process starts). Therefore, it can be easier to store built
 // index on disk and then load it if available.
 class Dex : public SymbolIndex {
 public:
   // All data must outlive this index.
   template <typename SymbolRange, typename RefsRange, typename RelationsRange>
   Dex(SymbolRange &&Symbols, RefsRange &&Refs, RelationsRange &&Relations)
       : Corpus(0) {
     for (auto &&Sym : Symbols)
       this->Symbols.push_back(&Sym);
     for (auto &&Ref : Refs)
       this->Refs.try_emplace(Ref.first, Ref.second);
     for (auto &&Rel : Relations)
-      this->Relations[std::make_pair(Rel.Subject, Rel.Predicate)].push_back(
-          Rel.Object);
+      this->Relations[std::make_pair(Rel.Subject,
+                                     static_cast<uint8_t>(Rel.Predicate))]
+          .push_back(Rel.Object);
     buildIndex();
   }
   // Symbols and Refs are owned by BackingData, Index takes ownership.
   template <typename SymbolRange, typename RefsRange, typename RelationsRange,
             typename Payload>
   Dex(SymbolRange &&Symbols, RefsRange &&Refs, RelationsRange &&Relations,
       Payload &&BackingData, size_t BackingDataSize)
       : Dex(std::forward<SymbolRange>(Symbols), std::forward<RefsRange>(Refs),
private:
   /// which contains all items which can be characterized by such search token.
   /// For example, if the search token is scope "std::", the corresponding
   /// posting list would contain all indices of symbols defined in namespace
   /// std. Inverted index is used to retrieve posting lists which are processed
   /// during the fuzzyFind process.
   llvm::DenseMap<Token, PostingList> InvertedIndex;
   dex::Corpus Corpus;
   llvm::DenseMap<SymbolID, llvm::ArrayRef<Ref>> Refs;
-  llvm::DenseMap<std::pair<SymbolID, index::SymbolRole>, std::vector<SymbolID>>
-      Relations;
+  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
   // 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

 void Dex::relations(
     const RelationsRequest &Req,
     llvm::function_ref<void(const SymbolID &, const Symbol &)> Callback) const {
   trace::Span Tracer("Dex relations");
   uint32_t Remaining =
       Req.Limit.getValueOr(std::numeric_limits<uint32_t>::max());
   for (const SymbolID &Subject : Req.Subjects) {
     LookupRequest LookupReq;
-    auto It = Relations.find(std::make_pair(Subject, Req.Predicate));
+    auto It = Relations.find(
+        std::make_pair(Subject, static_cast<uint8_t>(Req.Predicate)));
     if (It != Relations.end()) {
       for (const auto &Object : It->second) {
         if (Remaining > 0) {
           --Remaining;
           LookupReq.IDs.insert(Object);
         }
       }
     }

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

TEST_F(BackgroundIndexTest, ShardStorageTest) {
   for (const auto &Ref : *ShardSource->Refs)
     EXPECT_THAT(Ref.second,
                 UnorderedElementsAre(FileURI("unittest:///root/A.cc")));
 
   // The BaseOf relationship between A_CC and B_CC is stored in the file
   // containing the definition of the subject (A_CC)
   SymbolID A = findSymbol(*ShardHeader->Symbols, "A_CC").ID;
   SymbolID B = findSymbol(*ShardSource->Symbols, "B_CC").ID;
-  EXPECT_THAT(
-      *ShardHeader->Relations,
-      UnorderedElementsAre(Relation{A, index::SymbolRole::RelationBaseOf, B}));
+  EXPECT_THAT(*ShardHeader->Relations,
+              UnorderedElementsAre(Relation{A, RelationKind::BaseOf, B}));
   // (and not in the file containing the definition of the object (B_CC)).
   EXPECT_EQ(ShardSource->Relations->size(), 0u);
 }
 
 TEST_F(BackgroundIndexTest, DirectIncludesTest) {
   MockFSProvider FS;
   FS.Files[testPath("root/B.h")] = "";
   FS.Files[testPath("root/A.h")] = R"cpp(

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

 
 TEST(DexTests, Relations) {
   auto Parent = symbol("Parent");
   auto Child1 = symbol("Child1");
   auto Child2 = symbol("Child2");
 
   std::vector<Symbol> Symbols{Parent, Child1, Child2};
 
-  std::vector<Relation> Relations{
-      {Parent.ID, index::SymbolRole::RelationBaseOf, Child1.ID},
-      {Parent.ID, index::SymbolRole::RelationBaseOf, Child2.ID}};
+  std::vector<Relation> Relations{{Parent.ID, RelationKind::BaseOf, Child1.ID},
+                                  {Parent.ID, RelationKind::BaseOf, Child2.ID}};
 
   Dex I{Symbols, RefSlab(), Relations};
 
   std::vector<SymbolID> Results;
   RelationsRequest Req;
   Req.Subjects.insert(Parent.ID);
-  Req.Predicate = index::SymbolRole::RelationBaseOf;
+  Req.Predicate = RelationKind::BaseOf;
   I.relations(Req, [&](const SymbolID &Subject, const Symbol &Object) {
     Results.push_back(Object.ID);
   });
   EXPECT_THAT(Results, UnorderedElementsAre(Child1.ID, Child2.ID));
 }
 
 TEST(DexTest, PreferredTypesBoosting) {
   auto Sym1 = symbol("t1");

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

TEST(FileIndexTest, Relations) {
   auto AST = TU.build();
   FileIndex Index;
   Index.updatePreamble(TU.Filename, AST.getASTContext(),
                        AST.getPreprocessorPtr(), AST.getCanonicalIncludes());
   SymbolID A = findSymbol(TU.headerSymbols(), "A").ID;
   uint32_t Results = 0;
   RelationsRequest Req;
   Req.Subjects.insert(A);
-  Req.Predicate = index::SymbolRole::RelationBaseOf;
+  Req.Predicate = RelationKind::BaseOf;
   Index.relations(Req, [&](const SymbolID &, const Symbol &) { ++Results; });
   EXPECT_EQ(Results, 1u);
 }
 
 TEST(FileIndexTest, ReferencesInMainFileWithPreamble) {
   TestTU TU;
   TU.HeaderCode = "class Foo{};";
   Annotations Main(R"cpp(

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

 
 TEST(RelationSlab, Lookup) {
   SymbolID A{"A"};
   SymbolID B{"B"};
   SymbolID C{"C"};
   SymbolID D{"D"};
 
   RelationSlab::Builder Builder;
-  Builder.insert(Relation{A, index::SymbolRole::RelationBaseOf, B});
-  Builder.insert(Relation{A, index::SymbolRole::RelationBaseOf, C});
-  Builder.insert(Relation{B, index::SymbolRole::RelationBaseOf, D});
-  Builder.insert(Relation{C, index::SymbolRole::RelationBaseOf, D});
-  Builder.insert(Relation{B, index::SymbolRole::RelationChildOf, A});
-  Builder.insert(Relation{C, index::SymbolRole::RelationChildOf, A});
-  Builder.insert(Relation{D, index::SymbolRole::RelationChildOf, B});
-  Builder.insert(Relation{D, index::SymbolRole::RelationChildOf, C});
+  Builder.insert(Relation{A, RelationKind::BaseOf, B});
+  Builder.insert(Relation{A, RelationKind::BaseOf, C});
+  Builder.insert(Relation{B, RelationKind::BaseOf, D});
+  Builder.insert(Relation{C, RelationKind::BaseOf, D});
 
   RelationSlab Slab = std::move(Builder).build();
-  EXPECT_THAT(
-      Slab.lookup(A, index::SymbolRole::RelationBaseOf),
-      UnorderedElementsAre(Relation{A, index::SymbolRole::RelationBaseOf, B},
-                           Relation{A, index::SymbolRole::RelationBaseOf, C}));
+  EXPECT_THAT(Slab.lookup(A, RelationKind::BaseOf),
+              UnorderedElementsAre(Relation{A, RelationKind::BaseOf, B},
+                                   Relation{A, RelationKind::BaseOf, C}));
 }
 
 TEST(RelationSlab, Duplicates) {
   SymbolID A{"A"};
   SymbolID B{"B"};
   SymbolID C{"C"};
 
   RelationSlab::Builder Builder;
-  Builder.insert(Relation{A, index::SymbolRole::RelationBaseOf, B});
-  Builder.insert(Relation{A, index::SymbolRole::RelationBaseOf, C});
-  Builder.insert(Relation{A, index::SymbolRole::RelationBaseOf, B});
+  Builder.insert(Relation{A, RelationKind::BaseOf, B});
+  Builder.insert(Relation{A, RelationKind::BaseOf, C});
+  Builder.insert(Relation{A, RelationKind::BaseOf, B});
 
   RelationSlab Slab = std::move(Builder).build();
-  EXPECT_THAT(Slab, UnorderedElementsAre(
-                        Relation{A, index::SymbolRole::RelationBaseOf, B},
-                        Relation{A, index::SymbolRole::RelationBaseOf, C}));
+  EXPECT_THAT(Slab, UnorderedElementsAre(Relation{A, RelationKind::BaseOf, B},
+                                         Relation{A, RelationKind::BaseOf, C}));
 }
 
 TEST(SwapIndexTest, OldIndexRecycled) {
   auto Token = std::make_shared<int>();
   std::weak_ptr<int> WeakToken = Token;
 
   SwapIndex S(std::make_unique<MemIndex>(SymbolSlab(), RefSlab(),
                                           RelationSlab(), std::move(Token),

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

EXPECT_THAT(
                                 ::testing::SizeIs(1))));
   auto Ref1 = ParsedYAML->Refs->begin()->second.front();
   EXPECT_EQ(Ref1.Kind, RefKind::Reference);
   EXPECT_EQ(StringRef(Ref1.Location.FileURI), "file:///path/foo.cc");
 
   SymbolID Base = cantFail(SymbolID::fromStr("6481EE7AF2841756"));
   SymbolID Derived = cantFail(SymbolID::fromStr("6512AEC512EA3A2D"));
   ASSERT_TRUE(bool(ParsedYAML->Relations));
-  EXPECT_THAT(*ParsedYAML->Relations,
-              UnorderedElementsAre(
-                  Relation{Base, index::SymbolRole::RelationBaseOf, Derived}));
+  EXPECT_THAT(
+      *ParsedYAML->Relations,
+      UnorderedElementsAre(Relation{Base, RelationKind::BaseOf, Derived}));
 }
 
 std::vector<std::string> YAMLFromSymbols(const SymbolSlab &Slab) {
   std::vector<std::string> Result;
   for (const auto &Sym : Slab)
     Result.push_back(toYAML(Sym));
   return Result;
 }

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

TEST_F(SymbolCollectorTest, Relations) {
   std::string Header = R"(
   class Base {};
   class Derived : public Base {};
   )";
   runSymbolCollector(Header, /*Main=*/"");
   const Symbol &Base = findSymbol(Symbols, "Base");
   const Symbol &Derived = findSymbol(Symbols, "Derived");
   EXPECT_THAT(Relations,
-              Contains(Relation{Base.ID, index::SymbolRole::RelationBaseOf,
-                                Derived.ID}));
+              Contains(Relation{Base.ID, RelationKind::BaseOf, Derived.ID}));
 }
 
 TEST_F(SymbolCollectorTest, References) {
   const std::string Header = R"(
     class W;
     class X {};
     class Y;
     class Z {}; // not used anywhere

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

SymbolID findSymbolIDByName(SymbolIndex *Index, llvm::StringRef Name,
   EXPECT_TRUE(GotResult);
   return Result;
 }
 
 std::vector<SymbolID> collectSubtypes(SymbolID Subject, SymbolIndex *Index) {
   std::vector<SymbolID> Result;
   RelationsRequest Req;
   Req.Subjects.insert(Subject);
-  Req.Predicate = index::SymbolRole::RelationBaseOf;
+  Req.Predicate = RelationKind::BaseOf;
   Index->relations(Req,
                    [&Result](const SymbolID &Subject, const Symbol &Object) {
                      Result.push_back(Object.ID);
                    });
   return Result;
 }
 
 TEST(Subtypes, SimpleInheritance) {

llvm/include/llvm/ADT/DenseMapInfo.h

template<> struct DenseMapInfo<char> {
   static inline char getTombstoneKey() { return ~0 - 1; }
   static unsigned getHashValue(const char& Val) { return Val * 37U; }
 
   static bool isEqual(const char &LHS, const char &RHS) {
     return LHS == RHS;
   }
 };
 
+// Provide DenseMapInfo for unsigned chars.
+template <> struct DenseMapInfo<unsigned char> {
+  static inline unsigned char getEmptyKey() { return ~0; }
+  static inline unsigned char getTombstoneKey() { return ~0 - 1; }
+  static unsigned getHashValue(const unsigned char &Val) { return Val * 37U; }
+
+  static bool isEqual(const unsigned char &LHS, const unsigned char &RHS) {
+    return LHS == RHS;
+  }
+};
+
 // Provide DenseMapInfo for unsigned shorts.
 template <> struct DenseMapInfo<unsigned short> {
   static inline unsigned short getEmptyKey() { return 0xFFFF; }
   static inline unsigned short getTombstoneKey() { return 0xFFFF - 1; }
   static unsigned getHashValue(const unsigned short &Val) { return Val * 37U; }
 
   static bool isEqual(const unsigned short &LHS, const unsigned short &RHS) {
     return LHS == RHS;