FileSpec: Remove PathSyntax enum and use llvm version instead

[labath]

Summary

The llvm version of the enum has the same enumerators, with stlightly
different names, so this is mostly just a search&replace exercise. One
concrete benefit of this is that we can remove the function for
converting between the two enums.

To avoid typing llvm::sys::path::Style::windows everywhere I import the
enum into the FileSpec class, so it can be referenced as
FileSpec::Style::windows.

[clayborg]

Fine to use llvm's enum as long as we don't export the style through the SB API

[labath]

We don't export the style right now. At some point we may need to teach SBFileSpec about path styles, but at that point I'd just do the translation at the SB level, and let everyone else use the llvm enum.

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

 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Utility/ConstString.h"
 
 #include "llvm/ADT/StringRef.h" // for StringRef
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/Path.h"
 
 #include <stddef.h> // for size_t
 #include <stdint.h> // for uint32_t, uint64_t
 
 namespace lldb_private {
 class Stream;
 }
 namespace llvm {

 /// line, or specifying a module (shared library) to limit the scope in which
 /// to execute a command. The user rarely types in a full path. When the paths
 /// are already split up, it makes it easy for us to compare only the
 /// basenames of a lot of file specifications without having to split up the
 /// file path each time to get to the basename.
 //----------------------------------------------------------------------
 class FileSpec {
 public:
-  enum PathSyntax : unsigned char {
-    ePathSyntaxPosix,
-    ePathSyntaxWindows,
-    ePathSyntaxHostNative
-  };
+  using Style = llvm::sys::path::Style;
 
   FileSpec();
 
   //------------------------------------------------------------------
   /// Constructor with path.
   ///
   /// Takes a path to a file which can be just a filename, or a full path. If
   /// \a path is not nullptr or empty, this function will call
   /// FileSpec::SetFile (const char *path, bool resolve).
   ///
   /// @param[in] path
   ///     The full or partial path to a file.
   ///
   /// @param[in] resolve_path
   ///     If \b true, then we resolve the path, removing stray ../.. and so
   ///     forth,
   ///     if \b false we trust the path is in canonical form already.
   ///
   /// @see FileSpec::SetFile (const char *path, bool resolve)
   //------------------------------------------------------------------
   explicit FileSpec(llvm::StringRef path, bool resolve_path,
-                    PathSyntax syntax = ePathSyntaxHostNative);
+                    Style style = Style::native);
 
   explicit FileSpec(llvm::StringRef path, bool resolve_path,
                     const llvm::Triple &Triple);
 
   //------------------------------------------------------------------
   /// Copy constructor
   ///
   /// Makes a copy of the uniqued directory and filename strings from \a rhs.
public:
 
   //------------------------------------------------------------------
   /// Case sensitivity of path.
   ///
   /// @return
   ///     \b true if the file path is case sensitive (POSIX), false
   ///   if case insensitive (Windows).
   //------------------------------------------------------------------
-  bool IsCaseSensitive() const { return m_syntax != ePathSyntaxWindows; }
+  bool IsCaseSensitive() const { return m_style != Style::windows; }
 
   //------------------------------------------------------------------
   /// Dump this object to a Stream.
   ///
   /// Dump the object to the supplied stream \a s. If the object contains a
   /// valid directory name, it will be displayed followed by a directory
   /// delimiter, and the filename.
   ///
public:
   /// Canonicalize this file path (basically running the static
   /// FileSpec::Resolve method on it). Useful if you asked us not to resolve
   /// the file path when you set the file.
   //------------------------------------------------------------------
   bool ResolvePath();
 
   uint64_t GetByteSize() const;
 
-  PathSyntax GetPathSyntax() const;
+  Style GetPathStyle() const;
 
   //------------------------------------------------------------------
   /// Directory string get accessor.
   ///
   /// @return
   ///     A reference to the directory string object.
   //------------------------------------------------------------------
   ConstString &GetDirectory();
public:
   /// @param[in] path
   ///     A full, partial, or relative path to a file.
   ///
   /// @param[in] resolve_path
   ///     If \b true, then we will try to resolve links the path using
   ///     the static FileSpec::Resolve.
   //------------------------------------------------------------------
   void SetFile(llvm::StringRef path, bool resolve_path,
-               PathSyntax syntax = ePathSyntaxHostNative);
+               Style style = Style::native);
 
   void SetFile(llvm::StringRef path, bool resolve_path,
                const llvm::Triple &Triple);
 
   bool IsResolved() const { return m_is_resolved; }
 
   //------------------------------------------------------------------
   /// Set if the file path has been resolved or not.

 
 protected:
   //------------------------------------------------------------------
   // Member variables
   //------------------------------------------------------------------
   ConstString m_directory;            ///< The uniqued directory path
   ConstString m_filename;             ///< The uniqued filename path
   mutable bool m_is_resolved = false; ///< True if this path has been resolved.
-  PathSyntax
-      m_syntax; ///< The syntax that this path uses (e.g. Windows / Posix)
+  Style m_style; ///< The syntax that this path uses (e.g. Windows / Posix)
 };
 
 //----------------------------------------------------------------------
 /// Dump a FileSpec object to a stream
 //----------------------------------------------------------------------
 Stream &operator<<(Stream &s, const FileSpec &f);
 
 } // namespace lldb_private

lldb/trunk/source/Plugins/Platform/Android/PlatformAndroid.cpp

