Support: Use sys::path::is_style_{posix,windows}() in a few places

[dexonsmith]

Summary

Use the new sys::path::is_style_posix() and is_style_windows() in a few
places that need to detect the system's native path style.

In llvm/lib/Support/Path.cpp, this patch removes most uses of the
private real_style(), where is_style_posix() and is_style_windows()
are just a little tidier.

Elsewhere, this removes _WIN32 macro checks. Added a FIXME to a
FileManagerTest that seemed fishy, but maintained the existing
behaviour.

Happy to split this up as much as makes sense. Mainly posting to show
examples for https://reviews.llvm.org/D112288.

[Bigcheese]

lgtm

[dexonsmith]

Rebased on top of https://reviews.llvm.org/D110369, which switched from system_style() to is_style_{posix,windows,native}(), and updated the description.

Also cleaned up uses of real_style() in llvm/lib/Support/Path.cpp that were unrelated to slash preferences.

[dexonsmith]

Undo a no-op change in the Path unit tests that I didn't intend to put here.

[dexonsmith]

Fix some backwards checks in FileManagerTest.cpp. (check-clang check-llvm passes now.)

[mstorsjo]

LGTM, too. D112786 does a couple more things that do pretty much the same - I don't mind if you want to fold them into this, or keep it as-is, with the bits that are closer to separator handling split out for clarity.

[dexonsmith]

Squashed in the changes from https://reviews.llvm.org/D112786.

[thakis]

Looks like this breaks tests on windows: http://45.33.8.238/win/47971/step_7.txt

Please take a look and revert for now if it takes a while to fix.

[cfe-commits]

Looking now.

[dexonsmith]

In D112289#3097959, @thakis wrote:

Looks like this breaks tests on windows: http://45.33.8.238/win/47971/step_7.txt

Please take a look and revert for now if it takes a while to fix.

Should be fixed in 9091df5fad52ab6a281d7f4d6a508696e6f9fbae.

clang/lib/Basic/FileManager.cpp

129–133

This introduced a use-after-scope for DirNameStr. Fixed in 9091df5fad52ab6a281d7f4d6a508696e6f9fbae.

