[Support] Add support for the OF_Delete open flag on posix platforms

[zturner]

Summary

Previously this was documented as only making a difference on
Windows.  However, we can support this on all platform for
symmetry.  Although the semantics differ slightly, the important
part (i.e. the file should no longer exist after the descriptor
is closed) is supportable everywhere.  On Windows we do this
with FILE_FLAG_DELETE_ON_CLOSE, as we always have.  On Unixy
platforms, we do this by simply unlinking the file after it
has been opened.

[rnk]

lgtm

[echristo]

LGTM.

[zturner]

FWIW turns out this doesn't work as nicely as I thought it did. So I'm going to bench this one for now. createUniqueFile uses this flag, and there are several places in the codebase that assume they can refer to the path afterwords, which breaks here as this effectively makes an open unliked file on posix platforms. I'll think about the best way to handle this in the future, but it's not high priority right now.

llvm/include/llvm/Support/FileSystem.h

enum OpenFlags : unsigned {
   /// distinction.
   OF_Text = 1,
   F_Text = 1, // For compatibility
 
   /// The file should be opened in append mode.
   OF_Append = 2,
   F_Append = 2, // For compatibility
 
-  /// Delete the file on close. Only makes a difference on windows.
+  /// Delete the file on close.  This is guaranteed to be supported on all
+  /// platforms, and it is guaranteed that the file descriptor / file object
+  /// that is returned from the open call is valid and usable in the way the
+  /// user has requested.  However, it is **not** guaranteed that
+  /// exists(Path) will return true after the call to open returns.
   OF_Delete = 4
 };
 
 /// Create a uniquely named file.
 ///
 /// Generates a unique path suitable for a temporary file and then opens it as a
 /// file. The name is based on \a model with '%' replaced by a random char in
 /// [0-9a-f]. If \a model is not an absolute path, the temporary file will be

llvm/lib/Support/Unix/Path.inc

std::error_code openFile(const Twine &Name, int &ResultFD,
   if ((ResultFD = sys::RetryAfterSignal(-1, open, P.begin(), OpenFlags, Mode)) <
       0)
     return std::error_code(errno, std::generic_category());
 #ifndef O_CLOEXEC
   int r = fcntl(ResultFD, F_SETFD, FD_CLOEXEC);
   (void)r;
   assert(r == 0 && "fcntl(F_SETFD, FD_CLOEXEC) failed");
 #endif
+  if (Flags & OF_Delete)
+    ::unlink(P.data());
+
   return std::error_code();
 }
 
 Expected<int> openNativeFile(const Twine &Name, CreationDisposition Disp,
                              FileAccess Access, OpenFlags Flags,
                              unsigned Mode) {
 
   int FD;

llvm/unittests/Support/Path.cpp

TEST_F(FileSystemTest, ReadWriteFileCanReadOrWrite) {
   int FD;
   ASSERT_NO_ERROR(fs::openFileForReadWrite(NonExistantFile, FD,
                                            fs::CD_OpenExisting, fs::OF_None));
   FileDescriptorCloser Closer(FD);
   verifyRead(FD, "Fizz", true);
   verifyWrite(FD, "Buzz", true);
 }
 
+TEST_F(FileSystemTest, DeleteOnClose) {
+  createFileWithData(NonExistantFile, false, fs::CD_CreateNew, "Fizz");
+
+  // Even though we expect the file to be deleted automatically on close, we put
+  // this here as a failsafe so it gets removed even if the test fails, so we
+  // don't clutter up a file system.
+  FileRemover Cleanup(NonExistantFile);
+
+  int FD;
+  Optional<FileDescriptorCloser> Closer;
+
+  ASSERT_NO_ERROR(fs::openFileForReadWrite(NonExistantFile, FD,
+                                           fs::CD_OpenExisting, fs::OF_Delete));
+  Closer.emplace(FD);
+  verifyRead(FD, "Fizz", true);
+  verifyWrite(FD, "Buzz", true);
+  Closer.reset();
+  ASSERT_FALSE(fs::exists(NonExistantFile));
+}
+
 TEST_F(FileSystemTest, set_current_path) {
   SmallString<128> path;
 
   ASSERT_NO_ERROR(fs::current_path(path));
   ASSERT_NE(TestDirectory, path);
 
   struct RestorePath {
     SmallString<128> path;