Status PlatformAndroid::ConnectRemote(Args &args) {
   return error;
 }
 
 Status PlatformAndroid::GetFile(const FileSpec &source,
                                 const FileSpec &destination) {
   if (IsHost() || !m_remote_platform_sp)
     return PlatformLinux::GetFile(source, destination);
 
-  FileSpec source_spec(source.GetPath(false), false,
-                       FileSpec::ePathSyntaxPosix);
+  FileSpec source_spec(source.GetPath(false), false, FileSpec::Style::posix);
   if (source_spec.IsRelative())
     source_spec = GetRemoteWorkingDirectory().CopyByAppendingPathComponent(
         source_spec.GetCString(false));
 
   Status error;
   auto sync_service = GetSyncService(error);
   if (error.Fail())
     return error;

 
 Status PlatformAndroid::PutFile(const FileSpec &source,
                                 const FileSpec &destination, uint32_t uid,
                                 uint32_t gid) {
   if (IsHost() || !m_remote_platform_sp)
     return PlatformLinux::PutFile(source, destination, uid, gid);
 
   FileSpec destination_spec(destination.GetPath(false), false,
-                            FileSpec::ePathSyntaxPosix);
+                            FileSpec::Style::posix);
   if (destination_spec.IsRelative())
     destination_spec = GetRemoteWorkingDirectory().CopyByAppendingPathComponent(
         destination_spec.GetCString(false));
 
   // TODO: Set correct uid and gid on remote file.
   Status error;
   auto sync_service = GetSyncService(error);
   if (error.Fail())

lldb/trunk/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

bool SymbolFilePDB::ParseCompileUnitSupportFiles(
   auto compiland_up = GetPDBCompilandByUID(sc.comp_unit->GetID());
   if (!compiland_up)
     return false;
   auto files = m_session_up->getSourceFilesForCompiland(*compiland_up);
   if (!files || files->getChildCount() == 0)
     return false;
 
   while (auto file = files->getNext()) {
-    FileSpec spec(file->getFileName(), false, FileSpec::ePathSyntaxWindows);
+    FileSpec spec(file->getFileName(), false, FileSpec::Style::windows);
     support_files.AppendIfUnique(spec);
   }
   return true;
 }
 
 bool SymbolFilePDB::ParseImportedModules(
     const lldb_private::SymbolContext &sc,
     std::vector<lldb_private::ConstString> &imported_modules) {
while (auto compiland = compilands->getNext()) {
       // If we're not checking inlines, then don't add line information for
       // this file unless the FileSpec matches. For inline functions, we don't
       // have to match the FileSpec since they could be defined in headers
       // other than file specified in FileSpec.
       if (!check_inlines) {
         std::string source_file = compiland->getSourceFileFullPath();
         if (source_file.empty())
           continue;
-        FileSpec this_spec(source_file, false, FileSpec::ePathSyntaxWindows);
+        FileSpec this_spec(source_file, false, FileSpec::Style::windows);
         bool need_full_match = !file_spec.GetDirectory().IsEmpty();
         if (FileSpec::Compare(file_spec, this_spec, need_full_match) != 0)
           continue;
       }
 
       SymbolContext sc;
       auto cu = ParseCompileUnitForUID(compiland->getSymIndexId());
       if (!cu)

lldb/trunk/source/Utility/FileSpec.cpp

 
 #include "llvm/ADT/SmallString.h" // for SmallString
 #include "llvm/ADT/SmallVector.h" // for SmallVectorTemplat...
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"         // for Triple
 #include "llvm/ADT/Twine.h"          // for Twine
 #include "llvm/Support/ErrorOr.h"    // for ErrorOr
 #include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h" // for raw_ostream, fs
 
 #include <algorithm>    // for replace, min, unique
 #include <system_error> // for error_code
 #include <vector>       // for vector
 
 #include <assert.h> // for assert
 #include <stdio.h>  // for size_t, NULL, snpr...
 #include <string.h> // for strcmp
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 
-static constexpr FileSpec::PathSyntax GetNativeSyntax() {
+static constexpr FileSpec::Style GetNativeStyle() {
 #if defined(_WIN32)
-  return FileSpec::ePathSyntaxWindows;
+  return FileSpec::Style::windows;
 #else
-  return FileSpec::ePathSyntaxPosix;
+  return FileSpec::Style::posix;
 #endif
 }
 
-bool PathSyntaxIsPosix(FileSpec::PathSyntax syntax) {
-  return (syntax == FileSpec::ePathSyntaxPosix ||
-          (syntax == FileSpec::ePathSyntaxHostNative &&
-           GetNativeSyntax() == FileSpec::ePathSyntaxPosix));
+bool PathStyleIsPosix(FileSpec::Style style) {
+  return (style == FileSpec::Style::posix ||
+          (style == FileSpec::Style::native &&
+           GetNativeStyle() == FileSpec::Style::posix));
 }
 
-const char *GetPathSeparators(FileSpec::PathSyntax syntax) {
-  return PathSyntaxIsPosix(syntax) ? "/" : "\\/";
+const char *GetPathSeparators(FileSpec::Style style) {
+  return PathStyleIsPosix(style) ? "/" : "\\/";
 }
 
-char GetPreferredPathSeparator(FileSpec::PathSyntax syntax) {
-  return GetPathSeparators(syntax)[0];
+char GetPreferredPathSeparator(FileSpec::Style style) {
+  return GetPathSeparators(style)[0];
 }
 
-bool IsPathSeparator(char value, FileSpec::PathSyntax syntax) {
-  return value == '/' || (!PathSyntaxIsPosix(syntax) && value == '\\');
+bool IsPathSeparator(char value, FileSpec::Style style) {
+  return value == '/' || (!PathStyleIsPosix(style) && value == '\\');
 }
 
-inline llvm::sys::path::Style
-LLVMPathSyntax(FileSpec::PathSyntax lldb_syntax) {
-  switch (lldb_syntax) {
-    case FileSpec::ePathSyntaxPosix:
-      return llvm::sys::path::Style::posix;
-    case FileSpec::ePathSyntaxWindows:
-      return llvm::sys::path::Style::windows;
-    case FileSpec::ePathSyntaxHostNative:
-      return llvm::sys::path::Style::native;
-  };
-  return llvm::sys::path::Style::native;
-}
-
-void Denormalize(llvm::SmallVectorImpl<char> &path,
-                 FileSpec::PathSyntax syntax) {
-  if (PathSyntaxIsPosix(syntax))
+void Denormalize(llvm::SmallVectorImpl<char> &path, FileSpec::Style style) {
+  if (PathStyleIsPosix(style))
     return;
 
   std::replace(path.begin(), path.end(), '/', '\\');
 }
 } // end anonymous namespace
 
 void FileSpec::Resolve(llvm::SmallVectorImpl<char> &path) {
   if (path.empty())
     return;
 
   llvm::SmallString<32> Source(path.begin(), path.end());
   StandardTildeExpressionResolver Resolver;
   Resolver.ResolveFullPath(Source, path);
 
   // Save a copy of the original path that's passed in
   llvm::SmallString<128> original_path(path.begin(), path.end());
 
   llvm::sys::fs::make_absolute(path);
   if (!llvm::sys::fs::exists(path)) {
     path.clear();
     path.append(original_path.begin(), original_path.end());
   }
 }
 
-FileSpec::FileSpec() : m_syntax(GetNativeSyntax()) {}
+FileSpec::FileSpec() : m_style(GetNativeStyle()) {}
 
 //------------------------------------------------------------------
 // Default constructor that can take an optional full path to a file on disk.
 //------------------------------------------------------------------
-FileSpec::FileSpec(llvm::StringRef path, bool resolve_path, PathSyntax syntax)
-    : m_syntax(syntax) {
-  SetFile(path, resolve_path, syntax);
+FileSpec::FileSpec(llvm::StringRef path, bool resolve_path, Style style)
+    : m_style(style) {
+  SetFile(path, resolve_path, style);
 }
 
 FileSpec::FileSpec(llvm::StringRef path, bool resolve_path,
                    const llvm::Triple &Triple)
     : FileSpec{path, resolve_path,
-               Triple.isOSWindows() ? ePathSyntaxWindows : ePathSyntaxPosix} {}
+               Triple.isOSWindows() ? Style::windows : Style::posix} {}
 
 //------------------------------------------------------------------
 // Copy constructor
 //------------------------------------------------------------------
 FileSpec::FileSpec(const FileSpec &rhs)
     : m_directory(rhs.m_directory), m_filename(rhs.m_filename),
-      m_is_resolved(rhs.m_is_resolved), m_syntax(rhs.m_syntax) {}
+      m_is_resolved(rhs.m_is_resolved), m_style(rhs.m_style) {}
 
 //------------------------------------------------------------------
 // Copy constructor
 //------------------------------------------------------------------
 FileSpec::FileSpec(const FileSpec *rhs) : m_directory(), m_filename() {
   if (rhs)
     *this = *rhs;
 }

 //------------------------------------------------------------------
 // Assignment operator.
 //------------------------------------------------------------------
 const FileSpec &FileSpec::operator=(const FileSpec &rhs) {
   if (this != &rhs) {
     m_directory = rhs.m_directory;
     m_filename = rhs.m_filename;
     m_is_resolved = rhs.m_is_resolved;
-    m_syntax = rhs.m_syntax;
+    m_style = rhs.m_style;
   }
   return *this;
 }
 
 //------------------------------------------------------------------
 // Update the contents of this object with a new path. The path will be split
 // up into a directory and filename and stored as uniqued string values for
 // quick comparison and efficient memory usage.
 //------------------------------------------------------------------
-void FileSpec::SetFile(llvm::StringRef pathname, bool resolve,
-                       PathSyntax syntax) {
+void FileSpec::SetFile(llvm::StringRef pathname, bool resolve, Style style) {
   m_filename.Clear();
   m_directory.Clear();
   m_is_resolved = false;
-  m_syntax = (syntax == ePathSyntaxHostNative) ? GetNativeSyntax() : syntax;
+  m_style = (style == Style::native) ? GetNativeStyle() : style;
 
   if (pathname.empty())
     return;
 
   llvm::SmallString<64> resolved(pathname);
 
   if (resolve) {
     FileSpec::Resolve(resolved);
     m_is_resolved = true;
   }
 
   // Normalize the path by removing ".", ".." and other redundant components.
   if (needsNormalization(resolved))
-    llvm::sys::path::remove_dots(resolved, true, LLVMPathSyntax(m_syntax));
+    llvm::sys::path::remove_dots(resolved, true, m_style);
 
   // Normalize back slashes to forward slashes
-  if (m_syntax == FileSpec::ePathSyntaxWindows)
+  if (m_style == Style::windows)
     std::replace(resolved.begin(), resolved.end(), '\\', '/');
 
-  auto style = LLVMPathSyntax(syntax);
-  m_filename.SetString(llvm::sys::path::filename(resolved, style));
-  llvm::StringRef dir = llvm::sys::path::parent_path(resolved, style);
+  m_filename.SetString(llvm::sys::path::filename(resolved, m_style));
+  llvm::StringRef dir = llvm::sys::path::parent_path(resolved, m_style);
   if (!dir.empty())
     m_directory.SetString(dir);
 }
 
 void FileSpec::SetFile(llvm::StringRef path, bool resolve,
                        const llvm::Triple &Triple) {
   return SetFile(path, resolve,
-                 Triple.isOSWindows() ? ePathSyntaxWindows : ePathSyntaxPosix);
+                 Triple.isOSWindows() ? Style::windows : Style::posix);
 }
 
 //----------------------------------------------------------------------
 // Convert to pointer operator. This allows code to check any FileSpec objects
 // to see if they contain anything valid using code such as:
 //
 //  if (file_spec)
 //  {}

 // Dump the object to the supplied stream. If the object contains a valid
 // directory name, it will be displayed followed by a directory delimiter, and
 // the filename.
 //------------------------------------------------------------------
 void FileSpec::Dump(Stream *s) const {
   if (s) {
     std::string path{GetPath(true)};
     s->PutCString(path);
-    char path_separator = GetPreferredPathSeparator(m_syntax);
+    char path_separator = GetPreferredPathSeparator(m_style);
     if (!m_filename && !path.empty() && path.back() != path_separator)
       s->PutChar(path_separator);
   }
 }
 
 //------------------------------------------------------------------
 // Returns true if the file exists.
 //------------------------------------------------------------------

 
 uint64_t FileSpec::GetByteSize() const {
   uint64_t Size = 0;
   if (llvm::sys::fs::file_size(GetPath(), Size))
     return 0;
   return Size;
 }
 
-FileSpec::PathSyntax FileSpec::GetPathSyntax() const { return m_syntax; }
+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();
void FileSpec::GetPath(llvm::SmallVectorImpl<char> &path,
   // objects, we don't need to look for the actual syntax specific path
   // separator, we just look for and insert '/'.
   if (m_directory && m_filename && m_directory.GetStringRef().back() != '/' &&
       m_filename.GetStringRef().back() != '/')
     path.insert(path.end(), '/');
   path.append(m_filename.GetStringRef().begin(),
               m_filename.GetStringRef().end());
   if (denormalize && !path.empty())
-    Denormalize(path, m_syntax);
+    Denormalize(path, m_style);
 }
 
 ConstString FileSpec::GetFileNameExtension() const {
   if (m_filename) {
     const char *filename = m_filename.GetCString();
     const char *dot_pos = strrchr(filename, '.');
     if (dot_pos && dot_pos[1] != '\0')
       return ConstString(dot_pos + 1);
if (m_directory) {
     ConstString result(penultimate_slash_ptr + 1,
                        last_slash_ptr - penultimate_slash_ptr);
     return result;
   }
   return ConstString();
 }
 
 static std::string
-join_path_components(FileSpec::PathSyntax syntax,
+join_path_components(FileSpec::Style style,
                      const std::vector<llvm::StringRef> components) {
   std::string result;
   for (size_t i = 0; i < components.size(); ++i) {
     if (components[i].empty())
       continue;
     result += components[i];
     if (i != components.size() - 1 &&
-        !IsPathSeparator(components[i].back(), syntax))
-      result += GetPreferredPathSeparator(syntax);
+        !IsPathSeparator(components[i].back(), style))
+      result += GetPreferredPathSeparator(style);
   }
 
   return result;
 }
 
 void FileSpec::PrependPathComponent(llvm::StringRef component) {
   if (component.empty())
     return;
 
   const bool resolve = false;
   if (m_filename.IsEmpty() && m_directory.IsEmpty()) {
     SetFile(component, resolve);
     return;
   }
 
   std::string result =
-      join_path_components(m_syntax, {component, m_directory.GetStringRef(),
-                                      m_filename.GetStringRef()});
-  SetFile(result, resolve, m_syntax);
+      join_path_components(m_style, {component, m_directory.GetStringRef(),
+  SetFile(result, resolve, m_style);
 }
 
 void FileSpec::PrependPathComponent(const FileSpec &new_path) {
   return PrependPathComponent(new_path.GetPath(false));
 }
 
 void FileSpec::AppendPathComponent(llvm::StringRef component) {
   if (component.empty())
     return;
 
   component = component.drop_while(
-      [this](char c) { return IsPathSeparator(c, m_syntax); });
+      [this](char c) { return IsPathSeparator(c, m_style); });
 
   std::string result =
-      join_path_components(m_syntax, {m_directory.GetStringRef(),
-                                      m_filename.GetStringRef(), component});
+      join_path_components(m_style, {m_directory.GetStringRef(),
 
-  SetFile(result, false, m_syntax);
+  SetFile(result, false, m_style);
 }
 
 void FileSpec::AppendPathComponent(const FileSpec &new_path) {
   return AppendPathComponent(new_path.GetPath(false));
 }
 
 void FileSpec::RemoveLastPathComponent() {
   // CLEANUP: Use StringRef for string handling.
bool FileSpec::IsSourceImplementationFile() const {
   return g_source_file_regex.Execute(extension.GetStringRef());
 }
 
 bool FileSpec::IsRelative() const {
   const char *dir = m_directory.GetCString();
   llvm::StringRef directory(dir ? dir : "");
 
   if (directory.size() > 0) {
-    if (PathSyntaxIsPosix(m_syntax)) {
+    if (PathStyleIsPosix(m_style)) {
       // If the path doesn't start with '/' or '~', return true
       switch (directory[0]) {
       case '/':
       case '~':
         return false;
       default:
         return true;
       }
void llvm::format_provider<FileSpec>::format(const FileSpec &F,
   }
 
   // Style is either D or empty, either way we need to print the directory.
   if (!dir.empty()) {
     // Directory is stored in normalized form, which might be different than
     // preferred form.  In order to handle this, we need to cut off the
     // filename, then denormalize, then write the entire denorm'ed directory.
     llvm::SmallString<64> denormalized_dir = dir;
-    Denormalize(denormalized_dir, F.GetPathSyntax());
+    Denormalize(denormalized_dir, F.GetPathStyle());
     Stream << denormalized_dir;
-    Stream << GetPreferredPathSeparator(F.GetPathSyntax());
+    Stream << GetPreferredPathSeparator(F.GetPathStyle());
   }
 
   if (Style.equals_lower("D")) {
     // We only want to print the directory, so now just exit.
     if (dir.empty())
       Stream << "(empty)";
     return;
   }
 
   if (!file.empty())
     Stream << file;
 }

lldb/trunk/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

TEST_F(GDBRemoteCommunicationClientTest, SyncThreadState) {
   HandlePacket(server, "QSyncThreadState:0047;", "OK");
   ASSERT_TRUE(async_result.get());
 }
 
 TEST_F(GDBRemoteCommunicationClientTest, GetModulesInfo) {
   llvm::Triple triple("i386-pc-linux");
 
   FileSpec file_specs[] = {
-      FileSpec("/foo/bar.so", false, FileSpec::ePathSyntaxPosix),
-      FileSpec("/foo/baz.so", false, FileSpec::ePathSyntaxPosix),
+      FileSpec("/foo/bar.so", false, FileSpec::Style::posix),
+      FileSpec("/foo/baz.so", false, FileSpec::Style::posix),
 
       // This is a bit dodgy but we currently depend on GetModulesInfo not
       // performing denormalization. It can go away once the users
       // (DynamicLoaderPOSIXDYLD, at least) correctly set the path syntax for
       // the FileSpecs they create.
-      FileSpec("/foo/baw.so", false, FileSpec::ePathSyntaxWindows),
+      FileSpec("/foo/baw.so", false, FileSpec::Style::windows),
   };
   std::future<llvm::Optional<std::vector<ModuleSpec>>> async_result =
       std::async(std::launch::async,
                  [&] { return client.GetModulesInfo(file_specs, triple); });
   HandlePacket(
       server, "jModulesInfo:["
               R"({"file":"/foo/bar.so","triple":"i386-pc-linux"},)"
               R"({"file":"/foo/baz.so","triple":"i386-pc-linux"},)"
TEST_F(GDBRemoteCommunicationClientTest, GetModulesInfo) {
   EXPECT_EQ(UUID("@ABCDEFGHIJKLMNO", 16), result.getValue()[0].GetUUID());
   EXPECT_EQ(0u, result.getValue()[0].GetObjectOffset());
   EXPECT_EQ(1234u, result.getValue()[0].GetObjectSize());
 }
 
 TEST_F(GDBRemoteCommunicationClientTest, GetModulesInfo_UUID20) {
   llvm::Triple triple("i386-pc-linux");
 
-  FileSpec file_spec("/foo/bar.so", false, FileSpec::ePathSyntaxPosix);
+  FileSpec file_spec("/foo/bar.so", false, FileSpec::Style::posix);
   std::future<llvm::Optional<std::vector<ModuleSpec>>> async_result =
       std::async(std::launch::async,
                  [&] { return client.GetModulesInfo(file_spec, triple); });
   HandlePacket(
       server,
       "jModulesInfo:["
       R"({"file":"/foo/bar.so","triple":"i386-pc-linux"}])",
       R"([{"uuid":"404142434445464748494a4b4c4d4e4f50515253","triple":"i386-pc-linux",)"
       R"("file_path":"/foo/bar.so","file_offset":0,"file_size":1234}]])");
 
   auto result = async_result.get();
   ASSERT_TRUE(result.hasValue());
   ASSERT_EQ(1u, result->size());
   EXPECT_EQ("/foo/bar.so", result.getValue()[0].GetFileSpec().GetPath());
   EXPECT_EQ(triple, result.getValue()[0].GetArchitecture().GetTriple());
   EXPECT_EQ(UUID("@ABCDEFGHIJKLMNOPQRS", 20), result.getValue()[0].GetUUID());
   EXPECT_EQ(0u, result.getValue()[0].GetObjectOffset());
   EXPECT_EQ(1234u, result.getValue()[0].GetObjectSize());
 }
 
 TEST_F(GDBRemoteCommunicationClientTest, GetModulesInfoInvalidResponse) {
   llvm::Triple triple("i386-pc-linux");
-  FileSpec file_spec("/foo/bar.so", false, FileSpec::ePathSyntaxPosix);
+  FileSpec file_spec("/foo/bar.so", false, FileSpec::Style::posix);
 
   const char *invalid_responses[] = {
       // no UUID
       R"([{"triple":"i386-pc-linux",)"
       R"("file_path":"/foo/bar.so","file_offset":0,"file_size":1234}]])",
       // invalid UUID
       R"([{"uuid":"XXXXXX","triple":"i386-pc-linux",)"
       R"("file_path":"/foo/bar.so","file_offset":0,"file_size":1234}]])",

lldb/trunk/unittests/Target/ModuleCacheTest.cpp

 static const char dummy_remote_dir[] = "bin";
 static const char module_name[] = "TestModule.so";
 static const char module_uuid[] =
     "F4E7E991-9B61-6AD4-0073-561AC3D9FA10-C043A476";
 static const uint32_t uuid_bytes = 20;
 static const size_t module_size = 5602;
 
 static FileSpec GetDummyRemotePath() {
-  FileSpec fs("/", false, FileSpec::ePathSyntaxPosix);
+  FileSpec fs("/", false, FileSpec::Style::posix);
   fs.AppendPathComponent(dummy_remote_dir);
   fs.AppendPathComponent(module_name);
   return fs;
 }
 
 static FileSpec GetUuidView(FileSpec spec) {
   spec.AppendPathComponent(".cache");
   spec.AppendPathComponent(module_uuid);

lldb/trunk/unittests/Utility/FileSpecTest.cpp

 //===-- FileSpecTest.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 
 #include "lldb/Utility/FileSpec.h"
 
 using namespace lldb_private;
 
 TEST(FileSpecTest, FileAndDirectoryComponents) {
-  FileSpec fs_posix("/foo/bar", false, FileSpec::ePathSyntaxPosix);
+  FileSpec fs_posix("/foo/bar", false, FileSpec::Style::posix);
   EXPECT_STREQ("/foo/bar", fs_posix.GetCString());
   EXPECT_STREQ("/foo", fs_posix.GetDirectory().GetCString());
   EXPECT_STREQ("bar", fs_posix.GetFilename().GetCString());
 
-  FileSpec fs_windows("F:\\bar", false, FileSpec::ePathSyntaxWindows);
+  FileSpec fs_windows("F:\\bar", false, FileSpec::Style::windows);
   EXPECT_STREQ("F:\\bar", fs_windows.GetCString());
   // EXPECT_STREQ("F:\\", fs_windows.GetDirectory().GetCString()); // It returns
   // "F:/"
   EXPECT_STREQ("bar", fs_windows.GetFilename().GetCString());
 
-  FileSpec fs_posix_root("/", false, FileSpec::ePathSyntaxPosix);
+  FileSpec fs_posix_root("/", false, FileSpec::Style::posix);
   EXPECT_STREQ("/", fs_posix_root.GetCString());
   EXPECT_EQ(nullptr, fs_posix_root.GetDirectory().GetCString());
   EXPECT_STREQ("/", fs_posix_root.GetFilename().GetCString());
 
-  FileSpec fs_windows_drive("F:", false, FileSpec::ePathSyntaxWindows);
+  FileSpec fs_windows_drive("F:", false, FileSpec::Style::windows);
   EXPECT_STREQ("F:", fs_windows_drive.GetCString());
   EXPECT_EQ(nullptr, fs_windows_drive.GetDirectory().GetCString());
   EXPECT_STREQ("F:", fs_windows_drive.GetFilename().GetCString());
 
-  FileSpec fs_windows_root("F:\\", false, FileSpec::ePathSyntaxWindows);
+  FileSpec fs_windows_root("F:\\", false, FileSpec::Style::windows);
   EXPECT_STREQ("F:\\", fs_windows_root.GetCString());
   EXPECT_STREQ("F:", fs_windows_root.GetDirectory().GetCString());
   // EXPECT_STREQ("\\", fs_windows_root.GetFilename().GetCString()); // It
   // returns "/"
 
-  FileSpec fs_posix_long("/foo/bar/baz", false, FileSpec::ePathSyntaxPosix);
+  FileSpec fs_posix_long("/foo/bar/baz", false, FileSpec::Style::posix);
   EXPECT_STREQ("/foo/bar/baz", fs_posix_long.GetCString());
   EXPECT_STREQ("/foo/bar", fs_posix_long.GetDirectory().GetCString());
   EXPECT_STREQ("baz", fs_posix_long.GetFilename().GetCString());
 
-  FileSpec fs_windows_long("F:\\bar\\baz", false, FileSpec::ePathSyntaxWindows);
+  FileSpec fs_windows_long("F:\\bar\\baz", false, FileSpec::Style::windows);
   EXPECT_STREQ("F:\\bar\\baz", fs_windows_long.GetCString());
   // EXPECT_STREQ("F:\\bar", fs_windows_long.GetDirectory().GetCString()); // It
   // returns "F:/bar"
   EXPECT_STREQ("baz", fs_windows_long.GetFilename().GetCString());
 
-  FileSpec fs_posix_trailing_slash("/foo/bar/", false,
-                                   FileSpec::ePathSyntaxPosix);
+  FileSpec fs_posix_trailing_slash("/foo/bar/", false, FileSpec::Style::posix);
   EXPECT_STREQ("/foo/bar", fs_posix_trailing_slash.GetCString());
   EXPECT_STREQ("/foo", fs_posix_trailing_slash.GetDirectory().GetCString());
   EXPECT_STREQ("bar", fs_posix_trailing_slash.GetFilename().GetCString());
 
   FileSpec fs_windows_trailing_slash("F:\\bar\\", false,
-                                     FileSpec::ePathSyntaxWindows);
+                                     FileSpec::Style::windows);
   EXPECT_STREQ("F:\\bar", fs_windows_trailing_slash.GetCString());
   EXPECT_STREQ("bar", fs_windows_trailing_slash.GetFilename().GetCString());
 }
 
 TEST(FileSpecTest, AppendPathComponent) {
-  FileSpec fs_posix("/foo", false, FileSpec::ePathSyntaxPosix);
+  FileSpec fs_posix("/foo", false, FileSpec::Style::posix);
   fs_posix.AppendPathComponent("bar");
   EXPECT_STREQ("/foo/bar", fs_posix.GetCString());
   EXPECT_STREQ("/foo", fs_posix.GetDirectory().GetCString());
   EXPECT_STREQ("bar", fs_posix.GetFilename().GetCString());
 
-  FileSpec fs_posix_2("/foo", false, FileSpec::ePathSyntaxPosix);
+  FileSpec fs_posix_2("/foo", false, FileSpec::Style::posix);
   fs_posix_2.AppendPathComponent("//bar/baz");
   EXPECT_STREQ("/foo/bar/baz", fs_posix_2.GetCString());
   EXPECT_STREQ("/foo/bar", fs_posix_2.GetDirectory().GetCString());
   EXPECT_STREQ("baz", fs_posix_2.GetFilename().GetCString());
 
-  FileSpec fs_windows("F:\\bar", false, FileSpec::ePathSyntaxWindows);
+  FileSpec fs_windows("F:\\bar", false, FileSpec::Style::windows);
   fs_windows.AppendPathComponent("baz");
   EXPECT_STREQ("F:\\bar\\baz", fs_windows.GetCString());
   // EXPECT_STREQ("F:\\bar", fs_windows.GetDirectory().GetCString()); // It
   // returns "F:/bar"
   EXPECT_STREQ("baz", fs_windows.GetFilename().GetCString());
 
-  FileSpec fs_posix_root("/", false, FileSpec::ePathSyntaxPosix);
+  FileSpec fs_posix_root("/", false, FileSpec::Style::posix);
   fs_posix_root.AppendPathComponent("bar");
   EXPECT_STREQ("/bar", fs_posix_root.GetCString());
   EXPECT_STREQ("/", fs_posix_root.GetDirectory().GetCString());
   EXPECT_STREQ("bar", fs_posix_root.GetFilename().GetCString());
 
-  FileSpec fs_windows_root("F:\\", false, FileSpec::ePathSyntaxWindows);
+  FileSpec fs_windows_root("F:\\", false, FileSpec::Style::windows);
   fs_windows_root.AppendPathComponent("bar");
   EXPECT_STREQ("F:\\bar", fs_windows_root.GetCString());
   // EXPECT_STREQ("F:\\", fs_windows_root.GetDirectory().GetCString()); // It
   // returns "F:/"
   EXPECT_STREQ("bar", fs_windows_root.GetFilename().GetCString());
 }
 
 TEST(FileSpecTest, CopyByAppendingPathComponent) {
-  FileSpec fs = FileSpec("/foo", false, FileSpec::ePathSyntaxPosix)
+  FileSpec fs = FileSpec("/foo", false, FileSpec::Style::posix)
                     .CopyByAppendingPathComponent("bar");
   EXPECT_STREQ("/foo/bar", fs.GetCString());
   EXPECT_STREQ("/foo", fs.GetDirectory().GetCString());
   EXPECT_STREQ("bar", fs.GetFilename().GetCString());
 }
 
 TEST(FileSpecTest, PrependPathComponent) {
-  FileSpec fs_posix("foo", false, FileSpec::ePathSyntaxPosix);
+  FileSpec fs_posix("foo", false, FileSpec::Style::posix);
   fs_posix.PrependPathComponent("/bar");
   EXPECT_STREQ("/bar/foo", fs_posix.GetCString());
 
-  FileSpec fs_posix_2("foo/bar", false, FileSpec::ePathSyntaxPosix);
+  FileSpec fs_posix_2("foo/bar", false, FileSpec::Style::posix);
   fs_posix_2.PrependPathComponent("/baz");
   EXPECT_STREQ("/baz/foo/bar", fs_posix_2.GetCString());
 
-  FileSpec fs_windows("baz", false, FileSpec::ePathSyntaxWindows);
+  FileSpec fs_windows("baz", false, FileSpec::Style::windows);
   fs_windows.PrependPathComponent("F:\\bar");
   EXPECT_STREQ("F:\\bar\\baz", fs_windows.GetCString());
 
-  FileSpec fs_posix_root("bar", false, FileSpec::ePathSyntaxPosix);
+  FileSpec fs_posix_root("bar", false, FileSpec::Style::posix);
   fs_posix_root.PrependPathComponent("/");
   EXPECT_STREQ("/bar", fs_posix_root.GetCString());
 
-  FileSpec fs_windows_root("bar", false, FileSpec::ePathSyntaxWindows);
+  FileSpec fs_windows_root("bar", false, FileSpec::Style::windows);
   fs_windows_root.PrependPathComponent("F:\\");
   EXPECT_STREQ("F:\\bar", fs_windows_root.GetCString());
 }
 
 TEST(FileSpecTest, EqualSeparator) {
-  FileSpec backward("C:\\foo\\bar", false, FileSpec::ePathSyntaxWindows);
-  FileSpec forward("C:/foo/bar", false, FileSpec::ePathSyntaxWindows);
+  FileSpec backward("C:\\foo\\bar", false, FileSpec::Style::windows);
+  FileSpec forward("C:/foo/bar", false, FileSpec::Style::windows);
   EXPECT_EQ(forward, backward);
 }
 
 TEST(FileSpecTest, EqualDotsWindows) {
   std::pair<const char *, const char *> tests[] = {
       {R"(C:\foo\bar\baz)", R"(C:\foo\foo\..\bar\baz)"},
       {R"(C:\bar\baz)", R"(C:\foo\..\bar\baz)"},
       {R"(C:\bar\baz)", R"(C:/foo/../bar/baz)"},
       {R"(C:/bar/baz)", R"(C:\foo\..\bar\baz)"},
       {R"(C:\bar)", R"(C:\foo\..\bar)"},
       {R"(C:\foo\bar)", R"(C:\foo\.\bar)"},
       {R"(C:\foo\bar)", R"(C:\foo\bar\.)"},
   };
 
   for (const auto &test : tests) {
-    FileSpec one(test.first, false, FileSpec::ePathSyntaxWindows);
-    FileSpec two(test.second, false, FileSpec::ePathSyntaxWindows);
+    FileSpec one(test.first, false, FileSpec::Style::windows);
+    FileSpec two(test.second, false, FileSpec::Style::windows);
     EXPECT_EQ(one, two);
   }
 }
 
 TEST(FileSpecTest, EqualDotsPosix) {
   std::pair<const char *, const char *> tests[] = {
       {R"(/foo/bar/baz)", R"(/foo/foo/../bar/baz)"},
       {R"(/bar/baz)", R"(/foo/../bar/baz)"},
       {R"(/bar)", R"(/foo/../bar)"},
       {R"(/foo/bar)", R"(/foo/./bar)"},
       {R"(/foo/bar)", R"(/foo/bar/.)"},
   };
 
   for (const auto &test : tests) {
-    FileSpec one(test.first, false, FileSpec::ePathSyntaxPosix);
-    FileSpec two(test.second, false, FileSpec::ePathSyntaxPosix);
+    FileSpec one(test.first, false, FileSpec::Style::posix);
+    FileSpec two(test.second, false, FileSpec::Style::posix);
     EXPECT_EQ(one, two);
   }
 }
 
 TEST(FileSpecTest, EqualDotsPosixRoot) {
   std::pair<const char *, const char *> tests[] = {
       {R"(/)", R"(/..)"},
       {R"(/)", R"(/.)"},
       {R"(/)", R"(/foo/..)"},
   };
 
   for (const auto &test : tests) {
-    FileSpec one(test.first, false, FileSpec::ePathSyntaxPosix);
-    FileSpec two(test.second, false, FileSpec::ePathSyntaxPosix);
+    FileSpec one(test.first, false, FileSpec::Style::posix);
+    FileSpec two(test.second, false, FileSpec::Style::posix);
     EXPECT_EQ(one, two);
   }
 }
 
 TEST(FileSpecTest, GetNormalizedPath) {
   std::pair<const char *, const char *> posix_tests[] = {
       {"/foo/.././bar", "/bar"},
       {"/foo/./../bar", "/bar"},
std::pair<const char *, const char *> posix_tests[] = {
       {"./foo", "foo"},
       {"././foo", "foo"},
       {"../foo", "../foo"},
       {"../../foo", "../../foo"},
   };
   for (auto test : posix_tests) {
     SCOPED_TRACE(llvm::Twine("test.first = ") + test.first);
     EXPECT_EQ(test.second,
-              FileSpec(test.first, false, FileSpec::ePathSyntaxPosix)
-                  .GetPath());
+              FileSpec(test.first, false, FileSpec::Style::posix).GetPath());
   }
 
   std::pair<const char *, const char *> windows_tests[] = {
       {R"(c:\bar\..\bar)", R"(c:\bar)"},
       {R"(c:\bar\.\bar)", R"(c:\bar\bar)"},
       {R"(c:\bar\..)", R"(c:\)"},
       {R"(c:\bar\.)", R"(c:\bar)"},
       {R"(c:\.\bar)", R"(c:\bar)"},
std::pair<const char *, const char *> windows_tests[] = {
       {R"(..\foo\..)", R"(..)"},
       {R"(.\foo)", R"(foo)"},
       {R"(.\.\foo)", R"(foo)"},
       {R"(..\foo)", R"(..\foo)"},
       {R"(..\..\foo)", R"(..\..\foo)"},
   };
   for (auto test : windows_tests) {
     EXPECT_EQ(test.second,
-              FileSpec(test.first, false, FileSpec::ePathSyntaxWindows)
-                  .GetPath())
+              FileSpec(test.first, false, FileSpec::Style::windows).GetPath())
         << "Original path: " << test.first;
   }
 }
 
 TEST(FileSpecTest, FormatFileSpec) {
-  auto win = FileSpec::ePathSyntaxWindows;
+  auto win = FileSpec::Style::windows;
 
   FileSpec F;
   EXPECT_EQ("(empty)", llvm::formatv("{0}", F).str());
   EXPECT_EQ("(empty)", llvm::formatv("{0:D}", F).str());
   EXPECT_EQ("(empty)", llvm::formatv("{0:F}", F).str());
 
   F = FileSpec("C:\\foo\\bar.txt", false, win);
   EXPECT_EQ("C:\\foo\\bar.txt", llvm::formatv("{0}", F).str());