[clang] Implement `PointerLikeTraits` for `{File,Directory}EntryRef`

[jansvoboda11]

Summary

This patch implements llvm::PointerLikeTraits<FileEntryRef> and llvm::PointerLikeTraits<DirectoryEntryRef>, allowing some simplifications around umbrella header/directory code.

[jansvoboda11]

Note that this enables usage of {File,Directory}EntryRef in other containers using PointerLikeTraits such as SmallPtrSet.

[benlangmuir]

clang/include/clang/Basic/DirectoryEntry.h

211

I suggest not hard-coding it if you can get away with it; maybe PointerLikeTypeTraits<clang::DirectoryEntryRef::MapEntry *>::NumLowBitsAvailable? I think 3 could be wrong on a 32-bit platform for example.

[jansvoboda11]

Forward NumLowBitsAvailable to PointerLikeTypeTraits of the underlying pointer.

[jansvoboda11]

clang/include/clang/Basic/DirectoryEntry.h

211

Good idea, updated.

[benlangmuir]

Thanks!

clang/include/clang/Basic/DirectoryEntry.h

public:
   using MapEntry = llvm::StringMapEntry<llvm::ErrorOr<DirectoryEntry &>>;
 
   const MapEntry &getMapEntry() const { return *ME; }
 
   /// Check if RHS referenced the file in exactly the same way.
   bool isSameRef(DirectoryEntryRef RHS) const { return ME == RHS.ME; }
 
   DirectoryEntryRef() = delete;
