[clang][cas] Move IncludeFile[List] to IncludeTree::File[List] NFC

(cherry picked from commit 7caa9d9)

Author: benlangmuir

clang/include/clang/CAS/IncludeTree.h

@@ -39,14 +39,9 @@ template <typename NodeT> class IncludeTreeBase : public ObjectProxy {
     return Node.getData().startswith(NodeT::getNodeKind());
   }
 
-  friend class IncludeFile;
-  friend class IncludeFileList;
-  friend class IncludeTree;
-  friend class IncludeTreeRoot;
+  friend NodeT;
 };
 
-class IncludeFile;
-
 /// Represents a DAG of included files by the preprocessor.
 /// Each node in the DAG represents a particular inclusion of a file that
 /// encompasses inclusions of other files as sub-trees, along with all the
@@ -56,7 +51,10 @@ class IncludeTree : public IncludeTreeBase<IncludeTree> {
 public:
   static constexpr StringRef getNodeKind() { return "Tree"; }
 
-  Expected<IncludeFile> getBaseFile();
+  class File;
+  class FileList;
+
+  Expected<File> getBaseFile();
 
   /// The include file that resulted in this include-tree.
   ObjectRef getBaseFileRef() const { return getReference(0); }
@@ -152,7 +150,7 @@ class IncludeTree : public IncludeTreeBase<IncludeTree> {
 
 /// Represents a \p SourceManager file (or buffer in the case of preprocessor
 /// predefines) that got included by the preprocessor.
-class IncludeFile : public IncludeTreeBase<IncludeFile> {
+class IncludeTree::File : public IncludeTreeBase<File> {
 public:
   static constexpr StringRef getNodeKind() { return "File"; }
 
@@ -167,7 +165,7 @@ class IncludeFile : public IncludeTreeBase<IncludeFile> {
     return getCAS().getProxy(getContentsRef());
   }
 
-  Expected<IncludeTree::FileInfo> getFileInfo() {
+  Expected<FileInfo> getFileInfo() {
     auto Filename = getFilename();
     if (!Filename)
       return Filename.takeError();
@@ -177,8 +175,8 @@ class IncludeFile : public IncludeTreeBase<IncludeFile> {
     return IncludeTree::FileInfo{Filename->getData(), Contents->getData()};
   }
 
-  static Expected<IncludeFile> create(ObjectStore &DB, StringRef Filename,
-                                      ObjectRef Contents);
+  static Expected<File> create(ObjectStore &DB, StringRef Filename,
+                               ObjectRef Contents);
 
   llvm::Error print(llvm::raw_ostream &OS, unsigned Indent = 0);
 
@@ -198,20 +196,20 @@ class IncludeFile : public IncludeTreeBase<IncludeFile> {
   }
 
 private:
-  friend class IncludeTreeBase<IncludeFile>;
-  friend class IncludeFileList;
+  friend class IncludeTreeBase<File>;
+  friend class FileList;
   friend class IncludeTree;
   friend class IncludeTreeRoot;
 
-  explicit IncludeFile(ObjectProxy Node) : IncludeTreeBase(std::move(Node)) {
+  explicit File(ObjectProxy Node) : IncludeTreeBase(std::move(Node)) {
     assert(isValid(*this));
   }
 };
 
-/// A flat list of \p IncludeFile entries. This is used along with a simple
+/// A flat list of \c File entries. This is used along with a simple
 /// implementation of a \p vfs::FileSystem produced via
 /// \p createIncludeTreeFileSystem().
-class IncludeFileList : public IncludeTreeBase<IncludeFileList> {
+class IncludeTree::FileList : public IncludeTreeBase<FileList> {
 public:
   static constexpr StringRef getNodeKind() { return "List"; }
 
@@ -224,12 +222,12 @@ class IncludeFileList : public IncludeTreeBase<IncludeFileList> {
     return getReference(I);
   }
 
-  Expected<IncludeFile> getFile(size_t I) { return getFile(getFileRef(I)); }
+  Expected<File> getFile(size_t I) { return getFile(getFileRef(I)); }
   FileSizeTy getFileSize(size_t I) const;
 
-  /// \returns each \p IncludeFile entry along with its file size.
-  llvm::Error forEachFile(
-      llvm::function_ref<llvm::Error(IncludeFile, FileSizeTy)> Callback);
+  /// \returns each \c File entry along with its file size.
+  llvm::Error
+  forEachFile(llvm::function_ref<llvm::Error(File, FileSizeTy)> Callback);
 
   /// We record the file size as well to avoid needing to materialize the
   /// underlying buffer for the \p IncludeTreeFileSystem::status()
@@ -238,27 +236,25 @@ class IncludeFileList : public IncludeTreeBase<IncludeFileList> {
     ObjectRef FileRef;
     FileSizeTy Size;
   };
-  static Expected<IncludeFileList> create(ObjectStore &DB,
-                                          ArrayRef<FileEntry> Files);
+  static Expected<FileList> create(ObjectStore &DB, ArrayRef<FileEntry> Files);
 
-  static Expected<IncludeFileList> get(ObjectStore &CAS, ObjectRef Ref);
+  static Expected<FileList> get(ObjectStore &CAS, ObjectRef Ref);
 
   llvm::Error print(llvm::raw_ostream &OS, unsigned Indent = 0);
 
 private:
-  friend class IncludeTreeBase<IncludeFileList>;
+  friend class IncludeTreeBase<FileList>;
   friend class IncludeTreeRoot;
 
-  explicit IncludeFileList(ObjectProxy Node)
-      : IncludeTreeBase(std::move(Node)) {
+  explicit FileList(ObjectProxy Node) : IncludeTreeBase(std::move(Node)) {
     assert(isValid(*this));
   }
 
-  Expected<IncludeFile> getFile(ObjectRef Ref) {
+  Expected<File> getFile(ObjectRef Ref) {
     auto Node = getCAS().getProxy(Ref);
     if (!Node)
       return Node.takeError();
-    return IncludeFile(std::move(*Node));
+    return File(std::move(*Node));
   }
 
   static bool isValid(const ObjectProxy &Node);
@@ -294,11 +290,11 @@ class IncludeTreeRoot : public IncludeTreeBase<IncludeTreeRoot> {
     return IncludeTree(std::move(*Node));
   }
 
-  Expected<IncludeFileList> getFileList() {
+  Expected<IncludeTree::FileList> getFileList() {
     auto Node = getCAS().getProxy(getFileListRef());
     if (!Node)
       return Node.takeError();
-    return IncludeFileList(std::move(*Node));
+    return IncludeTree::FileList(std::move(*Node));
   }
 
   Expected<std::optional<StringRef>> getPCHBuffer() {

clang/lib/CAS/IncludeTree.cpp

@@ -33,20 +33,21 @@ Expected<NodeT> IncludeTreeBase<NodeT>::create(ObjectStore &DB,
   return NodeT(*Proxy);
 }
 
-Expected<IncludeFile> IncludeFile::create(ObjectStore &DB, StringRef Filename,
-                                          ObjectRef Contents) {
+Expected<IncludeTree::File> IncludeTree::File::create(ObjectStore &DB,
+                                                      StringRef Filename,
+                                                      ObjectRef Contents) {
   auto PathRef = DB.storeFromString({}, Filename);
   if (!PathRef)
     return PathRef.takeError();
   std::array<ObjectRef, 2> Refs{*PathRef, Contents};
   return IncludeTreeBase::create(DB, Refs, {});
 }
 
-Expected<IncludeFile> IncludeTree::getBaseFile() {
+Expected<IncludeTree::File> IncludeTree::getBaseFile() {
   auto Node = getCAS().getProxy(getBaseFileRef());
   if (!Node)
     return Node.takeError();
-  return IncludeFile(std::move(*Node));
+  return File(std::move(*Node));
 }
 
 Expected<IncludeTree::FileInfo> IncludeTree::getBaseFileInfo() {
@@ -85,7 +86,7 @@ Expected<IncludeTree> IncludeTree::create(
 
   char Kind = FileCharacteristic;
   assert(Kind == FileCharacteristic && "SrcMgr::CharacteristicKind too big!");
-  assert(IncludeFile::isValid(DB, BaseFile));
+  assert(File::isValid(DB, BaseFile));
   SmallVector<ObjectRef, 16> Refs;
   Refs.reserve(Includes.size() + 1);
   Refs.push_back(BaseFile);
@@ -169,16 +170,17 @@ bool IncludeTree::isValid(const ObjectProxy &Node) {
   return Base.getData().size() >= NumIncludes * sizeof(uint32_t) + 1;
 }
 
-IncludeFileList::FileSizeTy IncludeFileList::getFileSize(size_t I) const {
+IncludeTree::FileList::FileSizeTy
+IncludeTree::FileList::getFileSize(size_t I) const {
   assert(I < getNumFiles());
   StringRef Data = getData();
   assert(Data.size() >= (I + 1) * sizeof(FileSizeTy));
   return llvm::support::endian::read<FileSizeTy, llvm::support::little>(
       Data.data() + I * sizeof(FileSizeTy));
 }
 
-llvm::Error IncludeFileList::forEachFile(
-    llvm::function_ref<llvm::Error(IncludeFile, FileSizeTy)> Callback) {
+llvm::Error IncludeTree::FileList::forEachFile(
+    llvm::function_ref<llvm::Error(File, FileSizeTy)> Callback) {
   size_t I = 0;
   return forEachReference([&](ObjectRef Ref) -> llvm::Error {
     auto Include = getFile(Ref);
@@ -188,8 +190,8 @@ llvm::Error IncludeFileList::forEachFile(
   });
 }
 
-Expected<IncludeFileList> IncludeFileList::create(ObjectStore &DB,
-                                                  ArrayRef<FileEntry> Files) {
+Expected<IncludeTree::FileList>
+IncludeTree::FileList::create(ObjectStore &DB, ArrayRef<FileEntry> Files) {
   SmallVector<ObjectRef, 16> Refs;
   Refs.reserve(Files.size());
   SmallString<256> Buffer;
@@ -199,24 +201,25 @@ Expected<IncludeFileList> IncludeFileList::create(ObjectStore &DB,
   llvm::support::endian::Writer Writer(BufOS, llvm::support::little);
 
   for (const FileEntry &Entry : Files) {
-    assert(IncludeFile::isValid(DB, Entry.FileRef));
+    assert(File::isValid(DB, Entry.FileRef));
     Refs.push_back(Entry.FileRef);
     Writer.write(Entry.Size);
   }
   return IncludeTreeBase::create(DB, Refs, Buffer);
 }
 
-Expected<IncludeFileList> IncludeFileList::get(ObjectStore &DB, ObjectRef Ref) {
+Expected<IncludeTree::FileList> IncludeTree::FileList::get(ObjectStore &DB,
+                                                           ObjectRef Ref) {
   auto Node = DB.getProxy(Ref);
   if (!Node)
     return Node.takeError();
   if (!isValid(*Node))
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "not a IncludeFileList node kind");
-  return IncludeFileList(std::move(*Node));
+  return FileList(std::move(*Node));
 }
 
-bool IncludeFileList::isValid(const ObjectProxy &Node) {
+bool IncludeTree::FileList::isValid(const ObjectProxy &Node) {
   if (!IncludeTreeBase::isValid(Node))
     return false;
   IncludeTreeBase Base(Node);
@@ -229,7 +232,7 @@ Expected<IncludeTreeRoot>
 IncludeTreeRoot::create(ObjectStore &DB, ObjectRef MainFileTree,
                         ObjectRef FileList, std::optional<ObjectRef> PCHRef) {
   assert(IncludeTree::isValid(DB, MainFileTree));
-  assert(IncludeFileList::isValid(DB, FileList));
+  assert(IncludeTree::FileList::isValid(DB, FileList));
   if (PCHRef) {
     return IncludeTreeBase::create(DB, {MainFileTree, FileList, *PCHRef}, {});
   } else {
@@ -247,7 +250,7 @@ Expected<IncludeTreeRoot> IncludeTreeRoot::get(ObjectStore &DB, ObjectRef Ref) {
   return IncludeTreeRoot(std::move(*Node));
 }
 
-llvm::Error IncludeFile::print(llvm::raw_ostream &OS, unsigned Indent) {
+llvm::Error IncludeTree::File::print(llvm::raw_ostream &OS, unsigned Indent) {
   auto Filename = getFilename();
   if (!Filename)
     return Filename.takeError();
@@ -281,8 +284,9 @@ llvm::Error IncludeTree::print(llvm::raw_ostream &OS, unsigned Indent) {
       });
 }
 
-llvm::Error IncludeFileList::print(llvm::raw_ostream &OS, unsigned Indent) {
-  return forEachFile([&](cas::IncludeFile File, FileSizeTy) -> llvm::Error {
+llvm::Error IncludeTree::FileList::print(llvm::raw_ostream &OS,
+                                         unsigned Indent) {
+  return forEachFile([&](File File, FileSizeTy) -> llvm::Error {
     return File.print(OS, Indent);
   });
 }
@@ -299,7 +303,7 @@ llvm::Error IncludeTreeRoot::print(llvm::raw_ostream &OS, unsigned Indent) {
   if (llvm::Error E = MainTree->print(OS.indent(Indent), Indent))
     return E;
   OS.indent(Indent) << "Files:\n";
-  std::optional<cas::IncludeFileList> List;
+  std::optional<IncludeTree::FileList> List;
   if (llvm::Error E = getFileList().moveInto(List))
     return E;
   return List->print(OS, Indent);
@@ -347,7 +351,7 @@ class IncludeTreeFileSystem : public llvm::vfs::FileSystem {
 
   struct FileEntry {
     cas::ObjectRef ContentsRef;
-    IncludeFileList::FileSizeTy Size;
+    IncludeTree::FileList::FileSizeTy Size;
     llvm::sys::fs::UniqueID UniqueID;
   };
 
@@ -450,7 +454,8 @@ cas::createIncludeTreeFileSystem(IncludeTreeRoot &Root) {
   IntrusiveRefCntPtr<IncludeTreeFileSystem> IncludeTreeFS =
       new IncludeTreeFileSystem(Root.getCAS());
   llvm::Error E = FileList->forEachFile(
-      [&](IncludeFile File, IncludeFileList::FileSizeTy Size) -> llvm::Error {
+      [&](IncludeTree::File File,
+          IncludeTree::FileList::FileSizeTy Size) -> llvm::Error {
         auto FilenameBlob = File.getFilename();
         if (!FilenameBlob)
           return FilenameBlob.takeError();

clang/lib/Tooling/DependencyScanning/IncludeTreeActionController.cpp

@@ -97,8 +97,8 @@ class IncludeTreeBuilder {
   Expected<cas::ObjectRef> getObjectForBuffer(const SrcMgr::FileInfo &FI);
   Expected<cas::ObjectRef> addToFileList(FileManager &FM, const FileEntry *FE);
   Expected<cas::IncludeTree> getCASTreeForFileIncludes(FilePPState &&PPState);
-  Expected<cas::IncludeFile> createIncludeFile(StringRef Filename,
-                                               cas::ObjectRef Contents);
+  Expected<cas::IncludeTree::File> createIncludeFile(StringRef Filename,
+                                                     cas::ObjectRef Contents);
 
   bool hasErrorOccurred() const { return ErrorToReport.has_value(); }
 
@@ -120,7 +120,7 @@ class IncludeTreeBuilder {
   // are recorded in the PCH, ordered by \p FileEntry::UID index.
   SmallVector<StringRef> PreIncludedFileNames;
   llvm::BitVector SeenIncludeFiles;
-  SmallVector<cas::IncludeFileList::FileEntry> IncludedFiles;
+  SmallVector<cas::IncludeTree::FileList::FileEntry> IncludedFiles;
   std::optional<cas::ObjectRef> PredefinesBufferRef;
   std::optional<cas::ObjectRef> ModuleIncludesBufferRef;
   std::optional<cas::ObjectRef> ModuleMapFileRef;
@@ -447,7 +447,7 @@ IncludeTreeBuilder::finishIncludeTree(CompilerInstance &ScanInstance,
       getCASTreeForFileIncludes(IncludeStack.pop_back_val());
   if (!MainIncludeTree)
     return MainIncludeTree.takeError();
-  auto FileList = cas::IncludeFileList::create(DB, IncludedFiles);
+  auto FileList = cas::IncludeTree::FileList::create(DB, IncludedFiles);
   if (!FileList)
     return FileList.takeError();
 
@@ -509,7 +509,8 @@ IncludeTreeBuilder::getObjectForBuffer(const SrcMgr::FileInfo &FI) {
       {}, FI.getContentCache().getBufferIfLoaded()->getBuffer());
   if (!Ref)
     return Ref.takeError();
-  Expected<cas::IncludeFile> FileNode = createIncludeFile(FI.getName(), *Ref);
+  Expected<cas::IncludeTree::File> FileNode =
+      createIncludeFile(FI.getName(), *Ref);
   if (!FileNode)
     return FileNode.takeError();
   return FileNode->getRef();
@@ -531,7 +532,7 @@ IncludeTreeBuilder::addToFileList(FileManager &FM, const FileEntry *FE) {
       return FileNode.takeError();
     IncludedFiles.push_back(
         {FileNode->getRef(),
-         static_cast<cas::IncludeFileList::FileSizeTy>(FE->getSize())});
+         static_cast<cas::IncludeTree::FileList::FileSizeTy>(FE->getSize())});
     return FileNode->getRef();
   };
 
@@ -554,15 +555,15 @@ IncludeTreeBuilder::getCASTreeForFileIncludes(FilePPState &&PPState) {
                                   PPState.Includes, PPState.HasIncludeChecks);
 }
 
-Expected<cas::IncludeFile>
+Expected<cas::IncludeTree::File>
 IncludeTreeBuilder::createIncludeFile(StringRef Filename,
                                       cas::ObjectRef Contents) {
   SmallString<256> MappedPath;
   if (!PrefixMapper.empty()) {
     PrefixMapper.map(Filename, MappedPath);
     Filename = MappedPath;
   }
-  return cas::IncludeFile::create(DB, Filename, std::move(Contents));
+  return cas::IncludeTree::File::create(DB, Filename, std::move(Contents));
 }
 
 std::unique_ptr<DependencyActionController>