[vfs] Use FS->WorkingDirectory when converting relative path to ABS

[haowei]

Summary

This is a follow up of change D137473

When parsing root directory from a VFS YAML file, llvm always uses process working directory (PWD) as the current working directory if "root-relative" option is not set to "overlay-dir". This behavior prevents clang's --working-directory flag from taking effect when processing a relative root directory. This patch changes the default PWD to FS->WorkingDirectory, which fixes the issue.

llvm/lib/Support/VirtualFileSystem.cpp

 
 RedirectingFileSystem::RedirectingFileSystem(IntrusiveRefCntPtr<FileSystem> FS)
     : ExternalFS(std::move(FS)) {
   if (ExternalFS)
     if (auto ExternalWorkingDirectory =
             ExternalFS->getCurrentWorkingDirectory()) {
       WorkingDirectory = *ExternalWorkingDirectory;
     }
+  if (WorkingDirectory == "") {
+    SmallString<256> cwd;
+    llvm::sys::fs::current_path(cwd);
+    WorkingDirectory = std::string(cwd);
+  }
 }
 
 /// Directory iterator implementation for \c RedirectingFileSystem's
 /// directory entries.
 class llvm::vfs::RedirectingFSDirIterImpl
     : public llvm::vfs::detail::DirIterImpl {
   std::string Dir;
   RedirectingFileSystem::DirectoryEntry::iterator Current, End;
if (IsRootEntry) {
         std::error_code EC;
         if (FS->RootRelative ==
             RedirectingFileSystem::RootRelativeKind::OverlayDir) {
           StringRef FullPath = FS->getOverlayFileDir();
           assert(!FullPath.empty() && "Overlay file directory must exist");
           EC = FS->makeAbsolute(FullPath, Name);
           Name = canonicalize(Name);
         } else {
-          EC = sys::fs::make_absolute(Name);
+          EC = FS->makeAbsolute(Name);
         }
         if (EC) {
           assert(NameValueNode && "Name presence should be checked earlier");
           error(
               NameValueNode,
               "entry with relative path at the root level is not discoverable");
           return nullptr;
         }

llvm/unittests/Support/VirtualFileSystemTest.cpp

for (int l = 0; I != E; I.increment(EC), ++l) {
     EXPECT_EQ(I.level(), l);
   }
   EXPECT_EQ(I, E);
 }
 
 TEST_F(VFSFromYAMLTest, RelativePaths) {
   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
   std::error_code EC;
-  SmallString<128> CWD;
-  EC = llvm::sys::fs::current_path(CWD);
   ASSERT_FALSE(EC);
 
   // Filename at root level without a parent directory.
   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
       "{ 'roots': [\n"
       "  { 'type': 'file', 'name': 'file-not-in-directory.h',\n"
       "    'external-contents': '//root/external/file'\n"
       "  }\n"
       "] }",
       Lower);
   ASSERT_TRUE(FS.get() != nullptr);
+  llvm::ErrorOr<std::string> CWD = FS->getCurrentWorkingDirectory();
+  ASSERT_TRUE(CWD);
+
   SmallString<128> ExpectedPathNotInDir("file-not-in-directory.h");
   llvm::sys::fs::make_absolute(ExpectedPathNotInDir);
-  checkContents(FS->dir_begin(CWD, EC), {ExpectedPathNotInDir});
+  checkContents(FS->dir_begin(CWD.get(), EC), {ExpectedPathNotInDir});
 
   // Relative file path.
   FS = getFromYAMLString("{ 'roots': [\n"
                          "  { 'type': 'file', 'name': 'relative/path.h',\n"
                          "    'external-contents': '//root/external/file'\n"
                          "  }\n"
                          "] }",
                          Lower);
   ASSERT_TRUE(FS.get() != nullptr);
   SmallString<128> Parent("relative");
   llvm::sys::fs::make_absolute(Parent);
   auto I = FS->dir_begin(Parent, EC);
   ASSERT_FALSE(EC);
   // Convert to POSIX path for comparison of windows paths
   ASSERT_EQ("relative/path.h",
-            getPosixPath(std::string(I->path().substr(CWD.size() + 1))));
+            getPosixPath(std::string(I->path().substr(CWD->size() + 1))));
 
   // Relative directory path.
   FS = getFromYAMLString(
       "{ 'roots': [\n"
       "  { 'type': 'directory', 'name': 'relative/directory/path.h',\n"
       "    'contents': []\n"
       "  }\n"
       "] }",