[llvm][clang][vfs] NFC: Simplify directory iteration

[jansvoboda11]

Summary

The iteration over directory entries of a VFS is a bit unweildy, since it requires using a pair of llvm::vfs::directory_iterator, calling llvm::vfs::directory_iterator::increment(std::error_code &) and checking std::error_code. Currently, there are 15 instances of this pattern in the Clang codebase.

This patch simplifies iteration over directory entries by introducing new type of iterator and adding FileSystem::dir_range() function.

[dexonsmith]

I think th eAPI is designed to ensure users don't forget to check the error code.

What about a new API/iterator type that wraps the existing one and has a "normal" operator++?

• Take an error as an out-parameter on construction
• Make it an llvm::Error which guarantees a crash if not checked
• This would wrap the other type and store a reference to the Error. If there's an error during iteration, advances to end and sets the error.

Here's what I'm thinking:

Optional<llvm::Error> DirError;
for (vfs::error_directory_iterator File = D.getVFS().dir_begin(Cand.Path, DirError),
                                   FileEnd;
     File != FileEnd; ++File) {
  // ...
}
if (DirError)
  return errorToErrorCode(std::move(*IterationEC));

At that point, it'd be easy to add a dir_range wrapper that creates an iterator range:

for (auto &File : dir_range(Path, DirError)) {
  // ...
}

[jansvoboda11]

Replace macro with range of new iterators

[jansvoboda11]

I agree that introducing new iterator and implementing iterator_range<...> FileSystem::dir_range() is better solution than a macro.

I'm not sure the dir_range function needs to take an std::error_code out-param though. The error code is only used to stop the iteration, clients don't use it for any other purpose. I think the new iterator could handle error codes completely internally (by advancing to the end), providing better ergonomics. WDYT?

I might create a follow-up patches for recursive VFS-based iteration and also enable range-based for loops in code using llvm::sys::fs instead of the VFS.

[dexonsmith]

In D116659#3237061, @jansvoboda11 wrote:

I agree that introducing new iterator and implementing iterator_range<...> FileSystem::dir_range() is better solution than a macro.

I'm not sure the dir_range function needs to take an std::error_code out-param though. The error code is only used to stop the iteration, clients don't use it for any other purpose. I think the new iterator could handle error codes completely internally (by advancing to the end), providing better ergonomics. WDYT?

I might create a follow-up patches for recursive VFS-based iteration and also enable range-based for loops in code using llvm::sys::fs instead of the VFS.

I don't know, I'm a bit skeptical we want to make it so easy to ignore errors so easily. I'd rather require clients to explicitly ignore the error.

@benlangmuir, any thoughts on this?

[benlangmuir]

I don't know, I'm a bit skeptical we want to make it so easy to ignore errors so easily. I'd rather require clients to explicitly ignore the error.

That's my gut feeling too. I suspect a bunch of this code should be explicitly ignoring ENOENT, but not ignoring e.g. EACCESS, EMFILE , etc. It seems like a bug that we're ignoring all errors right now.

If we really want to ignore all the iteration errors, we should do that consistently in llvm::sys::fs not just the wrapper in the VFS layer.

[dexonsmith]

In D116659#3241727, @benlangmuir wrote:

I don't know, I'm a bit skeptical we want to make it so easy to ignore errors so easily. I'd rather require clients to explicitly ignore the error.

That's my gut feeling too. I suspect a bunch of this code should be explicitly ignoring ENOENT, but not ignoring e.g. EACCESS, EMFILE , etc. It seems like a bug that we're ignoring all errors right now.

If we really want to ignore all the iteration errors, we should do that consistently in llvm::sys::fs not just the wrapper in the VFS layer.

If the main goal is to enable range-based-for, a simpler option than I suggested previously might be to have an iterator that dereferences to ErrorOr<FileEntry>. Could be an iterator adaptor that takes any increment(EC)-style iterator (either llvm::sys::fs or llvm::vfs). Maybe dir_range could return ErrorOr<iterator_range<...>> to expose the error-on-construction explicitly as well.

clang/lib/Driver/ToolChain.cpp

