[FileCollector] add support for recording empty directories

[arphaman]

Summary

The file collector class is useful for constructing reproducers by creating a snapshot of the files that are accessed. Sometimes it might also be important to construct directories that don't necessarily have files, but are still accessed by some tool that we want to make a reproducer for. This is useful for instance for modeling the behavior of Clang's header search, which scans through a number of directories it doesn't actually access when looking for framework headers. This patch extends the file collector to allow it to work with paths that are just directories, by constructing them as the files are copied over.

[JDevlieghere]

LGTM!

llvm/lib/Support/FileCollector.cpp

151 ↗

(On Diff #211804)

Spurious newline?

llvm/trunk/lib/Support/FileCollector.cpp

for (auto &entry : VFSWriter.getMappings()) {
     // Create directory tree.
     if (std::error_code EC =
             sys::fs::create_directories(sys::path::parent_path(entry.RPath),
                                         /*IgnoreExisting=*/true)) {
       if (StopOnError)
         return EC;
     }
 
+    // Get the status of the original file/directory.
+    sys::fs::file_status Stat;
+    if (std::error_code EC = sys::fs::status(entry.VPath, Stat)) {
+      if (StopOnError)
+        return EC;
+      continue;
+    }
+
+    if (Stat.type() == sys::fs::file_type::directory_file) {
+      // Construct a directory when it's just a directory entry.
+      if (std::error_code EC =
+              sys::fs::create_directories(entry.RPath,
+                                          /*IgnoreExisting=*/true)) {
+        if (StopOnError)
+          return EC;
+      }
+      continue;
+    }
+
     // Copy file over.
     if (std::error_code EC = sys::fs::copy_file(entry.VPath, entry.RPath)) {
       if (StopOnError)
         return EC;
     }
 
     // Copy over permissions.
     if (auto perms = sys::fs::getPermissions(entry.VPath)) {
       if (std::error_code EC = sys::fs::setPermissions(entry.RPath, *perms)) {
         if (StopOnError)
           return EC;
       }
     }
 
     // Copy over modification time.
-    sys::fs::file_status Stat;
-    if (std::error_code EC = sys::fs::status(entry.VPath, Stat)) {
-      if (StopOnError)
-        return EC;
-      continue;
-    }
     copyAccessAndModificationTime(entry.RPath, Stat);
   }
   return {};
 }
 
 std::error_code FileCollector::writeMapping(StringRef mapping_file) {
   std::lock_guard<std::mutex> lock(Mutex);
 

llvm/trunk/unittests/Support/FileCollectorTest.cpp

TEST(FileCollectorTest, copyFiles) {
   ec = FileCollector.copyFiles(true);
   EXPECT_TRUE(ec);
 
   // However, if stop_on_error is true the copy should still succeed.
   ec = FileCollector.copyFiles(false);
   EXPECT_FALSE(ec);
 }
 
+TEST(FileCollectorTest, recordAndConstructDirectory) {
+  ScopedDir file_root("dir_root", true);
+  ScopedDir subdir(file_root + "/subdir");
+  ScopedDir subdir2(file_root + "/subdir2");
+  ScopedFile a(subdir2 + "/a");
+
+  // Create file collector and add files.
+  ScopedDir root("copy_files_root", true);
+  std::string root_fs = root.Path.str();
+  TestingFileCollector FileCollector(root_fs, root_fs);
+  FileCollector.addFile(a.Path);
+
+  // The empty directory isn't seen until we add it.
+  EXPECT_TRUE(FileCollector.hasSeen(a.Path));
+  EXPECT_FALSE(FileCollector.hasSeen(subdir.Path));
+
+  FileCollector.addFile(subdir.Path);
+  EXPECT_TRUE(FileCollector.hasSeen(subdir.Path));
+
+  // Make sure we can construct the directory.
+  std::error_code ec = FileCollector.copyFiles(true);
+  EXPECT_FALSE(ec);
+  bool IsDirectory = false;
+  llvm::SmallString<128> SubdirInRoot = root.Path;
+  llvm::sys::path::append(SubdirInRoot,
+                          llvm::sys::path::relative_path(subdir.Path));
+  ec = sys::fs::is_directory(SubdirInRoot, IsDirectory);
+  EXPECT_FALSE(ec);
+  ASSERT_TRUE(IsDirectory);
+}
+
 #ifndef _WIN32
 TEST(FileCollectorTest, Symlinks) {
   // Root where the original files live.
   ScopedDir file_root("file_root", true);
 
   // Create some files in the file root.
   ScopedFile a(file_root + "/aaa");
   ScopedFile b(file_root + "/bbb");