Replace platform-dependent `stat` with `llvm::sys::fs::status`. NFC intended.

[vsapsai]

The plan is to instrument llvm::sys::fs::status with ALWAYS_ENABLED_STATITSTIC to be able to catch regressions causing lots of stat calls. That's why replacing current stat calls. And it seems to be a good change regardless of future plans.

[sammccall]

Watching for regressions in stat calls sounds really useful.

This change is trivially equivalent on linux, but the code path is quite different on windows (I have no idea how ::stat works on windows, but our implementation of fs::status does lots of things).
I don't imagine it'll matter here though, and the original commits don't seem to have avoided fs::status on purpose.

[vsapsai]

Thanks for the review! If fs::status behaviour is sufficiently different on Windows, it is worth fixing because I believe majority of non-Windows developers expect them to work in the same way.

clang/lib/Frontend/CompilerInstance.cpp

 #include "llvm/Support/LockFileManager.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
-#include <sys/stat.h>
-#include <system_error>
 #include <time.h>
 #include <utility>
 
 using namespace clang;
 
 CompilerInstance::CompilerInstance(
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     InMemoryModuleCache *SharedModuleCache)

 static void writeTimestampFile(StringRef TimestampFile) {
   std::error_code EC;
   llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::OF_None);
 }
 
 /// Prune the module cache of modules that haven't been accessed in
 /// a long time.
 static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
-  struct stat StatBuf;
+  llvm::sys::fs::file_status StatBuf;
   llvm::SmallString<128> TimestampFile;
   TimestampFile = HSOpts.ModuleCachePath;
   assert(!TimestampFile.empty());
   llvm::sys::path::append(TimestampFile, "modules.timestamp");
 
   // Try to stat() the timestamp file.
-  if (::stat(TimestampFile.c_str(), &StatBuf)) {
+  if (std::error_code EC = llvm::sys::fs::status(TimestampFile, StatBuf)) {
     // If the timestamp file wasn't there, create one now.
-    if (errno == ENOENT) {
+    if (EC == std::errc::no_such_file_or_directory) {
       writeTimestampFile(TimestampFile);
     }
     return;
   }
 
   // Check whether the time stamp is older than our pruning interval.
   // If not, do nothing.
-  time_t TimeStampModTime = StatBuf.st_mtime;
+  time_t TimeStampModTime =
+      llvm::sys::toTimeT(StatBuf.getLastModificationTime());
   time_t CurrentTime = time(nullptr);
   if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
     return;
 
   // Write a new timestamp file so that nobody else attempts to prune.
   // There is a benign race condition here, if two Clang instances happen to
   // notice at the same time that the timestamp is out-of-date.
   writeTimestampFile(TimestampFile);
for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
       // We only care about module and global module index files.
       StringRef Extension = llvm::sys::path::extension(File->path());
       if (Extension != ".pcm" && Extension != ".timestamp" &&
           llvm::sys::path::filename(File->path()) != "modules.idx")
         continue;
 
       // Look at this file. If we can't stat it, there's nothing interesting
       // there.
-      if (::stat(File->path().c_str(), &StatBuf))
+      if (llvm::sys::fs::status(File->path(), StatBuf))
         continue;
 
       // If the file has been used recently enough, leave it there.
-      time_t FileAccessTime = StatBuf.st_atime;
+      time_t FileAccessTime = llvm::sys::toTimeT(StatBuf.getLastAccessedTime());
       if (CurrentTime - FileAccessTime <=
               time_t(HSOpts.ModuleCachePruneAfter)) {
         continue;
       }
 
       // Remove the file.
       llvm::sys::fs::remove(File->path());
 

clang/tools/libclang/CIndexCodeCompletion.cpp

else if (strcmp(*I, "-include") == 0) {
       if (I+1 != E) {
         const char *arg = *(++I);
         SmallString<512> pchName;
         {
           llvm::raw_svector_ostream os(pchName);
           os << arg << ".pth";
         }
         pchName.push_back('\0');
-        struct stat stat_results;
-        if (stat(pchName.str().c_str(), &stat_results) == 0)
+        llvm::sys::fs::file_status stat_results;
+        if (!llvm::sys::fs::status(pchName, stat_results))
           usesPCH = true;
         continue;
       }
     }
   }
 
   os << "{ ";
   os << "\"wall\": " << (EndTime.getWallTime() - StartTime.getWallTime());