-  DirectoryEntryRef(const MapEntry &ME) : ME(&ME) {}
+  explicit DirectoryEntryRef(const MapEntry &ME) : ME(&ME) {}
 
   /// Allow DirectoryEntryRef to degrade into 'const DirectoryEntry*' to
   /// facilitate incremental adoption.
   ///
   /// The goal is to avoid code churn due to dances like the following:
   /// \code
   /// // Old code.
   /// lvalue = rvalue;

 
 static_assert(std::is_trivially_copyable<OptionalDirectoryEntryRef>::value,
               "OptionalDirectoryEntryRef should be trivially copyable");
 
 } // end namespace optional_detail
 } // namespace clang
 
 namespace llvm {
+
+template <> struct PointerLikeTypeTraits<clang::DirectoryEntryRef> {
+  static inline void *getAsVoidPointer(clang::DirectoryEntryRef Dir) {
+    return const_cast<clang::DirectoryEntryRef::MapEntry *>(&Dir.getMapEntry());
+  }
+
+  static inline clang::DirectoryEntryRef getFromVoidPointer(void *Ptr) {
+    return clang::DirectoryEntryRef(
+        *reinterpret_cast<const clang::DirectoryEntryRef::MapEntry *>(Ptr));
+  }
+
+  static constexpr int NumLowBitsAvailable = PointerLikeTypeTraits<
+      const clang::DirectoryEntryRef::MapEntry *>::NumLowBitsAvailable;
+};
+
 /// Specialisation of DenseMapInfo for DirectoryEntryRef.
 template <> struct DenseMapInfo<clang::DirectoryEntryRef> {
   static inline clang::DirectoryEntryRef getEmptyKey() {
     return clang::DirectoryEntryRef(
         clang::DirectoryEntryRef::dense_map_empty_tag());
   }
 
   static inline clang::DirectoryEntryRef getTombstoneKey() {

clang/include/clang/Basic/FileEntry.h

 
 static_assert(std::is_trivially_copyable<OptionalFileEntryRef>::value,
               "OptionalFileEntryRef should be trivially copyable");
 
 } // end namespace optional_detail
 } // namespace clang
 
 namespace llvm {
+
+template <> struct PointerLikeTypeTraits<clang::FileEntryRef> {
+  static inline void *getAsVoidPointer(clang::FileEntryRef File) {
+    return const_cast<clang::FileEntryRef::MapEntry *>(&File.getMapEntry());
+  }
+
+  static inline clang::FileEntryRef getFromVoidPointer(void *Ptr) {
+    return clang::FileEntryRef(
+        *reinterpret_cast<const clang::FileEntryRef::MapEntry *>(Ptr));
+  }
+
+  static constexpr int NumLowBitsAvailable = PointerLikeTypeTraits<
+      const clang::FileEntryRef::MapEntry *>::NumLowBitsAvailable;
+};
+
 /// Specialisation of DenseMapInfo for FileEntryRef.
 template <> struct DenseMapInfo<clang::FileEntryRef> {
   static inline clang::FileEntryRef getEmptyKey() {
     return clang::FileEntryRef(clang::FileEntryRef::dense_map_empty_tag());
   }
 
   static inline clang::FileEntryRef getTombstoneKey() {
     return clang::FileEntryRef(clang::FileEntryRef::dense_map_tombstone_tag());

clang/include/clang/Basic/Module.h

public:
   /// are found.
   OptionalDirectoryEntryRefDegradesToDirectoryEntryPtr Directory;
 
   /// The presumed file name for the module map defining this module.
   /// Only non-empty when building from preprocessed source.
   std::string PresumedModuleMapFile;
 
   /// The umbrella header or directory.
-  llvm::PointerUnion<const FileEntryRef::MapEntry *,
-                     const DirectoryEntryRef::MapEntry *>
-      Umbrella;
+  llvm::PointerUnion<FileEntryRef, DirectoryEntryRef> Umbrella;
 
   /// The module signature.
   ASTFileSignature Signature;
 
   /// The name of the umbrella entry, as written in the module map.
   std::string UmbrellaAsWritten;
 
   // The path to the umbrella entry relative to the root module's \c Directory.
public:
   /// Set the serialized AST file for the top-level module of this module.
   void setASTFile(OptionalFileEntryRef File) {
     assert((!getASTFile() || getASTFile() == File) && "file path changed");
     getTopLevelModule()->ASTFile = File;
   }
 
   /// Retrieve the umbrella directory as written.
   std::optional<DirectoryName> getUmbrellaDirAsWritten() const {
-    if (const auto *ME =
-            Umbrella.dyn_cast<const DirectoryEntryRef::MapEntry *>())
+    if (Umbrella && Umbrella.is<DirectoryEntryRef>())
       return DirectoryName{UmbrellaAsWritten,
                            UmbrellaRelativeToRootModuleDirectory,
-                           DirectoryEntryRef(*ME)};
+                           Umbrella.get<DirectoryEntryRef>()};
     return std::nullopt;
   }
 
   /// Retrieve the umbrella header as written.
   std::optional<Header> getUmbrellaHeaderAsWritten() const {
-    if (const auto *ME = Umbrella.dyn_cast<const FileEntryRef::MapEntry *>())
+    if (Umbrella && Umbrella.is<FileEntryRef>())
       return Header{UmbrellaAsWritten, UmbrellaRelativeToRootModuleDirectory,
-                    FileEntryRef(*ME)};
+                    Umbrella.get<FileEntryRef>()};
     return std::nullopt;
   }
 
   /// Get the effective umbrella directory for this module: either the one
   /// explicitly written in the module map file, or the parent of the umbrella
   /// header.
   OptionalDirectoryEntryRef getEffectiveUmbrellaDir() const;
 

clang/lib/Basic/Module.cpp

for (const Module *M = this; M; M = M->Parent) {
     if (nameParts.empty() || M->Name != nameParts.back())
       return false;
     nameParts = nameParts.drop_back();
   }
   return nameParts.empty();
 }
 
 OptionalDirectoryEntryRef Module::getEffectiveUmbrellaDir() const {
-  if (const auto *ME = Umbrella.dyn_cast<const FileEntryRef::MapEntry *>())
-    return FileEntryRef(*ME).getDir();
-  if (const auto *ME = Umbrella.dyn_cast<const DirectoryEntryRef::MapEntry *>())
-    return DirectoryEntryRef(*ME);
+  if (Umbrella && Umbrella.is<FileEntryRef>())
+    return Umbrella.get<FileEntryRef>().getDir();
+  if (Umbrella && Umbrella.is<DirectoryEntryRef>())
+    return Umbrella.get<DirectoryEntryRef>();
   return std::nullopt;
 }
 
 void Module::addTopHeader(FileEntryRef File) {
   assert(File);
   TopHeaders.insert(File);
 }
 

clang/lib/Lex/ModuleMap.cpp

Module *ModuleMap::createShadowedModule(StringRef Name, bool IsFramework,
 
   return Result;
 }
 
 void ModuleMap::setUmbrellaHeaderAsWritten(
     Module *Mod, FileEntryRef UmbrellaHeader, const Twine &NameAsWritten,
     const Twine &PathRelativeToRootModuleDirectory) {
   Headers[UmbrellaHeader].push_back(KnownHeader(Mod, NormalHeader));
-  Mod->Umbrella = &UmbrellaHeader.getMapEntry();
+  Mod->Umbrella = UmbrellaHeader;
   Mod->UmbrellaAsWritten = NameAsWritten.str();
   Mod->UmbrellaRelativeToRootModuleDirectory =
       PathRelativeToRootModuleDirectory.str();
   UmbrellaDirs[UmbrellaHeader.getDir()] = Mod;
 
   // Notify callbacks that we just added a new header.
   for (const auto &Cb : Callbacks)
     Cb->moduleMapAddUmbrellaHeader(UmbrellaHeader);
 }
 
 void ModuleMap::setUmbrellaDirAsWritten(
     Module *Mod, DirectoryEntryRef UmbrellaDir, const Twine &NameAsWritten,
     const Twine &PathRelativeToRootModuleDirectory) {
-  Mod->Umbrella = &UmbrellaDir.getMapEntry();
+  Mod->Umbrella = UmbrellaDir;
   Mod->UmbrellaAsWritten = NameAsWritten.str();
   Mod->UmbrellaRelativeToRootModuleDirectory =
       PathRelativeToRootModuleDirectory.str();
   UmbrellaDirs[UmbrellaDir] = Mod;
 }
 
 void ModuleMap::addUnresolvedHeader(Module *Mod,
                                     Module::UnresolvedHeaderDirective Header,