// RedirectingFileSystem implementation
//===-----------------------------------------------------------------------===/
-RedirectingFileSystem::RedirectingFileSystem(IntrusiveRefCntPtr<FileSystem> FS)
- : ExternalFS(std::move(FS)) {
- if (ExternalFS)
- if (auto ExternalWorkingDirectory =
- ExternalFS->getCurrentWorkingDirectory()) {
- WorkingDirectory = *ExternalWorkingDirectory;
- ExternalFSValidWD = true;
- }
-}
-
// FIXME: reuse implementation common with OverlayFSDirIterImpl as these
// iterators are conceptually similar.
class llvm::vfs::VFSFromYamlDirIterImpl
llvm::ErrorOr<std::string>
RedirectingFileSystem::getCurrentWorkingDirectory() const {
- return WorkingDirectory;
+ return ExternalFS->getCurrentWorkingDirectory();
}
std::error_code
RedirectingFileSystem::setCurrentWorkingDirectory(const Twine &Path) {
- // Don't change the working directory if the path doesn't exist.
- if (!exists(Path))
- return errc::no_such_file_or_directory;
-
- // Always change the external FS but ignore its result.
- if (ExternalFS) {
- auto EC = ExternalFS->setCurrentWorkingDirectory(Path);
- ExternalFSValidWD = !static_cast<bool>(EC);
- }
-
- SmallString<128> AbsolutePath;
- Path.toVector(AbsolutePath);
- if (std::error_code EC = makeAbsolute(AbsolutePath))
- return EC;
- WorkingDirectory = AbsolutePath.str();
- return {};
+ return ExternalFS->setCurrentWorkingDirectory(Path);
}
std::error_code RedirectingFileSystem::isLocal(const Twine &Path,
ErrorOr<RedirectingFileSystem::Entry *> E = lookupPath(Dir);
if (!E) {
EC = E.getError();
- if (shouldUseExternalFS() && EC == errc::no_such_file_or_directory)
+ if (IsFallthrough && EC == errc::no_such_file_or_directory)
return ExternalFS->dir_begin(Dir, EC);
return {};
}
auto *D = cast<RedirectingFileSystem::RedirectingDirectoryEntry>(*E);
return directory_iterator(std::make_shared<VFSFromYamlDirIterImpl>(
Dir, D->contents_begin(), D->contents_end(),
- /*IterateExternalFS=*/shouldUseExternalFS(), *ExternalFS, EC));
+ /*IterateExternalFS=*/IsFallthrough, *ExternalFS, EC));
}
void RedirectingFileSystem::setExternalContentsPrefixDir(StringRef PrefixDir) {
RedirectingFileSystemParser P(Stream);
std::unique_ptr<RedirectingFileSystem> FS(
- new RedirectingFileSystem(ExternalFS));
+ new RedirectingFileSystem(std::move(ExternalFS)));
if (!YAMLFilePath.empty()) {
// Use the YAML path from -ivfsoverlay to compute the dir to be prefixed
ErrorOr<Status> RedirectingFileSystem::status(const Twine &Path) {
ErrorOr<RedirectingFileSystem::Entry *> Result = lookupPath(Path);
if (!Result) {
- if (shouldUseExternalFS() &&
+ if (IsFallthrough &&
Result.getError() == llvm::errc::no_such_file_or_directory) {
return ExternalFS->status(Path);
}
RedirectingFileSystem::openFileForRead(const Twine &Path) {
ErrorOr<RedirectingFileSystem::Entry *> E = lookupPath(Path);
if (!E) {
- if (shouldUseExternalFS() &
+ if (IsFallthrough &&
E.getError() == llvm::errc::no_such_file_or_directory) {
return ExternalFS->openFileForRead(Path);
}
SmallVectorImpl<char> &Output) const {
ErrorOr<RedirectingFileSystem::Entry *> Result = lookupPath(Path);
if (!Result) {
- if (shouldUseExternalFS() &&
+ if (IsFallthrough &&
Result.getError() == llvm::errc::no_such_file_or_directory) {
return ExternalFS->getRealPath(Path, Output);
}
}
// Even if there is a directory entry, fall back to ExternalFS if allowed,
// because directories don't have a single external contents path.
- return shouldUseExternalFS() ? ExternalFS->getRealPath(Path, Output)
- : llvm::errc::invalid_argument;
+ return IsFallthrough ? ExternalFS->getRealPath(Path, Output)
+ : llvm::errc::invalid_argument;
}
IntrusiveRefCntPtr<FileSystem>
class DummyFileSystem : public vfs::FileSystem {
int FSID; // used to produce UniqueIDs
int FileID; // used to produce UniqueIDs
- std::string WorkingDirectory;
std::map<std::string, vfs::Status> FilesAndDirs;
- typedef std::map<std::string, vfs::Status>::const_iterator const_iterator;
static int getNextFSID() {
static int Count = 0;
DummyFileSystem() : FSID(getNextFSID()), FileID(0) {}
ErrorOr<vfs::Status> status(const Twine &Path) override {
- auto I = findEntry(Path);
+ std::map<std::string, vfs::Status>::iterator I =
+ FilesAndDirs.find(Path.str());
if (I == FilesAndDirs.end())
return make_error_code(llvm::errc::no_such_file_or_directory);
return I->second;
return S.getError();
}
llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override {
- return WorkingDirectory;
+ return std::string();
}
std::error_code setCurrentWorkingDirectory(const Twine &Path) override {
- WorkingDirectory = Path.str();
return std::error_code();
}
// Map any symlink to "/symlink".
std::error_code getRealPath(const Twine &Path,
SmallVectorImpl<char> &Output) const override {
- auto I = findEntry(Path);
+ auto I = FilesAndDirs.find(Path.str());
if (I == FilesAndDirs.end())
return make_error_code(llvm::errc::no_such_file_or_directory);
if (I->second.isSymlink()) {
FilesAndDirs[Path] = Status;
}
- const_iterator findEntry(const Twine &Path) const {
- SmallString<128> P;
- Path.toVector(P);
- std::error_code EC = makeAbsolute(P);
- assert(!EC);
- return FilesAndDirs.find(P.str());
- }
-
void addRegularFile(StringRef Path, sys::fs::perms Perms = sys::fs::all_all) {
vfs::Status S(Path, UniqueID(FSID, FileID++),
std::chrono::system_clock::now(), 0, 0, 1024,
}
};
-class ErrorDummyFileSystem : public DummyFileSystem {
- std::error_code setCurrentWorkingDirectory(const Twine &Path) override {
- return llvm::errc::no_such_file_or_directory;
- }
-};
-
/// Replace back-slashes by front-slashes.
std::string getPosixPath(std::string S) {
SmallString<128> Result;
EXPECT_EQ(FS->getRealPath("/non_existing", RealPath),
errc::no_such_file_or_directory);
}
-
-TEST_F(VFSFromYAMLTest, WorkingDirectory) {
- IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
- Lower->addDirectory("//root/");
- Lower->addDirectory("//root/foo");
- Lower->addRegularFile("//root/foo/a");
- Lower->addRegularFile("//root/foo/b");
- IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
- "{ 'use-external-names': false,\n"
- " 'roots': [\n"
- "{\n"
- " 'type': 'directory',\n"
- " 'name': '//root/bar',\n"
- " 'contents': [ {\n"
- " 'type': 'file',\n"
- " 'name': 'a',\n"
- " 'external-contents': '//root/foo/a'\n"
- " }\n"
- " ]\n"
- "}\n"
- "]\n"
- "}",
- Lower);
- ASSERT_TRUE(FS.get() != nullptr);
- std::error_code EC = FS->setCurrentWorkingDirectory("//root/bar/");
- ASSERT_FALSE(EC);
-
- llvm::ErrorOr<std::string> WorkingDir = FS->getCurrentWorkingDirectory();
- ASSERT_TRUE(WorkingDir);
- EXPECT_EQ(*WorkingDir, "//root/bar/");
-
- llvm::ErrorOr<vfs::Status> Status = FS->status("./a");
- ASSERT_FALSE(Status.getError());
- EXPECT_TRUE(Status->isStatusKnown());
- EXPECT_FALSE(Status->isDirectory());
- EXPECT_TRUE(Status->isRegularFile());
- EXPECT_FALSE(Status->isSymlink());
- EXPECT_FALSE(Status->isOther());
- EXPECT_TRUE(Status->exists());
-
- EC = FS->setCurrentWorkingDirectory("bogus");
- ASSERT_TRUE(EC);
- WorkingDir = FS->getCurrentWorkingDirectory();
- ASSERT_TRUE(WorkingDir);
- EXPECT_EQ(*WorkingDir, "//root/bar/");
-
- EC = FS->setCurrentWorkingDirectory("//root/");
- ASSERT_FALSE(EC);
- WorkingDir = FS->getCurrentWorkingDirectory();
- ASSERT_TRUE(WorkingDir);
- EXPECT_EQ(*WorkingDir, "//root/");
-
- EC = FS->setCurrentWorkingDirectory("bar/");
- ASSERT_FALSE(EC);
- WorkingDir = FS->getCurrentWorkingDirectory();
- ASSERT_TRUE(WorkingDir);
- EXPECT_EQ(*WorkingDir, "//root/bar/");
-}
-
-TEST_F(VFSFromYAMLTest, WorkingDirectoryFallthrough) {
- IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
- Lower->addDirectory("//root/");
- Lower->addDirectory("//root/foo");
- Lower->addRegularFile("//root/foo/a");
- Lower->addRegularFile("//root/foo/b");
- Lower->addRegularFile("//root/c");
- IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
- "{ 'use-external-names': false,\n"
- " 'roots': [\n"
- "{\n"
- " 'type': 'directory',\n"
- " 'name': '//root/bar',\n"
- " 'contents': [ {\n"
- " 'type': 'file',\n"
- " 'name': 'a',\n"
- " 'external-contents': '//root/foo/a'\n"
- " }\n"
- " ]\n"
- "}\n"
- "]\n"
- "}",
- Lower);
- ASSERT_TRUE(FS.get() != nullptr);
- std::error_code EC = FS->setCurrentWorkingDirectory("//root/");
- ASSERT_FALSE(EC);
- ASSERT_TRUE(FS.get() != nullptr);
-
- llvm::ErrorOr<vfs::Status> Status = FS->status("bar/a");
- ASSERT_FALSE(Status.getError());
- EXPECT_TRUE(Status->exists());
-
- Status = FS->status("foo/a");
- ASSERT_FALSE(Status.getError());
- EXPECT_TRUE(Status->exists());
-
- EC = FS->setCurrentWorkingDirectory("//root/bar/");
- ASSERT_FALSE(EC);
-
- Status = FS->status("./a");
- ASSERT_FALSE(Status.getError());
- EXPECT_TRUE(Status->exists());
-
- Status = FS->status("./b");
- ASSERT_TRUE(Status.getError());
-
- Status = FS->status("./c");
- ASSERT_TRUE(Status.getError());
-
- EC = FS->setCurrentWorkingDirectory("//root/");
- ASSERT_FALSE(EC);
-
- Status = FS->status("c");
- ASSERT_FALSE(Status.getError());
- EXPECT_TRUE(Status->exists());
-}
-
-TEST_F(VFSFromYAMLTest, WorkingDirectoryFallthroughInvalid) {
- IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem());
- Lower->addDirectory("//root/");
- Lower->addDirectory("//root/foo");
- Lower->addRegularFile("//root/foo/a");
- Lower->addRegularFile("//root/foo/b");
- Lower->addRegularFile("//root/c");
- IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
- "{ 'use-external-names': false,\n"
- " 'roots': [\n"
- "{\n"
- " 'type': 'directory',\n"
- " 'name': '//root/bar',\n"
- " 'contents': [ {\n"
- " 'type': 'file',\n"
- " 'name': 'a',\n"
- " 'external-contents': '//root/foo/a'\n"
- " }\n"
- " ]\n"
- "}\n"
- "]\n"
- "}",
- Lower);
- ASSERT_TRUE(FS.get() != nullptr);
- std::error_code EC = FS->setCurrentWorkingDirectory("//root/");
- ASSERT_FALSE(EC);
- ASSERT_TRUE(FS.get() != nullptr);
-
- llvm::ErrorOr<vfs::Status> Status = FS->status("bar/a");
- ASSERT_FALSE(Status.getError());
- EXPECT_TRUE(Status->exists());
-
- Status = FS->status("foo/a");
- ASSERT_TRUE(Status.getError());
-}
projects / llvm / commitdiff