clang/include/clang/Basic/JsonSupport.h

 //===- JsonSupport.h - JSON Output Utilities --------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_BASIC_JSONSUPPORT_H
 #define LLVM_CLANG_BASIC_JSONSUPPORT_H
 
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceManager.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <iterator>
 
 namespace clang {
 
 inline raw_ostream &Indent(raw_ostream &Out, const unsigned int Space,
                            bool IsDot) {
   for (unsigned int I = 0; I < Space * 2; ++I)
if (Loc.isFileID()) {
     if (PLoc.isInvalid()) {
       Out << "null";
       return;
     }
     // The macro expansion and spelling pos is identical for file locs.
     if (AddBraces)
       Out << "{ ";
     std::string filename(PLoc.getFilename());
-#ifdef _WIN32
+    if (is_style_windows(llvm::sys::path::Style::native)) {
       // Remove forbidden Windows path characters
       auto RemoveIt =
           std::remove_if(filename.begin(), filename.end(), [](auto Char) {
             static const char ForbiddenChars[] = "<>*?\"|";
-          return std::find(std::begin(ForbiddenChars), std::end(ForbiddenChars),
+            return std::find(std::begin(ForbiddenChars),
+                             std::end(ForbiddenChars),
                              Char) != std::end(ForbiddenChars);
           });
       filename.erase(RemoveIt, filename.end());
       // Handle windows-specific path delimiters.
       std::replace(filename.begin(), filename.end(), '\\', '/');
-#endif
+    }
     Out << "\"line\": " << PLoc.getLine()
         << ", \"column\": " << PLoc.getColumn()
         << ", \"file\": \"" << filename << "\"";
     if (AddBraces)
       Out << " }";
     return;
   }
 

clang/lib/Basic/FileManager.cpp

 FileManager::getDirectoryRef(StringRef DirName, bool CacheFailure) {
   // stat doesn't like trailing separators except for root directory.
   // At least, on Win32 MSVCRT, stat() cannot strip trailing '/'.
   // (though it can strip '\\')
   if (DirName.size() > 1 &&
       DirName != llvm::sys::path::root_path(DirName) &&
       llvm::sys::path::is_separator(DirName.back()))
     DirName = DirName.substr(0, DirName.size()-1);
-#ifdef _WIN32
+  if (is_style_windows(llvm::sys::path::Style::native)) {
     // Fixing a problem with "clang C:test.c" on Windows.
     // Stat("C:") does not recognize "C:" as a valid directory
     std::string DirNameStr;
     if (DirName.size() > 1 && DirName.back() == ':' &&
         DirName.equals_insensitive(llvm::sys::path::root_name(DirName))) {
       DirNameStr = DirName.str() + '.';
       DirName = DirNameStr;
     }
-#endif
+  }
 
   ++NumDirLookups;
 
   // See if there was already an entry in the map.  Note that the map
   // contains both virtual and real directories.
   auto SeenDirInsertResult =
       SeenDirEntries.insert({DirName, std::errc::no_such_file_or_directory});
   if (!SeenDirInsertResult.second) {

clang/lib/Driver/Driver.cpp

 }
 
 const char *Driver::GetNamedOutputPath(Compilation &C, const JobAction &JA,
                                        const char *BaseInput,
                                        StringRef OrigBoundArch, bool AtTopLevel,
                                        bool MultipleArchs,
                                        StringRef OffloadingPrefix) const {
   std::string BoundArch = OrigBoundArch.str();
-#if defined(_WIN32)
+  if (is_style_windows(llvm::sys::path::Style::native)) {
     // BoundArch may contains ':', which is invalid in file names on Windows,
     // therefore replace it with '%'.
     std::replace(BoundArch.begin(), BoundArch.end(), ':', '@');
-#endif
+  }
 
   llvm::PrettyStackTraceString CrashInfo("Computing output path");
   // Output to a user requested destination?
   if (AtTopLevel && !isa<DsymutilJobAction>(JA) && !isa<VerifyJobAction>(JA)) {
     if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
       return C.addResultFile(FinalOutput->getValue(), &JA);
   }
 

clang/lib/Driver/ToolChain.cpp

static const DriverSuffix *FindDriverSuffix(StringRef ProgName, size_t &Pos) {
   }
   return nullptr;
 }
 
 /// Normalize the program name from argv[0] by stripping the file extension if
 /// present and lower-casing the string on Windows.
 static std::string normalizeProgramName(llvm::StringRef Argv0) {
   std::string ProgName = std::string(llvm::sys::path::stem(Argv0));
-#ifdef _WIN32
+  if (is_style_windows(llvm::sys::path::Style::native)) {
     // Transform to lowercase for case insensitive file systems.
-  std::transform(ProgName.begin(), ProgName.end(), ProgName.begin(), ::tolower);
-#endif
+    std::transform(ProgName.begin(), ProgName.end(), ProgName.begin(),
+                   ::tolower);
+  }
   return ProgName;
 }
 
 static const DriverSuffix *parseDriverSuffix(StringRef ProgName, size_t &Pos) {
   // Try to infer frontend type and default target from the program name by
   // comparing it against DriverSuffixes in order.
 
   // If there is a match, the function tries to identify a target as prefix.

clang/lib/Lex/PPDirectives.cpp

Preprocessor::ImportAction Preprocessor::HandleHeaderIncludeOrImport(
   SmallString<1024> SearchPath;
   SmallString<1024> RelativePath;
   // We get the raw path only if we have 'Callbacks' to which we later pass
   // the path.
   ModuleMap::KnownHeader SuggestedModule;
   SourceLocation FilenameLoc = FilenameTok.getLocation();
   StringRef LookupFilename = Filename;
 
-#ifdef _WIN32
-  llvm::sys::path::Style BackslashStyle = llvm::sys::path::Style::windows;
-#else
   // Normalize slashes when compiling with -fms-extensions on non-Windows. This
   // is unnecessary on Windows since the filesystem there handles backslashes.
   SmallString<128> NormalizedPath;
-  llvm::sys::path::Style BackslashStyle = llvm::sys::path::Style::posix;
-  if (LangOpts.MicrosoftExt) {
+  llvm::sys::path::Style BackslashStyle = llvm::sys::path::Style::native;
+  if (is_style_posix(BackslashStyle) && LangOpts.MicrosoftExt) {
     NormalizedPath = Filename.str();
     llvm::sys::path::native(NormalizedPath);
     LookupFilename = NormalizedPath;
     BackslashStyle = llvm::sys::path::Style::windows;
   }
-#endif
 
   Optional<FileEntryRef> File = LookupHeaderIncludeOrImport(
       CurDir, Filename, FilenameLoc, FilenameRange, FilenameTok,
       IsFrameworkFound, IsImportDecl, IsMapped, LookupFrom, LookupFromFile,
       LookupFilename, RelativePath, SearchPath, SuggestedModule, isAngled);
 
   // Record the header's filename for later use.
   if (File)

clang/unittests/Basic/FileManagerTest.cpp

 class FakeStatCache : public FileSystemStatCache {
 private:
   // Maps a file/directory path to its desired stat result.  Anything
   // not in this map is considered to not exist in the file system.
   llvm::StringMap<llvm::vfs::Status, llvm::BumpPtrAllocator> StatCalls;
 
   void InjectFileOrDirectory(const char *Path, ino_t INode, bool IsFile,
                              const char *StatPath) {
-#ifndef _WIN32
     SmallString<128> NormalizedPath(Path);
+    SmallString<128> NormalizedStatPath;
+    if (is_style_posix(llvm::sys::path::Style::native)) {
       llvm::sys::path::native(NormalizedPath);
       Path = NormalizedPath.c_str();
 
-    SmallString<128> NormalizedStatPath;
       if (StatPath) {
         NormalizedStatPath = StatPath;
         llvm::sys::path::native(NormalizedStatPath);
         StatPath = NormalizedStatPath.c_str();
       }
-#endif
+    }
 
     if (!StatPath)
       StatPath = Path;
 
     auto fileType = IsFile ?
       llvm::sys::fs::file_type::regular_file :
       llvm::sys::fs::file_type::directory_file;
     llvm::vfs::Status Status(StatPath, llvm::sys::fs::UniqueID(1, INode),
void InjectDirectory(const char *Path, ino_t INode) {
     InjectFileOrDirectory(Path, INode, /*IsFile=*/false, nullptr);
   }
 
   // Implement FileSystemStatCache::getStat().
   std::error_code getStat(StringRef Path, llvm::vfs::Status &Status,
                           bool isFile,
                           std::unique_ptr<llvm::vfs::File> *F,
                           llvm::vfs::FileSystem &FS) override {
-#ifndef _WIN32
     SmallString<128> NormalizedPath(Path);
+    if (is_style_posix(llvm::sys::path::Style::native)) {
       llvm::sys::path::native(NormalizedPath);
       Path = NormalizedPath.c_str();
-#endif
+    }
 
     if (StatCalls.count(Path) != 0) {
       Status = StatCalls[Path];
       return std::error_code();
     }
 
     return std::make_error_code(std::errc::no_such_file_or_directory);
   }
TEST_F(FileManagerTest, getVirtualFileWithDifferentName) {
   EXPECT_EQ(43U, (*file2)->getUniqueID().getFile());
   // Check that the contents of the UFE are not overwritten by the entry in the
   // filesystem:
   EXPECT_EQ(123, (*file2)->getSize());
 }
 
 #endif  // !_WIN32
 
+static StringRef getSystemRoot() {
+  return is_style_windows(llvm::sys::path::Style::native) ? "C:/" : "/";
+}
+
 TEST_F(FileManagerTest, makeAbsoluteUsesVFS) {
-  SmallString<64> CustomWorkingDir;
-#ifdef _WIN32
-  CustomWorkingDir = "C:";
-#else
-  CustomWorkingDir = "/";
-#endif
+  // FIXME: Should this be using a root path / call getSystemRoot()? For now,
+  // avoiding that and leaving the test as-is.
+  SmallString<64> CustomWorkingDir =
+      is_style_windows(llvm::sys::path::Style::native) ? StringRef("C:")
+                                                       : StringRef("/");
   llvm::sys::path::append(CustomWorkingDir, "some", "weird", "path");
 
   auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
       new llvm::vfs::InMemoryFileSystem);
   // setCurrentworkingdirectory must finish without error.
   ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
 
   FileSystemOptions Opts;
   FileManager Manager(Opts, FS);
 
   SmallString<64> Path("a/foo.cpp");
 
   SmallString<64> ExpectedResult(CustomWorkingDir);
   llvm::sys::path::append(ExpectedResult, Path);
 
   ASSERT_TRUE(Manager.makeAbsolutePath(Path));
   EXPECT_EQ(Path, ExpectedResult);
 }
 
 // getVirtualFile should always fill the real path.
 TEST_F(FileManagerTest, getVirtualFileFillsRealPathName) {
-  SmallString<64> CustomWorkingDir;
-#ifdef _WIN32
-  CustomWorkingDir = "C:/";
-#else
-  CustomWorkingDir = "/";
-#endif
+  SmallString<64> CustomWorkingDir = getSystemRoot();
 
   auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
       new llvm::vfs::InMemoryFileSystem);
   // setCurrentworkingdirectory must finish without error.
   ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
 
   FileSystemOptions Opts;
   FileManager Manager(Opts, FS);
TEST_F(FileManagerTest, getVirtualFileFillsRealPathName) {
   ASSERT_TRUE(file->isValid());
   SmallString<64> ExpectedResult = CustomWorkingDir;
 
   llvm::sys::path::append(ExpectedResult, "tmp", "test");
   EXPECT_EQ(file->tryGetRealPathName(), ExpectedResult);
 }
 
 TEST_F(FileManagerTest, getFileDontOpenRealPath) {
-  SmallString<64> CustomWorkingDir;
-#ifdef _WIN32
-  CustomWorkingDir = "C:/";
-#else
-  CustomWorkingDir = "/";
-#endif
+  SmallString<64> CustomWorkingDir = getSystemRoot();
 
   auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
       new llvm::vfs::InMemoryFileSystem);
   // setCurrentworkingdirectory must finish without error.
   ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
 
   FileSystemOptions Opts;
   FileManager Manager(Opts, FS);

clang/unittests/Driver/ToolChainTest.cpp

for (const char *Path : EmptyFiles)
     std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
         {"-fsyntax-only", "--gcc-toolchain=", "--sysroot=", "foo.cpp"}));
     ASSERT_TRUE(C);
     std::string S;
     {
       llvm::raw_string_ostream OS(S);
       C->getDefaultToolChain().printVerboseInfo(OS);
     }
-#if _WIN32
+    if (is_style_windows(llvm::sys::path::Style::native))
       std::replace(S.begin(), S.end(), '\\', '/');
-#endif
     EXPECT_EQ(
         "Found candidate GCC installation: "
         "/usr/lib/gcc/arm-linux-gnueabihf/4.6.3\n"
         "Selected GCC installation: /usr/lib/gcc/arm-linux-gnueabihf/4.6.3\n"
         "Candidate multilib: .;@m32\n"
         "Selected multilib: .;@m32\n",
         S);
   }
 
   {
     DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
     Driver TheDriver("/bin/clang", "arm-linux-gnueabihf", Diags,
                      "clang LLVM compiler", InMemoryFileSystem);
     std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
         {"-fsyntax-only", "--gcc-toolchain=", "--sysroot=/sysroot",
          "foo.cpp"}));
     ASSERT_TRUE(C);
     std::string S;
     {
       llvm::raw_string_ostream OS(S);
       C->getDefaultToolChain().printVerboseInfo(OS);
     }
-#if _WIN32
+    if (is_style_windows(llvm::sys::path::Style::native))
       std::replace(S.begin(), S.end(), '\\', '/');
-#endif
     // Test that 4.5.3 from --sysroot is not overridden by 4.6.3 (larger
     // version) from /usr.
     EXPECT_EQ("Found candidate GCC installation: "
               "/sysroot/usr/lib/gcc/arm-linux-gnueabihf/4.5.3\n"
               "Selected GCC installation: "
               "/sysroot/usr/lib/gcc/arm-linux-gnueabihf/4.5.3\n"
               "Candidate multilib: .;@m32\n"
               "Selected multilib: .;@m32\n",
std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
       {"-fsyntax-only", "--gcc-toolchain=", "foo.cpp"}));
   EXPECT_TRUE(C);
 
   std::string S;
   {
     llvm::raw_string_ostream OS(S);
     C->getDefaultToolChain().printVerboseInfo(OS);
   }
-#if _WIN32
+  if (is_style_windows(llvm::sys::path::Style::windows))
     std::replace(S.begin(), S.end(), '\\', '/');
-#endif
   EXPECT_EQ("Found candidate GCC installation: "
             "/home/test/bin/../lib/gcc/arm-linux-gnueabi/4.6.1\n"
             "Selected GCC installation: "
             "/home/test/bin/../lib/gcc/arm-linux-gnueabi/4.6.1\n"
             "Candidate multilib: .;@m32\n"
             "Selected multilib: .;@m32\n",
             S);
 }

clang/unittests/Lex/HeaderSearchTest.cpp

 
 TEST_F(HeaderSearchTest, HeaderMapFrameworkLookup) {
   typedef NullTerminatedFile<test::HMapFileMock<4, 128>, char> FileTy;
   FileTy File;
   File.init();
 
   std::string HeaderDirName = "/tmp/Sources/Foo/Headers/";
   std::string HeaderName = "Foo.h";
-#ifdef _WIN32
+  if (is_style_windows(llvm::sys::path::Style::native)) {
     // Force header path to be absolute on windows.
     // As headermap content should represent absolute locations.
     HeaderDirName = "C:" + HeaderDirName;
-#endif /*_WIN32*/
+  }
 
   test::HMapFileMockMaker<FileTy> Maker(File);
   auto a = Maker.addString("Foo/Foo.h");
   auto b = Maker.addString(HeaderDirName);
   auto c = Maker.addString(HeaderName);
   Maker.addBucket("Foo/Foo.h", a, b, c);
   addHeaderMap("product-headers.hmap", File.getBuffer(), /*isAngled=*/true);
 

clang/unittests/Tooling/RefactoringTest.cpp

mergeAndTestRewrite(
       toReplacements({{"", 0, 1, ""}, {"", 2, 0, "bb"}, {"", 3, 0, "b"}}),
       toReplacements({{"", 0, 2, "cc"}, {"", 2, 3, "dd"}}));
   mergeAndTestRewrite(
       "aa", "babbab", "ccdd",
       toReplacements({{"", 0, 0, "b"}, {"", 1, 0, "bb"}, {"", 2, 0, "b"}}),
       toReplacements({{"", 0, 3, "cc"}, {"", 3, 3, "dd"}}));
 }
 
+static constexpr bool usesWindowsPaths() {
+  return is_style_windows(llvm::sys::path::Style::native);
+}
+
 TEST(DeduplicateByFileTest, PathsWithDots) {
   std::map<std::string, Replacements> FileToReplaces;
   llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> VFS(
       new llvm::vfs::InMemoryFileSystem());
   FileManager FileMgr(FileSystemOptions(), VFS);
-#if !defined(_WIN32)
-  StringRef Path1 = "a/b/.././c.h";
-  StringRef Path2 = "a/c.h";
-#else
-  StringRef Path1 = "a\\b\\..\\.\\c.h";
-  StringRef Path2 = "a\\c.h";
-#endif
+  StringRef Path1 = usesWindowsPaths() ? "a\\b\\..\\.\\c.h" : "a/b/.././c.h";
+  StringRef Path2 = usesWindowsPaths() ? "a\\c.h" : "a/c.h";
   EXPECT_TRUE(VFS->addFile(Path1, 0, llvm::MemoryBuffer::getMemBuffer("")));
   EXPECT_TRUE(VFS->addFile(Path2, 0, llvm::MemoryBuffer::getMemBuffer("")));
   FileToReplaces[std::string(Path1)] = Replacements();
   FileToReplaces[std::string(Path2)] = Replacements();
   FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces);
   EXPECT_EQ(1u, FileToReplaces.size());
   EXPECT_EQ(Path1, FileToReplaces.begin()->first);
 }
 
 TEST(DeduplicateByFileTest, PathWithDotSlash) {
   std::map<std::string, Replacements> FileToReplaces;
   llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> VFS(
       new llvm::vfs::InMemoryFileSystem());
   FileManager FileMgr(FileSystemOptions(), VFS);
-#if !defined(_WIN32)
-  StringRef Path1 = "./a/b/c.h";
-  StringRef Path2 = "a/b/c.h";
-#else
-  StringRef Path1 = ".\\a\\b\\c.h";
-  StringRef Path2 = "a\\b\\c.h";
-#endif
+  StringRef Path1 = usesWindowsPaths() ? ".\\a\\b\\c.h" : "./a/b/c.h";
+  StringRef Path2 = usesWindowsPaths() ? "a\\b\\c.h" : "a/b/c.h";
   EXPECT_TRUE(VFS->addFile(Path1, 0, llvm::MemoryBuffer::getMemBuffer("")));
   EXPECT_TRUE(VFS->addFile(Path2, 0, llvm::MemoryBuffer::getMemBuffer("")));
   FileToReplaces[std::string(Path1)] = Replacements();
   FileToReplaces[std::string(Path2)] = Replacements();
   FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces);
   EXPECT_EQ(1u, FileToReplaces.size());
   EXPECT_EQ(Path1, FileToReplaces.begin()->first);
 }
 
 TEST(DeduplicateByFileTest, NonExistingFilePath) {
   std::map<std::string, Replacements> FileToReplaces;
   llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> VFS(
       new llvm::vfs::InMemoryFileSystem());
   FileManager FileMgr(FileSystemOptions(), VFS);
-#if !defined(_WIN32)
-  StringRef Path1 = "./a/b/c.h";
-  StringRef Path2 = "a/b/c.h";
-#else
-  StringRef Path1 = ".\\a\\b\\c.h";
-  StringRef Path2 = "a\\b\\c.h";
-#endif
+  StringRef Path1 = usesWindowsPaths() ? ".\\a\\b\\c.h" : "./a/b/c.h";
+  StringRef Path2 = usesWindowsPaths() ? "a\\b\\c.h" : "a/b/c.h";
   FileToReplaces[std::string(Path1)] = Replacements();
   FileToReplaces[std::string(Path2)] = Replacements();
   FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces);
   EXPECT_TRUE(FileToReplaces.empty());
 }
 
 class AtomicChangeTest : public ::testing::Test {
   protected:

llvm/include/llvm/Support/VirtualFileSystem.h

private:
   std::string ExternalContentsPrefixDir;
 
   /// @name Configuration
   /// @{
 
   /// Whether to perform case-sensitive comparisons.
   ///
   /// Currently, case-insensitive matching only works correctly with ASCII.
-  bool CaseSensitive =
-#ifdef _WIN32
-      false;
-#else
-      true;
-#endif
+  bool CaseSensitive = is_style_posix(sys::path::Style::native);
 
   /// IsRelativeOverlay marks whether a ExternalContentsPrefixDir path must
   /// be prefixed in every 'external-contents' when reading from YAML files.
   bool IsRelativeOverlay = false;
 
   /// Whether to use to use the value of 'external-contents' for the
   /// names of files.  This global value is overridable on a per-file basis.
   bool UseExternalNames = true;

llvm/lib/Support/GraphWriter.cpp

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
-#include <system_error>
 #include <string>
+#include <system_error>
 #include <vector>
 
 using namespace llvm;
 
 #ifdef __APPLE__
 namespace {
 struct CreateViewBackground {
   static void *call() {
static const char* Colors[NumColors] = {
     "aaaaaa", "aa0000", "00aa00", "aa5500", "0055ff", "aa00aa", "00aaaa",
     "555555", "ff5555", "55ff55", "ffff55", "5555ff", "ff55ff", "55ffff",
     "ffaaaa", "aaffaa", "ffffaa", "aaaaff", "ffaaff", "aaffff"};
   return Colors[ColorNumber % NumColors];
 }
 
 static std::string replaceIllegalFilenameChars(std::string Filename,
                                                const char ReplacementChar) {
-#ifdef _WIN32
-  std::string IllegalChars = "\\/:?\"<>|";
-#else
-  std::string IllegalChars = "/";
-#endif
+  std::string IllegalChars =
+      is_style_windows(sys::path::Style::native) ? "\\/:?\"<>|" : "/";
 
   for (char IllegalChar : IllegalChars) {
     std::replace(Filename.begin(), Filename.end(), IllegalChar,
                  ReplacementChar);
   }
 
   return Filename;
 }

llvm/lib/Support/Path.cpp

StringRef find_first_component(StringRef path, Style style) {
     // * empty (in this case we return an empty string)
     // * either C: or {//,\\}net.
     // * {/,\}
     // * {file,directory}name
 
     if (path.empty())
       return path;
 
-    if (real_style(style) == Style::windows) {
+    if (is_style_windows(style)) {
       // C:
       if (path.size() >= 2 &&
           std::isalpha(static_cast<unsigned char>(path[0])) && path[1] == ':')
         return path.substr(0, 2);
     }
 
     // //net
     if ((path.size() > 2) && is_separator(path[0], style) &&
namespace {
   // Returns the first character of the filename in str. For paths ending in
   // '/', it returns the position of the '/'.
   size_t filename_pos(StringRef str, Style style) {
     if (str.size() > 0 && is_separator(str[str.size() - 1], style))
       return str.size() - 1;
 
     size_t pos = str.find_last_of(separators(style), str.size() - 1);
 
-    if (real_style(style) == Style::windows) {
+    if (is_style_windows(style)) {
       if (pos == StringRef::npos)
         pos = str.find_last_of(':', str.size() - 2);
     }
 
     if (pos == StringRef::npos || (pos == 1 && is_separator(str[0], style)))
       return 0;
 
     return pos + 1;
   }
 
   // Returns the position of the root directory in str. If there is no root
   // directory in str, it returns StringRef::npos.
   size_t root_dir_start(StringRef str, Style style) {
     // case "c:/"
-    if (real_style(style) == Style::windows) {
+    if (is_style_windows(style)) {
       if (str.size() > 2 && str[1] == ':' && is_separator(str[2], style))
         return 2;
     }
 
     // case "//net"
     if (str.size() > 3 && is_separator(str[0], style) && str[0] == str[1] &&
         !is_separator(str[2], style)) {
       return str.find_first_of(separators(style), 2);
const_iterator &const_iterator::operator++() {
   bool was_net = Component.size() > 2 && is_separator(Component[0], S) &&
                  Component[1] == Component[0] && !is_separator(Component[2], S);
 
   // Handle separators.
   if (is_separator(Path[Position], S)) {
     // Root dir.
     if (was_net ||
         // c:/
-        (real_style(S) == Style::windows && Component.endswith(":"))) {
+        (is_style_windows(S) && Component.endswith(":"))) {
       Component = Path.substr(Position, 1);
       return *this;
     }
 
     // Skip extra separators.
     while (Position != Path.size() && is_separator(Path[Position], S)) {
       ++Position;
     }
ptrdiff_t reverse_iterator::operator-(const reverse_iterator &RHS) const {
   return Position - RHS.Position;
 }
 
 StringRef root_path(StringRef path, Style style) {
   const_iterator b = begin(path, style), pos = b, e = end(path);
   if (b != e) {
     bool has_net =
         b->size() > 2 && is_separator((*b)[0], style) && (*b)[1] == (*b)[0];
-    bool has_drive = (real_style(style) == Style::windows) && b->endswith(":");
+    bool has_drive = is_style_windows(style) && b->endswith(":");
 
     if (has_net || has_drive) {
       if ((++pos != e) && is_separator((*pos)[0], style)) {
         // {C:/,//net/}, so get the first two components.
         return path.substr(0, b->size() + pos->size());
       }
       // just {C:,//net}, return the first component.
       return *b;
     }
 
     // POSIX style root directory.
     if (is_separator((*b)[0], style)) {
       return *b;
     }
   }
 
   return StringRef();
 }
 
 StringRef root_name(StringRef path, Style style) {
   const_iterator b = begin(path, style), e = end(path);
   if (b != e) {
     bool has_net =
         b->size() > 2 && is_separator((*b)[0], style) && (*b)[1] == (*b)[0];
-    bool has_drive = (real_style(style) == Style::windows) && b->endswith(":");
+    bool has_drive = is_style_windows(style) && b->endswith(":");
 
     if (has_net || has_drive) {
       // just {C:,//net}, return the first component.
       return *b;
     }
   }
 
   // No path or no name.
   return StringRef();
 }
 
 StringRef root_directory(StringRef path, Style style) {
   const_iterator b = begin(path, style), pos = b, e = end(path);
   if (b != e) {
     bool has_net =
         b->size() > 2 && is_separator((*b)[0], style) && (*b)[1] == (*b)[0];
-    bool has_drive = (real_style(style) == Style::windows) && b->endswith(":");
+    bool has_drive = is_style_windows(style) && b->endswith(":");
 
     if ((has_net || has_drive) &&
         // {C:,//net}, skip to the next component.
         (++pos != e) && is_separator((*pos)[0], style)) {
       return *pos;
     }
 
     // POSIX style root directory.
void replace_extension(SmallVectorImpl<char> &path, const Twine &extension,
 
   // Append extension.
   path.append(ext.begin(), ext.end());
 }
 
 static bool starts_with(StringRef Path, StringRef Prefix,
                         Style style = Style::native) {
   // Windows prefix matching : case and separator insensitive
-  if (real_style(style) == Style::windows) {
+  if (is_style_windows(style)) {
     if (Path.size() < Prefix.size())
       return false;
     for (size_t I = 0, E = Prefix.size(); I != E; ++I) {
       bool SepPath = is_separator(Path[I], style);
       bool SepPrefix = is_separator(Prefix[I], style);
       if (SepPath != SepPrefix)
         return false;
       if (!SepPath && toLower(Path[I]) != toLower(Prefix[I]))
void native(const Twine &path, SmallVectorImpl<char> &result, Style style) {
   result.clear();
   path.toVector(result);
   native(result, style);
 }
 
 void native(SmallVectorImpl<char> &Path, Style style) {
   if (Path.empty())
     return;
-  if (real_style(style) == Style::windows) {
+  if (is_style_windows(style)) {
     std::replace(Path.begin(), Path.end(), '/', '\\');
     if (Path[0] == '~' && (Path.size() == 1 || is_separator(Path[1], style))) {
       SmallString<128> PathHome;
       home_directory(PathHome);
       PathHome.append(Path.begin() + 1, Path.end());
       Path = PathHome;
     }
   } else {
     std::replace(Path.begin(), Path.end(), '\\', '/');
   }
 }
 
 std::string convert_to_slash(StringRef path, Style style) {
-  if (real_style(style) != Style::windows)
+  if (is_style_posix(style))
     return std::string(path);
 
   std::string s = path.str();
   std::replace(s.begin(), s.end(), '\\', '/');
   return s;
 }
 
 StringRef filename(StringRef path, Style style) { return *rbegin(path, style); }
if ((fname.size() == 1 && fname == ".") ||
       (fname.size() == 2 && fname == ".."))
     return StringRef();
   return fname.substr(pos);
 }
 
 bool is_separator(char value, Style style) {
   if (value == '/')
     return true;
-  if (real_style(style) == Style::windows)
+  if (is_style_windows(style))
     return value == '\\';
   return false;
 }
 
 StringRef get_separator(Style style) {
-  if (real_style(style) == Style::windows)
+  if (is_style_windows(style))
     return "\\";
   return "/";
 }
 
 bool has_root_name(const Twine &path, Style style) {
   SmallString<128> path_storage;
   StringRef p = path.toStringRef(path_storage);
 
bool has_extension(const Twine &path, Style style) {
   return !extension(p, style).empty();
 }
 
 bool is_absolute(const Twine &path, Style style) {
   SmallString<128> path_storage;
   StringRef p = path.toStringRef(path_storage);
 
   bool rootDir = has_root_directory(p, style);
-  bool rootName =
-      (real_style(style) != Style::windows) || has_root_name(p, style);
+  bool rootName = is_style_posix(style) || has_root_name(p, style);
 
   return rootDir && rootName;
 }
 
 bool is_absolute_gnu(const Twine &path, Style style) {
   SmallString<128> path_storage;
   StringRef p = path.toStringRef(path_storage);
 
   // Handle '/' which is absolute for both Windows and POSIX systems.
   // Handle '\\' on Windows.
   if (!p.empty() && is_separator(p.front(), style))
     return true;
 
-  if (real_style(style) == Style::windows) {
+  if (is_style_windows(style)) {
     // Handle drive letter pattern (a character followed by ':') on Windows.
     if (p.size() >= 2 && (p[0] && p[1] == ':'))
       return true;
   }
 
   return false;
 }
 

 void make_absolute(const Twine &current_directory,
                    SmallVectorImpl<char> &path) {
   StringRef p(path.data(), path.size());
 
   bool rootDirectory = path::has_root_directory(p);
   bool rootName = path::has_root_name(p);
 
   // Already absolute.
-  if ((rootName || real_style(Style::native) != Style::windows) &&
-      rootDirectory)
+  if ((rootName || is_style_posix(Style::native)) && rootDirectory)
     return;
 
   // All of the following conditions will need the current directory.
   SmallString<128> current_dir;
   current_directory.toVector(current_dir);
 
   // Relative path. Prepend the current directory.
   if (!rootName && !rootDirectory) {

llvm/tools/lli/lli.cpp

private:
 
   bool getCacheFilename(const std::string &ModID, std::string &CacheName) {
     std::string Prefix("file:");
     size_t PrefixLength = Prefix.length();
     if (ModID.substr(0, PrefixLength) != Prefix)
       return false;
 
     std::string CacheSubdir = ModID.substr(PrefixLength);
-#if defined(_WIN32)
-    // Transform "X:\foo" => "/X\foo" for convenience.
-    if (isalpha(CacheSubdir[0]) && CacheSubdir[1] == ':') {
+    // Transform "X:\foo" => "/X\foo" for convenience on Windows.
+    if (is_style_windows(llvm::sys::path::Style::native) &&
+        isalpha(CacheSubdir[0]) && CacheSubdir[1] == ':') {
       CacheSubdir[1] = CacheSubdir[0];
       CacheSubdir[0] = '/';
     }
-#endif
 
     CacheName = CacheDir + CacheSubdir;
     size_t pos = CacheName.rfind('.');
     CacheName.replace(pos, CacheName.length() - pos, ".o");
     return true;
   }
 };