/*static*/ void ToolChain::addSystemIncludes(const ArgList &DriverArgs,
                                              ArrayRef<StringRef> Paths) {
   for (const auto &Path : Paths) {
     CC1Args.push_back("-internal-isystem");
     CC1Args.push_back(DriverArgs.MakeArgString(Path));
   }
 }
 
 std::string ToolChain::detectLibcxxVersion(StringRef IncludePath) const {
-  std::error_code EC;
   int MaxVersion = 0;
   std::string MaxVersionString;
   SmallString<128> Path(IncludePath);
   llvm::sys::path::append(Path, "c++");
-  for (llvm::vfs::directory_iterator LI = getVFS().dir_begin(Path, EC), LE;
-       !EC && LI != LE; LI = LI.increment(EC)) {
-    StringRef VersionText = llvm::sys::path::filename(LI->path());
+  for (const auto &Entry : getVFS().dir_range(Path)) {
+    StringRef VersionText = llvm::sys::path::filename(Entry.path());
     int Version;
     if (VersionText[0] == 'v' &&
         !VersionText.slice(1, StringRef::npos).getAsInteger(10, Version)) {
       if (Version > MaxVersion) {
         MaxVersion = Version;
         MaxVersionString = std::string(VersionText);
       }
     }

clang/lib/Driver/ToolChains/AMDGPU.cpp

 // more than one matching sub-directories, diagnose them. Returns the full
 // path of the package if there is only one matching sub-directory, otherwise
 // returns an empty string.
 llvm::SmallString<0>
 RocmInstallationDetector::findSPACKPackage(const Candidate &Cand,
                                            StringRef PackageName) {
   if (!Cand.isSPACK())
     return {};
-  std::error_code EC;
   std::string Prefix = Twine(PackageName + "-" + Cand.SPACKReleaseStr).str();
   llvm::SmallVector<llvm::SmallString<0>> SubDirs;
-  for (llvm::vfs::directory_iterator File = D.getVFS().dir_begin(Cand.Path, EC),
-                                     FileEnd;
-       File != FileEnd && !EC; File.increment(EC)) {
-    llvm::StringRef FileName = llvm::sys::path::filename(File->path());
+  for (const auto &File : D.getVFS().dir_range(Cand.Path)) {
+    llvm::StringRef FileName = llvm::sys::path::filename(File.path());
     if (FileName.startswith(Prefix)) {
       SubDirs.push_back(FileName);
       if (SubDirs.size() > 1)
         break;
     }
   }
   if (SubDirs.size() == 1) {
     auto PackagePath = Cand.Path;

 }
 
 void RocmInstallationDetector::scanLibDevicePath(llvm::StringRef Path) {
   assert(!Path.empty());
 
   const StringRef Suffix(".bc");
   const StringRef Suffix2(".amdgcn.bc");
 
-  std::error_code EC;
-  for (llvm::vfs::directory_iterator LI = D.getVFS().dir_begin(Path, EC), LE;
-       !EC && LI != LE; LI = LI.increment(EC)) {
-    StringRef FilePath = LI->path();
+  for (const auto &Entry : D.getVFS().dir_range(Path)) {
+    StringRef FilePath = Entry.path();
     StringRef FileName = llvm::sys::path::filename(FilePath);
     if (!FileName.endswith(Suffix))
       continue;
 
     StringRef BaseName;
     if (FileName.endswith(Suffix2))
       BaseName = FileName.drop_back(Suffix2.size());
     else if (FileName.endswith(Suffix))
auto GetROCmVersion = [](StringRef DirName) {
     llvm::VersionTuple V;
     std::string VerStr = DirName.drop_front(strlen("rocm-")).str();
     // The ROCm directory name follows the format of
     // rocm-{major}.{minor}.{subMinor}[-{build}]
     std::replace(VerStr.begin(), VerStr.end(), '-', '.');
     V.tryParse(VerStr);
     return V;
   };
-  for (llvm::vfs::directory_iterator
-           File = D.getVFS().dir_begin(D.SysRoot + "/opt", EC),
-           FileEnd;
-       File != FileEnd && !EC; File.increment(EC)) {
-    llvm::StringRef FileName = llvm::sys::path::filename(File->path());
+  for (const auto &File : D.getVFS().dir_range(D.SysRoot + "/opt")) {
+    llvm::StringRef FileName = llvm::sys::path::filename(File.path());
     if (!FileName.startswith("rocm-"))
       continue;
     if (LatestROCm.empty()) {
       LatestROCm = FileName.str();
       LatestVer = GetROCmVersion(LatestROCm);
       continue;
     }
     auto Ver = GetROCmVersion(FileName);

clang/lib/Driver/ToolChains/BareMetal.cpp

case ToolChain::CST_Libcxx: {
     SmallString<128> Dir(SysRoot);
     llvm::sys::path::append(Dir, "include", "c++", "v1");
     addSystemInclude(DriverArgs, CC1Args, Dir.str());
     break;
   }
   case ToolChain::CST_Libstdcxx: {
     SmallString<128> Dir(SysRoot);
     llvm::sys::path::append(Dir, "include", "c++");
-    std::error_code EC;
     Generic_GCC::GCCVersion Version = {"", -1, -1, -1, "", "", ""};
     // Walk the subdirs, and find the one with the newest gcc version:
-    for (llvm::vfs::directory_iterator
-             LI = getDriver().getVFS().dir_begin(Dir.str(), EC),
-             LE;
-         !EC && LI != LE; LI = LI.increment(EC)) {
-      StringRef VersionText = llvm::sys::path::filename(LI->path());
+    for (const auto &Entry : getDriver().getVFS().dir_range(Dir)) {
+      StringRef VersionText = llvm::sys::path::filename(Entry.path());
       auto CandidateVersion = Generic_GCC::GCCVersion::Parse(VersionText);
       if (CandidateVersion.Major == -1)
         continue;
       if (CandidateVersion <= Version)
         continue;
       Version = CandidateVersion;
     }
     if (Version.Major == -1)

clang/lib/Driver/ToolChains/Cuda.cpp

if (Version >= CudaVersion::CUDA_90) {
           CudaArch GpuArch = static_cast<CudaArch>(Arch);
           if (!IsNVIDIAGpuArch(GpuArch))
             continue;
           std::string GpuArchName(CudaArchToString(GpuArch));
           LibDeviceMap[GpuArchName] = FilePath;
         }
       }
     } else {
-      std::error_code EC;
-      for (llvm::vfs::directory_iterator LI = FS.dir_begin(LibDevicePath, EC),
-                                         LE;
-           !EC && LI != LE; LI = LI.increment(EC)) {
-        StringRef FilePath = LI->path();
+      for (const auto &Entry : FS.dir_range(LibDevicePath)) {
+        StringRef FilePath = Entry.path();
         StringRef FileName = llvm::sys::path::filename(FilePath);
         // Process all bitcode filenames that look like
         // libdevice.compute_XX.YY.bc
         const StringRef LibDeviceName = "libdevice.";
         if (!(FileName.startswith(LibDeviceName) && FileName.endswith(".bc")))
           continue;
         StringRef GpuArch = FileName.slice(
             LibDeviceName.size(), FileName.find('.', LibDeviceName.size()));

clang/lib/Driver/ToolChains/Gnu.cpp

void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes(
   if (TargetTriple.getOS() == llvm::Triple::Solaris) {
     // Solaris is a special case.
     // The GCC installation is under
     //   /usr/gcc/<major>.<minor>/lib/gcc/<triple>/<major>.<minor>.<patch>/
     // so we need to find those /usr/gcc/*/lib/gcc libdirs and go with
     // /usr/gcc/<version> as a prefix.
 
     std::string PrefixDir = SysRoot.str() + "/usr/gcc";
-    std::error_code EC;
-    for (llvm::vfs::directory_iterator LI = D.getVFS().dir_begin(PrefixDir, EC),
-                                       LE;
-         !EC && LI != LE; LI = LI.increment(EC)) {
-      StringRef VersionText = llvm::sys::path::filename(LI->path());
+    for (const auto &Entry : D.getVFS().dir_range(PrefixDir)) {
+      StringRef VersionText = llvm::sys::path::filename(Entry.path());
       GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
 
       // Filter out obviously bad entries.
       if (CandidateVersion.Major == -1 || CandidateVersion.isOlderThan(4, 1, 1))
         continue;
 
       std::string CandidatePrefix = PrefixDir + "/" + VersionText.str();
       std::string CandidateLibPath = CandidatePrefix + "/lib/gcc";
bool Active;
        TargetTriple.getVendor() == llvm::Triple::Freescale ||
            TargetTriple.getVendor() == llvm::Triple::OpenEmbedded}};
 
   for (auto &Suffix : Suffixes) {
     if (!Suffix.Active)
       continue;
 
     StringRef LibSuffix = Suffix.LibSuffix;
-    std::error_code EC;
-    for (llvm::vfs::directory_iterator
-             LI = D.getVFS().dir_begin(LibDir + "/" + LibSuffix, EC),
-             LE;
-         !EC && LI != LE; LI = LI.increment(EC)) {
-      StringRef VersionText = llvm::sys::path::filename(LI->path());
+    for (const auto &Entry : D.getVFS().dir_range(LibDir + "/" + LibSuffix)) {
+      StringRef VersionText = llvm::sys::path::filename(Entry.path());
       GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
       if (CandidateVersion.Major != -1) // Filter obviously bad entries.
-        if (!CandidateGCCInstallPaths.insert(std::string(LI->path())).second)
+        if (!CandidateGCCInstallPaths.insert(std::string(Entry.path())).second)
           continue; // Saw this path before; no need to look at it again.
       if (CandidateVersion.isOlderThan(4, 1, 1))
         continue;
       if (CandidateVersion <= Version)
         continue;
 
-      if (!ScanGCCForMultilibs(TargetTriple, Args, LI->path(),
+      if (!ScanGCCForMultilibs(TargetTriple, Args, Entry.path(),
                                NeedsBiarchSuffix))
         continue;
 
       Version = CandidateVersion;
       GCCTriple.setTriple(CandidateTriple);
       // FIXME: We hack together the directory name here instead of
       // using LI to ensure stable path separators across Windows and
       // Linux.

clang/lib/Driver/ToolChains/MSVC.cpp

 static bool getSystemRegistryString(const char *keyPath, const char *valueName,
                                     std::string &value, std::string *phValue);
 
 static std::string getHighestNumericTupleInDirectory(llvm::vfs::FileSystem &VFS,
                                                      StringRef Directory) {
   std::string Highest;
   llvm::VersionTuple HighestTuple;
 
-  std::error_code EC;
-  for (llvm::vfs::directory_iterator DirIt = VFS.dir_begin(Directory, EC),
-                                     DirEnd;
-       !EC && DirIt != DirEnd; DirIt.increment(EC)) {
-    auto Status = VFS.status(DirIt->path());
+  for (const auto &Entry : VFS.dir_range(Directory)) {
+    auto Status = VFS.status(Entry.path());
     if (!Status || !Status->isDirectory())
       continue;
-    StringRef CandidateName = llvm::sys::path::filename(DirIt->path());
+    StringRef CandidateName = llvm::sys::path::filename(Entry.path());
     llvm::VersionTuple Tuple;
     if (Tuple.tryParse(CandidateName)) // tryParse() returns true on error.
       continue;
     if (Tuple > HighestTuple) {
       HighestTuple = Tuple;
       Highest = CandidateName.str();
     }
   }

clang/lib/Frontend/CompilerInstance.cpp

static void collectIncludePCH(CompilerInstance &CI,
   StringRef PCHInclude = PPOpts.ImplicitPCHInclude;
   FileManager &FileMgr = CI.getFileManager();
   auto PCHDir = FileMgr.getDirectory(PCHInclude);
   if (!PCHDir) {
     MDC->addFile(PCHInclude);
     return;
   }
 
-  std::error_code EC;
   SmallString<128> DirNative;
   llvm::sys::path::native((*PCHDir)->getName(), DirNative);
   llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
   SimpleASTReaderListener Validator(CI.getPreprocessor());
-  for (llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC), DirEnd;
-       Dir != DirEnd && !EC; Dir.increment(EC)) {
+  for (const auto &Dir : FS.dir_range(DirNative)) {
     // Check whether this is an AST file. ASTReader::isAcceptableASTFile is not
     // used here since we're not interested in validating the PCH at this time,
     // but only to check whether this is a file containing an AST.
     if (!ASTReader::readASTFileControlBlock(
-            Dir->path(), FileMgr, CI.getPCHContainerReader(),
+            Dir.path(), FileMgr, CI.getPCHContainerReader(),
             /*FindModuleFileExtensions=*/false, Validator,
             /*ValidateDiagnosticOptions=*/false))
-      MDC->addFile(Dir->path());
+      MDC->addFile(Dir.path());
   }
 }
 
 static void collectVFSEntries(CompilerInstance &CI,
                               std::shared_ptr<ModuleDependencyCollector> MDC) {
   if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
     return;
 

clang/lib/Frontend/FrontendAction.cpp

bool FrontendAction::BeginSourceFile(CompilerInstance &CI,
   // If the implicit PCH include is actually a directory, rather than
   // a single file, search for a suitable PCH file in that directory.
   if (!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
     FileManager &FileMgr = CI.getFileManager();
     PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
     StringRef PCHInclude = PPOpts.ImplicitPCHInclude;
     std::string SpecificModuleCachePath = CI.getSpecificModuleCachePath();
     if (auto PCHDir = FileMgr.getDirectory(PCHInclude)) {
-      std::error_code EC;
       SmallString<128> DirNative;
       llvm::sys::path::native((*PCHDir)->getName(), DirNative);
       bool Found = false;
       llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
-      for (llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC),
-                                         DirEnd;
-           Dir != DirEnd && !EC; Dir.increment(EC)) {
+      for (const auto &Dir : FS.dir_range(DirNative)) {
         // Check whether this is an acceptable AST file.
         if (ASTReader::isAcceptableASTFile(
-                Dir->path(), FileMgr, CI.getPCHContainerReader(),
+                Dir.path(), FileMgr, CI.getPCHContainerReader(),
                 CI.getLangOpts(), CI.getTargetOpts(), CI.getPreprocessorOpts(),
                 SpecificModuleCachePath)) {
-          PPOpts.ImplicitPCHInclude = std::string(Dir->path());
+          PPOpts.ImplicitPCHInclude = std::string(Dir.path());
           Found = true;
           break;
         }
       }
 
       if (!Found) {
         CI.getDiagnostics().Report(diag::err_fe_no_pch_in_dir) << PCHInclude;
         return false;

clang/lib/Lex/HeaderSearch.cpp

 void HeaderSearch::collectAllModules(SmallVectorImpl<Module *> &Modules) {
   Modules.clear();
 
   if (HSOpts->ImplicitModuleMaps) {
     // Load module maps for each of the header search directories.
     for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) {
       bool IsSystem = SearchDirs[Idx]->isSystemHeaderDirectory();
       if (SearchDirs[Idx]->isFramework()) {
-        std::error_code EC;
         SmallString<128> DirNative;
         llvm::sys::path::native(SearchDirs[Idx]->getFrameworkDir()->getName(),
                                 DirNative);
 
         // Search each of the ".framework" directories to load them as modules.
         llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
-        for (llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC),
-                                           DirEnd;
-             Dir != DirEnd && !EC; Dir.increment(EC)) {
-          if (llvm::sys::path::extension(Dir->path()) != ".framework")
+        for (const auto &Dir : FS.dir_range(DirNative)) {
+          if (llvm::sys::path::extension(Dir.path()) != ".framework")
             continue;
 
           auto FrameworkDir =
-              FileMgr.getDirectory(Dir->path());
+              FileMgr.getDirectory(Dir.path());
           if (!FrameworkDir)
             continue;
 
           // Load this framework module.
-          loadFrameworkModule(llvm::sys::path::stem(Dir->path()), *FrameworkDir,
+          loadFrameworkModule(llvm::sys::path::stem(Dir.path()), *FrameworkDir,
                               IsSystem);
         }
         continue;
       }
 
       // FIXME: Deal with header maps.
       if (SearchDirs[Idx]->isHeaderMap())
         continue;

 
 void HeaderSearch::loadSubdirectoryModuleMaps(DirectoryLookup &SearchDir) {
   assert(HSOpts->ImplicitModuleMaps &&
          "Should not be loading subdirectory module maps");
 
   if (SearchDir.haveSearchedAllModuleMaps())
     return;
 
-  std::error_code EC;
   SmallString<128> Dir = SearchDir.getDir()->getName();
   FileMgr.makeAbsolutePath(Dir);
   SmallString<128> DirNative;
   llvm::sys::path::native(Dir, DirNative);
   llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
-  for (llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC), DirEnd;
-       Dir != DirEnd && !EC; Dir.increment(EC)) {
-    bool IsFramework = llvm::sys::path::extension(Dir->path()) == ".framework";
+  for (const auto &Dir : FS.dir_range(DirNative)) {
+    bool IsFramework = llvm::sys::path::extension(Dir.path()) == ".framework";
     if (IsFramework == SearchDir.isFramework())
-      loadModuleMapFile(Dir->path(), SearchDir.isSystemHeaderDirectory(),
+      loadModuleMapFile(Dir.path(), SearchDir.isSystemHeaderDirectory(),
                         SearchDir.isFramework());
   }
 
   SearchDir.setSearchedAllModuleMaps(true);
 }
 
 std::string HeaderSearch::suggestPathToFileForDiagnostics(
     const FileEntry *File, llvm::StringRef MainFile, bool *IsSystem) {

clang/lib/Lex/ModuleMap.cpp

Module *ModuleMap::inferFrameworkModule(const DirectoryEntry *FrameworkDir,
   // export *
   Result->Exports.push_back(Module::ExportDecl(nullptr, true));
 
   // module * { export * }
   Result->InferSubmodules = true;
   Result->InferExportWildcard = true;
 
   // Look for subframeworks.
-  std::error_code EC;
   SmallString<128> SubframeworksDirName
     = StringRef(FrameworkDir->getName());
   llvm::sys::path::append(SubframeworksDirName, "Frameworks");
   llvm::sys::path::native(SubframeworksDirName);
   llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
-  for (llvm::vfs::directory_iterator
-           Dir = FS.dir_begin(SubframeworksDirName, EC),
-           DirEnd;
-       Dir != DirEnd && !EC; Dir.increment(EC)) {
-    if (!StringRef(Dir->path()).endswith(".framework"))
+  for (const auto &Dir : FS.dir_range(SubframeworksDirName)) {
+    if (!StringRef(Dir.path()).endswith(".framework"))
       continue;
 
-    if (auto SubframeworkDir =
-            FileMgr.getDirectory(Dir->path())) {
+    if (auto SubframeworkDir = FileMgr.getDirectory(Dir.path())) {
       // Note: as an egregious but useful hack, we use the real path here and
       // check whether it is actually a subdirectory of the parent directory.
       // This will not be the case if the 'subframework' is actually a symlink
       // out to a top-level framework.
       StringRef SubframeworkDirName =
           FileMgr.getCanonicalName(*SubframeworkDir);
       bool FoundParent = false;
       do {

clang/lib/Sema/SemaCodeComplete.cpp

if (!NativeRelDir.empty()) {
         llvm::sys::path::append(Dir, NativeRelDir);
       }
     }
 
     const StringRef &Dirname = llvm::sys::path::filename(Dir);
     const bool isQt = Dirname.startswith("Qt") || Dirname == "ActiveQt";
     const bool ExtensionlessHeaders =
         IsSystem || isQt || Dir.endswith(".framework/Headers");
-    std::error_code EC;
     unsigned Count = 0;
-    for (auto It = FS.dir_begin(Dir, EC);
-         !EC && It != llvm::vfs::directory_iterator(); It.increment(EC)) {
+    for (const auto &Entry : FS.dir_range(Dir)) {
       if (++Count == 2500) // If we happen to hit a huge directory,
         break;             // bail out early so we're not too slow.
-      StringRef Filename = llvm::sys::path::filename(It->path());
+      StringRef Filename = llvm::sys::path::filename(Entry.path());
 
       // To know whether a symlink should be treated as file or a directory, we
       // have to stat it. This should be cheap enough as there shouldn't be many
       // symlinks.
-      llvm::sys::fs::file_type Type = It->type();
+      llvm::sys::fs::file_type Type = Entry.type();
       if (Type == llvm::sys::fs::file_type::symlink_file) {
-        if (auto FileStatus = FS.status(It->path()))
+        if (auto FileStatus = FS.status(Entry.path()))
           Type = FileStatus->getType();
       }
       switch (Type) {
       case llvm::sys::fs::file_type::directory_file:
         // All entries in a framework directory must have a ".framework" suffix,
         // but the suffix does not appear in the source code's include/import.
         if (LookupType == DirectoryLookup::LT_Framework &&
             NativeRelDir.empty() && !Filename.consume_back(".framework"))

llvm/include/llvm/Support/VirtualFileSystem.h

if (Impl && RHS.Impl)
       return Impl->CurrentEntry.path() == RHS.Impl->CurrentEntry.path();
     return !Impl && !RHS.Impl;
   }
   bool operator!=(const directory_iterator &RHS) const {
     return !(*this == RHS);
   }
 };
 
+/// Wrapper for directory_iterator that automatically handles error codes.
+class directory_iterator_error_wrapper {
+  directory_iterator It;
+
+public:
+  directory_iterator_error_wrapper(directory_iterator It, std::error_code &EC)
+      : It(std::move(It)) {
+    if (EC)
+      It = directory_iterator();
+  }
+
+  directory_iterator_error_wrapper() = default;
+
+  directory_iterator_error_wrapper &operator++() {
+    std::error_code EC;
+    It.increment(EC);
+    if (EC)
+      It = directory_iterator();
+    return *this;
+  }
+
+  const directory_entry &operator*() const { return *It; }
+  const directory_entry *operator->() const { return &*It; }
+
+  bool operator==(const directory_iterator_error_wrapper &RHS) const {
+    return It == RHS.It;
+  }
+  bool operator!=(const directory_iterator_error_wrapper &RHS) const {
+    return !(*this == RHS);
+  }
+};
+
 class FileSystem;
 
 namespace detail {
 
 /// Keeps state for the recursive_directory_iterator.
 struct RecDirIterState {
   std::stack<directory_iterator, std::vector<directory_iterator>> Stack;
   bool HasNoPushRequest = false;
public:
   getBufferForFile(const Twine &Name, int64_t FileSize = -1,
                    bool RequiresNullTerminator = true, bool IsVolatile = false);
 
   /// Get a directory_iterator for \p Dir.
   /// \note The 'end' iterator is directory_iterator().
   virtual directory_iterator dir_begin(const Twine &Dir,
                                        std::error_code &EC) = 0;
 
+  /// Get a directory_iterator range for \p Dir.
+  iterator_range<directory_iterator_error_wrapper> dir_range(const Twine &Dir);
+
   /// Set the working directory. This will affect all following operations on
   /// this file system and may propagate down for nested file systems.
   virtual std::error_code setCurrentWorkingDirectory(const Twine &Path) = 0;
 
   /// Get the working directory of this file system.
   virtual llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const = 0;
 
   /// Gets real path of \p Path e.g. collapse all . and .. patterns, resolve

llvm/lib/Support/VirtualFileSystem.cpp

FileSystem::getBufferForFile(const llvm::Twine &Name, int64_t FileSize,
                              bool RequiresNullTerminator, bool IsVolatile) {
   auto F = openFileForRead(Name);
   if (!F)
     return F.getError();
 
   return (*F)->getBuffer(Name, FileSize, RequiresNullTerminator, IsVolatile);
 }
 
+iterator_range<directory_iterator_error_wrapper>
+FileSystem::dir_range(const Twine &Dir) {
+  std::error_code EC;
+  return {directory_iterator_error_wrapper(dir_begin(Dir, EC), EC),
+          directory_iterator_error_wrapper()};
+}
+
 std::error_code FileSystem::makeAbsolute(SmallVectorImpl<char> &Path) const {
   if (llvm::sys::path::is_absolute(Path))
     return {};
 
   auto WorkingDir = getCurrentWorkingDirectory();
   if (!WorkingDir)
     return WorkingDir.getError();