Add convenience method in FileSystem to check if a path/filespec is a directory.

[JDevlieghere]

Summary

Replace calls to LLVM's is_directory with calls to LLDB's FileSytem class. For this I introduced a new convenience method that, like the other methods, takes either a path or filespec.

[krytarowski]

Why? We already put a lot of effort into reusing code from LLVM.

[JDevlieghere]

In D54135#1288254, @krytarowski wrote:

Why? We already put a lot of effort into reusing code from LLVM.

This is still using code from LLVM, the FileSystem class is just an abstraction in between:

1. It uses LLVM's virtual file system. The VFS is stateful and the FileSystem class maintains this state. If you don't specify a virtual file system it uses the "real" file system (the default).
2. It has convenience methods for FileSpecs, so that you don't have to convert them at every call site. These functions used to be methods in the FileSpec class, something we wanted to get rid of for a while because conceptually the latter is just a "smart path".

I started doing all this work to support reproducers in LLDB. We'll need a bunch of files that won't live at their original location and the VFS makes it possible to deal with that transparently.

include/lldb/Host/FileSystem.h

public:
   /// @}
 
   /// Returns whether the given file is readable.
   /// @{
   bool Readable(const FileSpec &file_spec) const;
   bool Readable(const llvm::Twine &path) const;
   /// @}
 
+  /// Returns whether the given path is a directory.
+  /// @{
+  bool IsDirectory(const FileSpec &file_spec) const;
+  bool IsDirectory(const llvm::Twine &path) const;
+  /// @}
+
   /// Make the given file path absolute.
   /// @{
   std::error_code MakeAbsolute(llvm::SmallVectorImpl<char> &path) const;
   std::error_code MakeAbsolute(FileSpec &file_spec) const;
   /// @}
 
   /// Resolve path to make it canonical.
   /// @{

source/API/SBPlatform.cpp

SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
   return sb_error;
 }
 
 SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) {
   return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
     if (src.Exists()) {
       uint32_t permissions = FileSystem::Instance().GetPermissions(src.ref());
       if (permissions == 0) {
-        if (llvm::sys::fs::is_directory(src.ref().GetPath()))
+        if (FileSystem::Instance().IsDirectory(src.ref()))
           permissions = eFilePermissionsDirectoryDefault;
         else
           permissions = eFilePermissionsFileDefault;
       }
 
       return platform_sp->PutFile(src.ref(), dst.ref(), permissions);
     }
 

source/Core/Module.cpp

if (section_list && symbol_file) {
         // one
         obj_file->ClearSymtab();
 
         // The symbol file might be a directory bundle ("/tmp/a.out.dSYM")
         // instead of a full path to the symbol file within the bundle
         // ("/tmp/a.out.dSYM/Contents/Resources/DWARF/a.out"). So we need to
         // check this
 
-        if (llvm::sys::fs::is_directory(file.GetPath())) {
+        if (FileSystem::Instance().IsDirectory(file)) {
           std::string new_path(file.GetPath());
           std::string old_path(obj_file->GetFileSpec().GetPath());
           if (old_path.find(new_path) == 0) {
             // We specified the same bundle as the symbol file that we already
             // have
             return;
           }
         }

source/Core/ModuleList.cpp

Status ModuleList::GetSharedModule(const ModuleSpec &module_spec,
   }
 
   if (module_search_paths_ptr) {
     const auto num_directories = module_search_paths_ptr->GetSize();
     for (size_t idx = 0; idx < num_directories; ++idx) {
       auto search_path_spec = module_search_paths_ptr->GetFileSpecAtIndex(idx);
       FileSystem::Instance().Resolve(search_path_spec);
       namespace fs = llvm::sys::fs;
-      if (!fs::is_directory(search_path_spec.GetPath()))
+      if (!FileSystem::Instance().IsDirectory(search_path_spec))
         continue;
       search_path_spec.AppendPathComponent(
           module_spec.GetFileSpec().GetFilename().AsCString());
       if (!FileSystem::Instance().Exists(search_path_spec))
         continue;
 
       auto resolved_module_spec(module_spec);
       resolved_module_spec.GetFileSpec() = search_path_spec;

source/Host/common/FileSystem.cpp

 bool FileSystem::Readable(const Twine &path) const {
   return GetPermissions(path) & sys::fs::perms::all_read;
 }
 
 bool FileSystem::Readable(const FileSpec &file_spec) const {
   return Readable(file_spec.GetPath());
 }
 
+bool FileSystem::IsDirectory(const Twine &path) const {
+  ErrorOr<vfs::Status> status = m_fs->status(path);
+  if (!status)
+    return false;
+  return status->isDirectory();
+}
+
+bool FileSystem::IsDirectory(const FileSpec &file_spec) const {
+  return IsDirectory(file_spec.GetPath());
+}
+
 void FileSystem::EnumerateDirectory(Twine path, bool find_directories,
                                     bool find_files, bool find_other,
                                     EnumerateDirectoryCallbackType callback,
                                     void *callback_baton) {
   std::error_code EC;
   vfs::recursive_directory_iterator Iter(*m_fs, path, EC);
   vfs::recursive_directory_iterator End;
   for (; Iter != End && !EC; Iter.increment(EC)) {

source/Host/common/Symbols.cpp

if (module_uuid.IsValid()) {
       uuid_str.insert(2, 1, '/');
       uuid_str = uuid_str + ".debug";
     }
 
     size_t num_directories = debug_file_search_paths.GetSize();
     for (size_t idx = 0; idx < num_directories; ++idx) {
       FileSpec dirspec = debug_file_search_paths.GetFileSpecAtIndex(idx);
       FileSystem::Instance().Resolve(dirspec);
-      if (!llvm::sys::fs::is_directory(dirspec.GetPath()))
+      if (!FileSystem::Instance().IsDirectory(dirspec))
         continue;
 
       std::vector<std::string> files;
       std::string dirname = dirspec.GetPath();
 
       files.push_back(dirname + "/" + symbol_filename);
       files.push_back(dirname + "/.debug/" + symbol_filename);
       files.push_back(dirname + "/.build-id/" + uuid_str);

source/Host/macosx/Symbols.cpp

if (module_uuid.size() == 16) {
               log->Printf("DebugSymbols framework returned dSYM path of %s for "
                           "UUID %s -- looking for the dSYM",
                           path, uuid->GetAsString().c_str());
             }
             FileSpec dsym_filespec(path);
             if (path[0] == '~')
               FileSystem::Instance().Resolve(dsym_filespec);
 
-            if (llvm::sys::fs::is_directory(dsym_filespec.GetPath())) {
+            if (FileSystem::Instance().IsDirectory(dsym_filespec)) {
               dsym_filespec =
                   Symbols::FindSymbolFileInBundle(dsym_filespec, uuid, arch);
               ++items_found;
             } else {
               ++items_found;
             }
             return_module_spec.GetSymbolFileSpec() = dsym_filespec;
           }

source/Host/macosx/objcxx/Host.mm

 }
 
 using namespace lldb;
 using namespace lldb_private;
 
 bool Host::GetBundleDirectory(const FileSpec &file,
                               FileSpec &bundle_directory) {
 #if defined(__APPLE__)
-  if (llvm::sys::fs::is_directory(file.GetPath())) {
+  if (FileSystem::Instance().IsDirectory(file)) {
     char path[PATH_MAX];
     if (file.GetPath(path, sizeof(path))) {
       CFCBundle bundle(path);
       if (bundle.GetPath(path, sizeof(path))) {
         bundle_directory.SetFile(path, FileSpec::Style::native);
         return true;
       }
     }
   }
 #endif
   bundle_directory.Clear();
   return false;
 }
 
 bool Host::ResolveExecutableInBundle(FileSpec &file) {
 #if defined(__APPLE__)
-  if (llvm::sys::fs::is_directory(file.GetPath())) {
+  if (FileSystem::Instance().IsDirectory(file)) {
     char path[PATH_MAX];
     if (file.GetPath(path, sizeof(path))) {
       CFCBundle bundle(path);
       CFCReleaser<CFURLRef> url(bundle.CopyExecutableURL());
       if (url.get()) {
         if (::CFURLGetFileSystemRepresentation(url.get(), YES, (UInt8 *)path,
                                                sizeof(path))) {
           file.SetFile(path, FileSpec::Style::native);

source/Host/macosx/objcxx/HostInfoMacOSX.mm

#endif
     // dir are not both in the same dir.
     //
     // It is not going to work to do it by the executable path either,
     // as in the case of a python script, the executable is python, not
     // the lldb driver.
     raw_path.append("/../bin");
     FileSpec support_dir_spec(raw_path);
     FileSystem::Instance().Resolve(support_dir_spec);
-    if (!llvm::sys::fs::is_directory(support_dir_spec.GetPath())) {
+    if (!FileSystem::Instance().IsDirectory(support_dir_spec)) {
       Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
       if (log)
         log->Printf("HostInfoMacOSX::%s(): failed to find support directory",
                     __FUNCTION__);
       return false;
     }
 
     // Get normalization from support_dir_spec.  Note the FileSpec resolve

source/Plugins/ExpressionParser/Clang/ClangHost.cpp

return HostInfoPosix::ComputePathRelativeToLibrary(
       file_spec, (llvm::Twine("/lib") + CLANG_LIBDIR_SUFFIX + "/clang/" +
                   CLANG_VERSION_STRING)
                      .str());
 }
 
 #if defined(__APPLE__)
 
 static bool VerifyClangPath(const llvm::Twine &clang_path) {
-  if (llvm::sys::fs::is_directory(clang_path))
+  if (FileSystem::Instance().IsDirectory(clang_path))
     return true;
   Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
   if (log)
     log->Printf("VerifyClangPath(): "
                 "failed to stat clang resource directory at \"%s\"",
                 clang_path.str().c_str());
   return false;
 }

source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

for (size_t spi = 0, spe = module_search_paths.GetSize(); spi < spe; ++spi) {
     search_path_argument.append(search_path.GetPath());
 
     compiler_invocation_arguments.push_back(search_path_argument);
   }
 
   {
     FileSpec clang_resource_dir = GetClangResourceDir();
 
-    if (llvm::sys::fs::is_directory(clang_resource_dir.GetPath())) {
+    if (FileSystem::Instance().IsDirectory(clang_resource_dir.GetPath())) {
       compiler_invocation_arguments.push_back("-resource-dir");
       compiler_invocation_arguments.push_back(clang_resource_dir.GetPath());
     }
   }
 
   llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_engine =
       clang::CompilerInstance::createDiagnostics(new clang::DiagnosticOptions,
                                                  new StoringDiagnosticConsumer);

source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

if (!developer_dir_path_valid) {
             if (cmd_output_ptr[i] == '\r' || cmd_output_ptr[i] == '\n' ||
                 cmd_output_ptr[i] == '\0')
               break;
             developer_dir_path[i] = cmd_output_ptr[i];
           }
           developer_dir_path[i] = '\0';
 
           FileSpec devel_dir(developer_dir_path);
-          if (llvm::sys::fs::is_directory(devel_dir.GetPath())) {
+          if (FileSystem::Instance().IsDirectory(devel_dir)) {
             developer_dir_path_valid = true;
           }
         }
       }
     }
 
     if (developer_dir_path_valid) {
       temp_file_spec.SetFile(developer_dir_path, FileSpec::Style::native);
FileSystem::EnumerateDirectoryResult PlatformDarwin::DirectoryEnumerator(
 
   return FileSystem::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
 }
 
 FileSpec PlatformDarwin::FindSDKInXcodeForModules(SDKType sdk_type,
                                                   const FileSpec &sdks_spec) {
   // Look inside Xcode for the required installed iOS SDK version
 
-  if (!llvm::sys::fs::is_directory(sdks_spec.GetPath())) {
+  if (!FileSystem::Instance().IsDirectory(sdks_spec)) {
     return FileSpec();
   }
 
   const bool find_directories = true;
   const bool find_files = false;
   const bool find_other = true; // include symlinks
 
   SDKEnumeratorInfo enumerator_info;
 
   enumerator_info.sdk_type = sdk_type;
 
   FileSystem::Instance().EnumerateDirectory(
       sdks_spec.GetPath(), find_directories, find_files, find_other,
       DirectoryEnumerator, &enumerator_info);
 
-  if (llvm::sys::fs::is_directory(enumerator_info.found_path.GetPath()))
+  if (FileSystem::Instance().IsDirectory(enumerator_info.found_path))
     return enumerator_info.found_path;
   else
     return FileSpec();
 }
 
 FileSpec PlatformDarwin::GetSDKDirectoryForModules(SDKType sdk_type) {
   switch (sdk_type) {
   case SDKType::MacOSX:
#endif
 
   FileSpec sysroot_spec;
   // Scope for mutex locker below
   {
     std::lock_guard<std::mutex> guard(m_mutex);
     sysroot_spec = GetSDKDirectoryForModules(sdk_type);
   }
 
-  if (llvm::sys::fs::is_directory(sysroot_spec.GetPath())) {
+  if (FileSystem::Instance().IsDirectory(sysroot_spec.GetPath())) {
     options.push_back("-isysroot");
     options.push_back(sysroot_spec.GetPath());
   }
 }
 
 ConstString PlatformDarwin::GetFullNameForDylib(ConstString basename) {
   if (basename.IsEmpty())
     return basename;

source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

if (m_ios_debug_session != eLazyBoolYes) {
     AddRootSubdirsToSearchPaths(this, "/");
   }
 
   GetUserSpecifiedDirectoriesToSearch();
 
   // Add simple directory /Applications/Xcode.app/Contents/Developer/../Symbols
   FileSpec possible_dir(developer_dir + "/../Symbols");
   FileSystem::Instance().Resolve(possible_dir);
-  if (llvm::sys::fs::is_directory(possible_dir.GetPath()))
+  if (FileSystem::Instance().IsDirectory(possible_dir))
     m_search_directories.push_back(possible_dir);
 
   // Add simple directory of the current working directory
   FileSpec cwd(".");
   FileSystem::Instance().Resolve(cwd);
   m_search_directories_no_recursing.push_back(cwd);
 }
 
 void PlatformDarwinKernel::GetUserSpecifiedDirectoriesToSearch() {
   FileSpecList user_dirs(GetGlobalProperties()->GetKextDirectories());
   std::vector<FileSpec> possible_sdk_dirs;
 
   const uint32_t user_dirs_count = user_dirs.GetSize();
   for (uint32_t i = 0; i < user_dirs_count; i++) {
     FileSpec dir = user_dirs.GetFileSpecAtIndex(i);
     FileSystem::Instance().Resolve(dir);
-    if (llvm::sys::fs::is_directory(dir.GetPath())) {
+    if (FileSystem::Instance().IsDirectory(dir)) {
       m_search_directories.push_back(dir);
     }
   }
 }
 
 void PlatformDarwinKernel::AddRootSubdirsToSearchPaths(
     PlatformDarwinKernel *thisp, const std::string &dir) {
   const char *subdirs[] = {
       "/System/Library/Extensions", "/Library/Extensions",
       "/System/Library/Kernels",
       "/System/Library/Extensions/KDK", // this one probably only exist in
                                         // /AppleInternal/Developer/KDKs/*.kdk/...
       nullptr};
   for (int i = 0; subdirs[i] != nullptr; i++) {
     FileSpec testdir(dir + subdirs[i]);
     FileSystem::Instance().Resolve(testdir);
-    if (llvm::sys::fs::is_directory(testdir.GetPath()))
+    if (FileSystem::Instance().IsDirectory(testdir))
       thisp->m_search_directories.push_back(testdir);
   }
 
   // Look for kernel binaries in the top level directory, without any recursion
   thisp->m_search_directories_no_recursing.push_back(FileSpec(dir + "/"));
 }
 
 // Given a directory path dir, look for any subdirs named *.kdk and *.sdk
if ((strncmp(filename.GetCString(), "kernel", 6) == 0 ||
       return FileSystem::eEnumerateDirectoryResultNext;
     }
   } else if (ft == llvm::sys::fs::file_type::directory_file &&
              file_spec_extension == g_kext_suffix) {
     AddKextToMap(thisp, file_spec);
     // Look to see if there is a PlugIns subdir with more kexts
     FileSpec contents_plugins(file_spec.GetPath() + "/Contents/PlugIns");
     std::string search_here_too;
-    if (llvm::sys::fs::is_directory(contents_plugins.GetPath())) {
+    if (FileSystem::Instance().IsDirectory(contents_plugins)) {
       search_here_too = contents_plugins.GetPath();
     } else {
       FileSpec plugins(file_spec.GetPath() + "/PlugIns");
-      if (llvm::sys::fs::is_directory(plugins.GetPath())) {
+      if (FileSystem::Instance().IsDirectory(plugins)) {
         search_here_too = plugins.GetPath();
       }
     }
 
     if (!search_here_too.empty()) {
       const bool find_directories = true;
       const bool find_files = false;
       const bool find_other = false;

 //    /dir/dir/foo.kext/Contents/MacOS/foo.dSYM
 //    /dir/dir/foo.kext/foo.dSYM
 bool PlatformDarwinKernel::KextHasdSYMSibling(
     const FileSpec &kext_bundle_filepath) {
   FileSpec dsym_fspec = kext_bundle_filepath;
   std::string filename = dsym_fspec.GetFilename().AsCString();
   filename += ".dSYM";
   dsym_fspec.GetFilename() = ConstString(filename);
-  if (llvm::sys::fs::is_directory(dsym_fspec.GetPath())) {
+  if (FileSystem::Instance().IsDirectory(dsym_fspec)) {
     return true;
   }
   // Should probably get the CFBundleExecutable here or call
   // CFBundleCopyExecutableURL
 
   // Look for a deep bundle foramt
   ConstString executable_name =
       kext_bundle_filepath.GetFileNameStrippingExtension();
   std::string deep_bundle_str =
       kext_bundle_filepath.GetPath() + "/Contents/MacOS/";
   deep_bundle_str += executable_name.AsCString();
   deep_bundle_str += ".dSYM";
   dsym_fspec.SetFile(deep_bundle_str, FileSpec::Style::native);
   FileSystem::Instance().Resolve(dsym_fspec);
-  if (llvm::sys::fs::is_directory(dsym_fspec.GetPath())) {
+  if (FileSystem::Instance().IsDirectory(dsym_fspec)) {
     return true;
   }
 
   // look for a shallow bundle format
   //
   std::string shallow_bundle_str = kext_bundle_filepath.GetPath() + "/";
   shallow_bundle_str += executable_name.AsCString();
   shallow_bundle_str += ".dSYM";
   dsym_fspec.SetFile(shallow_bundle_str, FileSpec::Style::native);
   FileSystem::Instance().Resolve(dsym_fspec);
-  if (llvm::sys::fs::is_directory(dsym_fspec.GetPath())) {
+  if (FileSystem::Instance().IsDirectory(dsym_fspec)) {
     return true;
   }
   return false;
 }
 
 // Given a FileSpec of /dir/dir/mach.development.t7004 Return true if a dSYM
 // exists next to it:
 //    /dir/dir/mach.development.t7004.dSYM
 bool PlatformDarwinKernel::KernelHasdSYMSibling(const FileSpec &kernel_binary) {
   FileSpec kernel_dsym = kernel_binary;
   std::string filename = kernel_binary.GetFilename().AsCString();
   filename += ".dSYM";
   kernel_dsym.GetFilename() = ConstString(filename);
-  if (llvm::sys::fs::is_directory(kernel_dsym.GetPath())) {
+  if (FileSystem::Instance().IsDirectory(kernel_dsym)) {
     return true;
   }
   return false;
 }
 
 Status PlatformDarwinKernel::GetSharedModule(
     const ModuleSpec &module_spec, Process *process, ModuleSP &module_sp,
     const FileSpecList *module_search_paths_ptr, ModuleSP *old_module_sp_ptr,

source/Plugins/Process/Darwin/NativeProcessDarwin.cpp

Status NativeProcessProtocol::Launch(
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   Status error;
 
   // Verify the working directory is valid if one was specified.
   FileSpec working_dir(launch_info.GetWorkingDirectory());
   if (working_dir) {
     FileInstance::Instance().Resolve(working_dir);
-    if (!llvm::sys::fs::is_directory(working_dir.GetPath())) {
+    if (!FileSystem::Instance().IsDirectory(working_dir)) {
       error.SetErrorStringWithFormat("No such file or directory: %s",
                                    working_dir.GetCString());
       return error;
     }
   }
 
   // Launch the inferior.
   int pty_master_fd = -1;

source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

 }
 
 Status ProcessFreeBSD::DoLaunch(Module *module,
                                 ProcessLaunchInfo &launch_info) {
   Status error;
   assert(m_monitor == NULL);
 
   FileSpec working_dir = launch_info.GetWorkingDirectory();
-  namespace fs = llvm::sys::fs;
   if (working_dir) {
     FileSystem::Instance().Resolve(working_dir);
-    if (!fs::is_directory(working_dir.GetPath())) {
+    if (!FileSystem::Instance().IsDirectory(working_dir.GetPath())) {
       error.SetErrorStringWithFormat("No such file or directory: %s",
                                    working_dir.GetCString());
       return error;
     }
   }
 
   SetPrivateState(eStateLaunching);
 

source/Plugins/Process/Windows/Common/ProcessWindows.cpp

Status ProcessWindows::DoLaunch(Module *exe_module,
 
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
   Status result;
 
   FileSpec working_dir = launch_info.GetWorkingDirectory();
   namespace fs = llvm::sys::fs;
   if (working_dir) {
     FileSystem::Instance().Resolve(working_dir);
-    if (!fs::is_directory(working_dir.GetPath())) {
+    if (!FileSystem::Instance().IsDirectory(working_dir)) {
       result.SetErrorStringWithFormat("No such file or directory: %s",
                                       working_dir.GetCString());
       return result;
     }
   }
 
   if (!launch_info.GetFlags().Test(eLaunchFlagDebug)) {
     StreamString stream;

source/Target/TargetList.cpp

if (!FileSystem::Instance().Exists(file) && user_exe_path.startswith("~")) {
     else
       file = FileSpec(unglobbed_path.c_str());
   }
 
   bool user_exe_path_is_bundle = false;
   char resolved_bundle_exe_path[PATH_MAX];
   resolved_bundle_exe_path[0] = '\0';
   if (file) {
-    if (llvm::sys::fs::is_directory(file.GetPath()))
+    if (FileSystem::Instance().IsDirectory(file))
       user_exe_path_is_bundle = true;
 
     if (file.IsRelative() && !user_exe_path.empty()) {
       llvm::SmallString<64> cwd;
       if (! llvm::sys::fs::current_path(cwd)) {
         FileSpec cwd_file(cwd.c_str());
         cwd_file.AppendPathComponent(file);
         if (FileSystem::Instance().Exists(cwd_file))