[FileSystem] Remove GetPermissions() and Readable() from FileSpec

[JDevlieghere]

Summary

This patch removes the GetPermissions and GetReadable methods from FileSpec and updates its uses with calls to the FileSystem.

lldb/trunk/include/lldb/Utility/FileSpec.h

public:
   /// Existence test.
   ///
   /// @return
   ///     \b true if the file exists on disk, \b false otherwise.
   //------------------------------------------------------------------
   bool Exists() const;
 
   //------------------------------------------------------------------
-  /// Check if a file is readable by the current user
-  ///
-  /// @return
-  ///     \b true if the file exists on disk and is readable, \b false
-  ///     otherwise.
-  //------------------------------------------------------------------
-  bool Readable() const;
-
-  //------------------------------------------------------------------
   /// Expanded existence test.
   ///
   /// Call into the Host to see if it can help find the file (e.g. by
   /// searching paths set in the environment, etc.).
   ///
   /// If found, sets the value of m_directory to the directory where the file
   /// was found.
   ///
public:
   ///
   /// @return
   ///     Returns the filename without extension
   ///     as a ConstString object.
   //------------------------------------------------------------------
   ConstString GetFileNameStrippingExtension() const;
 
   //------------------------------------------------------------------
-  /// Return the current permissions of the path.
-  ///
-  /// Returns a bitmask for the current permissions of the file ( zero or more
-  /// of the permission bits defined in File::Permissions).
-  ///
-  /// @return
-  ///     Zero if the file doesn't exist or we are unable to get
-  ///     information for the file, otherwise one or more permission
-  ///     bits from the File::Permissions enumeration.
-  //------------------------------------------------------------------
-  uint32_t GetPermissions() const;
-
-  //------------------------------------------------------------------
   /// Get the memory cost of this object.
   ///
   /// Return the size in bytes that this object takes in memory. This returns
   /// the size in bytes of this object, not any shared string values it may
   /// refer to.
   ///
   /// @return
   ///     The number of bytes that this object occupies in memory.

lldb/trunk/source/API/SBPlatform.cpp

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

lldb/trunk/source/Commands/CommandObjectTarget.cpp

bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     if (core_file) {
       if (!core_file.Exists()) {
         result.AppendErrorWithFormat("core file '%s' doesn't exist",
                                      core_file.GetPath().c_str());
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
-      if (!core_file.Readable()) {
+      if (!FileSystem::Instance().Readable(core_file)) {
         result.AppendErrorWithFormat("core file '%s' is not readable",
                                      core_file.GetPath().c_str());
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
     }
 
     if (argc == 1 || core_file || remote_file) {
       FileSpec symfile(m_symbol_file.GetOptionValue().GetCurrentValue());
       if (symfile) {
         if (symfile.Exists()) {
-          if (!symfile.Readable()) {
+          if (!FileSystem::Instance().Readable(symfile)) {
             result.AppendErrorWithFormat("symbol file '%s' is not readable",
                                          symfile.GetPath().c_str());
             result.SetStatus(eReturnStatusFailed);
             return false;
           }
         } else {
           char symfile_path[PATH_MAX];
           symfile.GetPath(symfile_path, sizeof(symfile_path));
if (argc == 1 || core_file || remote_file) {
           ModuleSP module_sp = target_sp->GetSharedModule(main_module_spec);
           if (module_sp)
             module_sp->SetPlatformFileSpec(remote_file);
         }
         if (core_file) {
           char core_path[PATH_MAX];
           core_file.GetPath(core_path, sizeof(core_path));
           if (core_file.Exists()) {
-            if (!core_file.Readable()) {
+            if (!FileSystem::Instance().Readable(core_file)) {
               result.AppendMessageWithFormat(
                   "Core file '%s' is not readable.\n", core_path);
               result.SetStatus(eReturnStatusFailed);
               return false;
             }
             FileSpec core_file_dir;
             core_file_dir.GetDirectory() = core_file.GetDirectory();
             target_sp->GetExecutableSearchPaths().Append(core_file_dir);

lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

bool RenderScriptRuntime::LoadAllocation(Stream &strm, const uint32_t alloc_id,
   // Check we can read from file
   FileSpec file(path, true);
   if (!file.Exists()) {
     strm.Printf("Error: File %s does not exist", path);
     strm.EOL();
     return false;
   }
 
-  if (!file.Readable()) {
+  if (!FileSystem::Instance().Readable(file)) {
     strm.Printf("Error: File %s does not have readable permissions", path);
     strm.EOL();
     return false;
   }
 
   // Read file into data buffer
   auto data_sp = DataBufferLLVM::CreateFromPath(file.GetPath());
 

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformAppleTVSimulator.cpp

for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
 
         if (idx > 0)
           arch_names.PutCString(", ");
         arch_names.PutCString(platform_arch.GetArchitectureName());
       }
     }
 
     if (error.Fail() || !exe_module_sp) {
-      if (resolved_module_spec.GetFileSpec().Readable()) {
+      if (FileSystem::Instance().Readable(resolved_module_spec.GetFileSpec())) {
         error.SetErrorStringWithFormat(
             "'%s' doesn't contain any '%s' platform architectures: %s",
             resolved_module_spec.GetFileSpec().GetPath().c_str(),
             GetPluginName().GetCString(), arch_names.GetString().str().c_str());
       } else {
         error.SetErrorStringWithFormat(
             "'%s' is not readable",
             resolved_module_spec.GetFileSpec().GetPath().c_str());

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformAppleWatchSimulator.cpp

for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
 
         if (idx > 0)
           arch_names.PutCString(", ");
         arch_names.PutCString(platform_arch.GetArchitectureName());
       }
     }
 
     if (error.Fail() || !exe_module_sp) {
-      if (resolved_module_spec.GetFileSpec().Readable()) {
+      if (FileSystem::Instance().Readable(resolved_module_spec.GetFileSpec())) {
         error.SetErrorStringWithFormat(
             "'%s' doesn't contain any '%s' platform architectures: %s",
             resolved_module_spec.GetFileSpec().GetPath().c_str(),
             GetPluginName().GetCString(), arch_names.GetString().str().c_str());
       } else {
         error.SetErrorStringWithFormat(
             "'%s' is not readable",
             resolved_module_spec.GetFileSpec().GetPath().c_str());

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.cpp

for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
 
       if (idx > 0)
         arch_names.PutCString(", ");
       arch_names.PutCString(
           resolved_module_spec.GetArchitecture().GetArchitectureName());
     }
 
     if (error.Fail() || !exe_module_sp) {
-      if (resolved_module_spec.GetFileSpec().Readable()) {
+      if (FileSystem::Instance().Readable(resolved_module_spec.GetFileSpec())) {
         error.SetErrorStringWithFormat(
             "'%s' doesn't contain any '%s' platform architectures: %s",
             resolved_module_spec.GetFileSpec().GetPath().c_str(),
             GetPluginName().GetCString(), arch_names.GetData());
       } else {
         error.SetErrorStringWithFormat(
             "'%s' is not readable",
             resolved_module_spec.GetFileSpec().GetPath().c_str());

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp

for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
 
         if (idx > 0)
           arch_names.PutCString(", ");
         arch_names.PutCString(platform_arch.GetArchitectureName());
       }
     }
 
     if (error.Fail() || !exe_module_sp) {
-      if (resolved_module_spec.GetFileSpec().Readable()) {
+      if (FileSystem::Instance().Readable(resolved_module_spec.GetFileSpec())) {
         error.SetErrorStringWithFormat(
             "'%s' doesn't contain any '%s' platform architectures: %s",
             resolved_module_spec.GetFileSpec().GetPath().c_str(),
             GetPluginName().GetCString(), arch_names.GetString().str().c_str());
       } else {
         error.SetErrorStringWithFormat(
             "'%s' is not readable",
             resolved_module_spec.GetFileSpec().GetPath().c_str());

lldb/trunk/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

if (!resolved_module_spec.GetFileSpec().Exists())
       resolved_module_spec.GetFileSpec().ResolveExecutableLocation();
 
     // Resolve any executable within a bundle on MacOSX
     Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
 
     if (resolved_module_spec.GetFileSpec().Exists())
       error.Clear();
     else {
-      const uint32_t permissions =
-          resolved_module_spec.GetFileSpec().GetPermissions();
+      const uint32_t permissions = FileSystem::Instance().GetPermissions(
+          resolved_module_spec.GetFileSpec());
       if (permissions && (permissions & eFilePermissionsEveryoneR) == 0)
         error.SetErrorStringWithFormat(
             "executable '%s' is not readable",
             resolved_module_spec.GetFileSpec().GetPath().c_str());
       else
         error.SetErrorStringWithFormat(
             "unable to find executable for '%s'",
             resolved_module_spec.GetFileSpec().GetPath().c_str());
// it another try.
 
         if (idx > 0)
           arch_names.PutCString(", ");
         arch_names.PutCString(
             resolved_module_spec.GetArchitecture().GetArchitectureName());
       }
 
       if (error.Fail() || !exe_module_sp) {
-        if (resolved_module_spec.GetFileSpec().Readable()) {
+        if (FileSystem::Instance().Readable(
+                resolved_module_spec.GetFileSpec())) {
           error.SetErrorStringWithFormat(
               "'%s' doesn't contain any '%s' platform architectures: %s",
               resolved_module_spec.GetFileSpec().GetPath().c_str(),
               GetPluginName().GetCString(), arch_names.GetData());
         } else {
           error.SetErrorStringWithFormat(
               "'%s' is not readable",
               resolved_module_spec.GetFileSpec().GetPath().c_str());

lldb/trunk/source/Plugins/Platform/Windows/PlatformWindows.cpp

if (resolved_module_spec.GetArchitecture().IsValid()) {
 
         if (idx > 0)
           arch_names.PutCString(", ");
         arch_names.PutCString(
             resolved_module_spec.GetArchitecture().GetArchitectureName());
       }
 
       if (error.Fail() || !exe_module_sp) {
-        if (resolved_module_spec.GetFileSpec().Readable()) {
+        if (FileSystem::Instance().Readable(
+                resolved_module_spec.GetFileSpec())) {
           error.SetErrorStringWithFormat(
               "'%s' doesn't contain any '%s' platform architectures: %s",
               resolved_module_spec.GetFileSpec().GetPath().c_str(),
               GetPluginName().GetCString(), arch_names.GetData());
         } else {
           error.SetErrorStringWithFormat(
               "'%s' is not readable",
               resolved_module_spec.GetFileSpec().GetPath().c_str());

lldb/trunk/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
 
       if (idx > 0)
         arch_names.PutCString(", ");
       arch_names.PutCString(
           resolved_module_spec.GetArchitecture().GetArchitectureName());
     }
 
     if (error.Fail() || !exe_module_sp) {
-      if (resolved_module_spec.GetFileSpec().Readable()) {
+      if (FileSystem::Instance().Readable(resolved_module_spec.GetFileSpec())) {
         error.SetErrorStringWithFormat(
             "'%s' doesn't contain any '%s' platform architectures: %s",
             resolved_module_spec.GetFileSpec().GetPath().c_str(),
             GetPluginName().GetCString(), arch_names.GetData());
       } else {
         error.SetErrorStringWithFormat(
             "'%s' is not readable",
             resolved_module_spec.GetFileSpec().GetPath().c_str());

lldb/trunk/source/Target/Platform.cpp

Status Platform::Install(const FileSpec &src, const FileSpec &dst) {
 
   if (GetSupportsRSync()) {
     error = PutFile(src, dst);
   } else {
     namespace fs = llvm::sys::fs;
     switch (fs::get_file_type(src.GetPath(), false)) {
     case fs::file_type::directory_file: {
       llvm::sys::fs::remove(fixed_dst.GetPath());
-      uint32_t permissions = src.GetPermissions();
+      uint32_t permissions = FileSystem::Instance().GetPermissions(src);
       if (permissions == 0)
         permissions = eFilePermissionsDirectoryDefault;
       error = MakeDirectory(fixed_dst, permissions);
       if (error.Success()) {
         // Make a filespec that only fills in the directory of a FileSpec so
         // when we enumerate we can quickly fill in the filename for dst copies
         FileSpec recurse_dst;
         recurse_dst.GetDirectory().SetCString(fixed_dst.GetCString());

lldb/trunk/source/Utility/FileSpec.cpp

void FileSpec::Dump(Stream *s) const {
   }
 }
 
 //------------------------------------------------------------------
 // Returns true if the file exists.
 //------------------------------------------------------------------
 bool FileSpec::Exists() const { return llvm::sys::fs::exists(GetPath()); }
 
-bool FileSpec::Readable() const {
-  return GetPermissions() & llvm::sys::fs::perms::all_read;
-}
-
 bool FileSpec::ResolveExecutableLocation() {
   // CLEANUP: Use StringRef for string handling.
   if (!m_directory) {
     const char *file_cstr = m_filename.GetCString();
     if (file_cstr) {
       const std::string file_str(file_cstr);
       llvm::ErrorOr<std::string> error_or_path =
           llvm::sys::findProgramByName(file_str);
bool FileSpec::ResolvePath() {
 
   // SetFile(...) will set m_is_resolved correctly if it can resolve the path
   SetFile(GetPath(false), true);
   return m_is_resolved;
 }
 
 FileSpec::Style FileSpec::GetPathStyle() const { return m_style; }
 
-uint32_t FileSpec::GetPermissions() const {
-  namespace fs = llvm::sys::fs;
-  fs::file_status st;
-  if (fs::status(GetPath(), st, false))
-    return fs::perms::perms_not_known;
-
-  return st.permissions();
-}
-
 //------------------------------------------------------------------
 // Directory string get accessor.
 //------------------------------------------------------------------
 ConstString &FileSpec::GetDirectory() { return m_directory; }
 
 //------------------------------------------------------------------
 // Directory string const get accessor.
 //------------------------------------------------------------------