[Support] Add path::temp_directory() function.

[chfast]

Summary

Function path::temp_directory() returns a path to OS-specific temporary directory. On Windows and OSX it is usually a dir under user's control, on Linux it is usually /tmp.
This function is going to replace path::system_temp_directory(true).

[aaron.ballman]

include/llvm/Support/Path.h

336

Why is Path1 required to pass to the function?

lib/Support/Unix/Path.inc

563

Is there a reason this is a bool instead of an int?

646

Do you have to call Result.clear() here in the event getDarwinConfDir() fails but modifies Result?

lib/Support/Windows/Path.inc

816

I know this isn't yours, but this is a terrible idea just the same. We should not be hard coding paths on Windows. I have a slight preference for this API to return a bool indicating failure, but at the same time, I struggle to imagine what error recovery would look like. I think I could be persuaded that failures here should assert and fail.

824

Do you need to clear Result if user_cache_directory() fails?

[chfast]

include/llvm/Support/Path.h

336

It was discussed around user_cache_directory(). It is not good idea to place files there directly so the API enforces appending at least one path element.

http://reviews.llvm.org/D13801?id=37977#inline-115640

lib/Support/Unix/Path.inc

563

Not any particular reason. I was replacing bool flag, so I used bool.

646

getDarwinConfDir() either clears or does not modify Result in case of failure.

lib/Support/Windows/Path.inc

824

No. user_cache_directory() will either clear or not modify Result in case of failure.

[aaron.ballman]

include/llvm/Support/Path.h

336

That's not the case for the temp directory on Windows, but is the case for the user_cached_directory(). Temp files generally live directly in the temp directory on Windows, and folders are only used when there is a chance the file names will conflict with an existing file. However, the usual pattern when in the temp directory is to pick a temp file name, and so those conflicts do not happen. However, with the user's cache directory, those files are longer-lived, and so they tend to have specific file names that can conflict.

lib/Support/Unix/Path.inc

563

I'm not keen on the bool because then comparisons below are effectively if (bool == bool) instead of if (bool). I have a slight preference for unsigned here.

include/llvm/Support/Path.h

 void system_temp_directory(bool erasedOnReboot, SmallVectorImpl<char> &result);
 
 /// @brief Get the user's home directory.
 ///
 /// @param result Holds the resulting path name.
 /// @result True if a home directory is set, false otherwise.
 bool home_directory(SmallVectorImpl<char> &result);
 
+/// @brief Get the typical OS-specific temporary directory.
+///
+/// Expect the resulting path to be a directory shared with other
+/// applications/services used by the user and/or the system. Params \p Path1 to
+/// \p Path3 can be used to append additional directory names to the resulting
+/// path. Recommended pattern is <temp_directory>/<AppAuthor>/<AppName>.
+///
+/// @param Result Holds the resulting path name.
+void temp_directory(SmallVectorImpl<char> &Result, const Twine &Path1,
+                    const Twine &Path2 = "", const Twine &Path3 = "");
+
 /// @brief Get the user's cache directory.
 ///
 /// Expect the resulting path to be a directory shared with other
 /// applications/services used by the user. Params \p Path1 to \p Path3 can be
 /// used to append additional directory names to the resulting path. Recommended
 /// pattern is <user_cache_directory>/<vendor>/<application>.
 ///
 /// @param Result Holds the resulting path.

lib/Support/Path.cpp

 #if defined(LLVM_ON_WIN32)
 #include "Windows/Path.inc"
 #endif
 
 namespace llvm {
 namespace sys {
 namespace path {
 
+void temp_directory(SmallVectorImpl<char> &Result, const Twine &Path1,
+                    const Twine &Path2, const Twine &Path3) {
+  getTempDir(Result);
+  append(Result, Path1, Path2, Path3);
+}
+
 bool user_cache_directory(SmallVectorImpl<char> &Result, const Twine &Path1,
                           const Twine &Path2, const Twine &Path3) {
   if (getUserCacheDir(Result)) {
     append(Result, Path1, Path2, Path3);
     return true;
   }
   return false;
 }
 
 } // end namespace path
 } // end namsspace sys
 } // end namespace llvm

lib/Support/Unix/Path.inc

if (char *RequestedDir = getenv("HOME")) {
     result.clear();
     result.append(RequestedDir, RequestedDir + strlen(RequestedDir));
     return true;
   }
 
   return false;
 }
 
-static bool getDarwinConfDir(bool TempDir, SmallVectorImpl<char> &Result) {
-  #if defined(_CS_DARWIN_USER_TEMP_DIR) && defined(_CS_DARWIN_USER_CACHE_DIR)
+enum class DarwinConfDir : bool { Temp, Cache };
+
+static bool getDarwinConfDir(DarwinConfDir Dir, SmallVectorImpl<char> &Result) {
   // On Darwin, use DARWIN_USER_TEMP_DIR or DARWIN_USER_CACHE_DIR.
   // macros defined in <unistd.h> on darwin >= 9
-  int ConfName = TempDir ? _CS_DARWIN_USER_TEMP_DIR
+  int ConfName = (Dir == DarwinConfDir::Temp) ? _CS_DARWIN_USER_TEMP_DIR
                                               : _CS_DARWIN_USER_CACHE_DIR;
   size_t ConfLen = confstr(ConfName, nullptr, 0);
   if (ConfLen > 0) {
     do {
       Result.resize(ConfLen);
       ConfLen = confstr(ConfName, Result.data(), Result.size());
     } while (ConfLen > 0 && ConfLen != Result.size());
 
     if (ConfLen > 0) {
       assert(Result.back() == 0);
       Result.pop_back();
       return true;
     }
 
     Result.clear();
   }
-  #endif
   return false;
 }
 
 static bool getUserCacheDir(SmallVectorImpl<char> &Result) {
   // First try using XDS_CACHE_HOME env variable,
   // as specified in XDG Base Directory Specification at
   // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
   if (const char *XdsCacheDir = std::getenv("XDS_CACHE_HOME")) {
     Result.clear();
     Result.append(XdsCacheDir, XdsCacheDir + strlen(XdsCacheDir));
     return true;
   }
 
   // Try Darwin configuration query
-  if (getDarwinConfDir(false, Result))
+  if (getDarwinConfDir(DarwinConfDir::Cache, Result))
     return true;
 
   // Use "$HOME/.cache" if $HOME is available
   if (home_directory(Result)) {
     append(Result, ".cache");
     return true;
   }
 
   return false;
 }
 
 static const char *getEnvTempDir() {
   // Check whether the temporary directory is specified by an environment
   // variable.
   const char *EnvironmentVariables[] = {"TMPDIR", "TMP", "TEMP", "TEMPDIR"};
   for (const char *Env : EnvironmentVariables) {
     if (const char *Dir = std::getenv(Env))
       return Dir;
   }
 
   return nullptr;
 }
 
-static const char *getDefaultTempDir(bool ErasedOnReboot) {
+static const char *getDefaultTempDir() {
 #ifdef P_tmpdir
   if ((bool)P_tmpdir)
     return P_tmpdir;
 #endif
 
-  if (ErasedOnReboot)
-    return "/tmp";
-  return "/var/tmp";
 }
 
-void system_temp_directory(bool ErasedOnReboot, SmallVectorImpl<char> &Result) {
+static void getTempDir(SmallVectorImpl<char> &Result) {
   Result.clear();
 
-  if (ErasedOnReboot) {
-    // There is no env variable for the cache directory.
-    if (const char *RequestedDir = getEnvTempDir()) {
-      Result.append(RequestedDir, RequestedDir + strlen(RequestedDir));
-      return;
-    }
-  }
+
+  if (getDarwinConfDir(DarwinConfDir::Temp , Result))
+    return;
+
+  const char *RequestedDir = getDefaultTempDir();
+  Result.append(RequestedDir, RequestedDir + strlen(RequestedDir));
 
-  if (getDarwinConfDir(ErasedOnReboot, Result))
+void system_temp_directory(bool ErasedOnReboot, SmallVectorImpl<char> &Result) {
+  if (ErasedOnReboot)
+    return getTempDir(Result);
+
+  if (user_cache_directory(Result, ""))
     return;
 
-  const char *RequestedDir = getDefaultTempDir(ErasedOnReboot);
+  const char *RequestedDir = "/var/tmp";
+  Result.clear();
   Result.append(RequestedDir, RequestedDir + strlen(RequestedDir));
 }
 
 } // end namespace path
 
 } // end namespace sys
 } // end namespace llvm

lib/Support/Windows/Path.inc

static bool getTempDirEnvVar(SmallVectorImpl<char> &Res) {
   const wchar_t *EnvironmentVariables[] = {L"TMP", L"TEMP", L"USERPROFILE"};
   for (auto *Env : EnvironmentVariables) {
     if (getTempDirEnvVar(Env, Res))
       return true;
   }
   return false;
 }
 
-void system_temp_directory(bool ErasedOnReboot, SmallVectorImpl<char> &Result) {
-  (void)ErasedOnReboot;
+static void getTempDir(SmallVectorImpl<char> &Result) {
   Result.clear();
 
   // Check whether the temporary directory is specified by an environment var.
   // This matches GetTempPath logic to some degree. GetTempPath is not used
   // directly as it cannot handle evn var longer than 130 chars on Windows 7
   // (fixed on Windows 8).
   if (getTempDirEnvVar(Result)) {
     assert(!Result.empty() && "Unexpected empty path");
     native(Result); // Some Unix-like shells use Unix path separator in $TMP.
     fs::make_absolute(Result); // Make it absolute if not already.
     return;
   }
 
   // Fall back to a system default.
   const char *DefaultResult = "C:\\Temp";
   Result.append(DefaultResult, DefaultResult + strlen(DefaultResult));
 }
+
+void system_temp_directory(bool ErasedOnReboot, SmallVectorImpl<char> &Result) {
+  if (!ErasedOnReboot && user_cache_directory(Result, ""))
+    return;
+
+  temp_directory(Result, "");
+}
 } // end namespace path
 
 namespace windows {
 std::error_code UTF8ToUTF16(llvm::StringRef utf8,
                             llvm::SmallVectorImpl<wchar_t> &utf16) {
   if (!utf8.empty()) {
     int len = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8.begin(),
                                     utf8.size(), utf16.begin(), 0);

unittests/Support/Path.cpp

#endif
   if (!expected.empty()) {
     SmallString<128> HomeDir;
     auto status = path::home_directory(HomeDir);
     EXPECT_TRUE(status);
     EXPECT_EQ(expected, HomeDir);
   }
 }
 
+static std::string path2regex(std::string Path) {
+  size_t Pos = 0;
+  while ((Pos = Path.find('\\', Pos)) != std::string::npos) {
+    Path.replace(Pos, 1, "\\\\");
+    Pos += 2;
+  }
+  return Path;
+}
+
+/// Helper for running known dir test that depends on enviroment variables in
+/// separated process. This allows checking different values of enviroment
+/// variables without messing up the environment of the current process.
+#define EXPECT_DIR(test, expected)                                             \
+  EXPECT_EXIT(                                                                 \
+      {                                                                        \
+        SmallString<300> Dir;                                                  \
+        test;                                                                  \
+        raw_os_ostream(std::cerr) << Dir;                                      \
+        std::exit(0);                                                          \
+      },                                                                       \
+      ::testing::ExitedWithCode(0), path2regex(expected))
+
+/// Helper for running home dir test in separated process, @see EXPECT_DIR.
+#define EXPECT_HOME_DIR(prepare, expected)                                     \
+  EXPECT_DIR(                                                                  \
+      {                                                                        \
+        prepare;                                                               \
+        path::home_directory(Dir);                                             \
+      },                                                                       \
+      expected)
+
+/// Helper for running temp dir test in separated process, @see EXPECT_DIR.
+#define EXPECT_TEMP_DIR(prepare, expected)                                     \
+  EXPECT_DIR(                                                                  \
+      {                                                                        \
+        prepare;                                                               \
+        path::temp_directory(Dir, "");                                         \
+      },                                                                       \
+      expected)
+
 TEST(Support, UserCacheDirectory) {
   SmallString<13> CacheDir;
   SmallString<20> CacheDir2;
   auto Status = path::user_cache_directory(CacheDir, "");
   EXPECT_TRUE(Status ^ CacheDir.empty());
 
   if (Status) {
     EXPECT_TRUE(path::user_cache_directory(CacheDir2, "")); // should succeed

 
 TEST(Support, TempDirectory) {
   SmallString<32> TempDir;
   path::system_temp_directory(false, TempDir);
   EXPECT_TRUE(!TempDir.empty());
   TempDir.clear();
   path::system_temp_directory(true, TempDir);
   EXPECT_TRUE(!TempDir.empty());
-}
 
-#ifdef LLVM_ON_WIN32
-static std::string path2regex(std::string Path) {
-  size_t Pos = 0;
-  while ((Pos = Path.find('\\', Pos)) != std::string::npos) {
-    Path.replace(Pos, 1, "\\\\");
-    Pos += 2;
-  }
-  return Path;
+  StringRef TestToken{"<test token>"};
+  SmallString<32> TempDir2{TestToken};
+  path::temp_directory(TempDir2, "");
+  EXPECT_FALSE(TempDir2.empty());
+  EXPECT_FALSE(TempDir2.startswith(TestToken));
+
+  path::temp_directory(TempDir, "");
+  EXPECT_EQ(TempDir2, TempDir);
+
+  path::temp_directory(TempDir, "TempInc", "TempApp", "file.tmp");
+  auto It = path::rbegin(TempDir);
+  EXPECT_EQ("file.tmp", *It);
+  EXPECT_EQ("TempApp", *++It);
+  EXPECT_EQ("TempInc", *++It);
+  auto ParentDir = *++It;
+
+  // Test Unicode: "<user_cache_dir>/(pi)r^2/aleth.0"
+  path::temp_directory(TempDir2, "\xCF\x80r\xC2\xB2", "\xE2\x84\xB5.0");
+  auto It2 = path::rbegin(TempDir2);
+  EXPECT_EQ("\xE2\x84\xB5.0", *It2);
+  EXPECT_EQ("\xCF\x80r\xC2\xB2", *++It2);
+  auto ParentDir2 = *++It2;
+
+  EXPECT_EQ(ParentDir, ParentDir2);
 }
 
-/// Helper for running temp dir test in separated process. See below.
-#define EXPECT_TEMP_DIR(prepare, expected)                                     \
-  EXPECT_EXIT(                                                                 \
-      {                                                                        \
-        prepare;                                                               \
-        SmallString<300> TempDir;                                              \
-        path::system_temp_directory(true, TempDir);                            \
-        raw_os_ostream(std::cerr) << TempDir;                                  \
-        std::exit(0);                                                          \
-      },                                                                       \
-      ::testing::ExitedWithCode(0), path2regex(expected))
+#ifdef LLVM_ON_UNIX
+TEST(SupportDeathTest, TempDirectoryOnUnix) {
+  EXPECT_TEMP_DIR(setenv("TMPDIR", "/home/LLVMUser/.tmp", true),
+                  "/home/LLVMUser/.tmp");
+}
+#endif
 
+#ifdef LLVM_ON_WIN32
 TEST(SupportDeathTest, TempDirectoryOnWindows) {
   // In this test we want to check how system_temp_directory responds to
   // different values of specific env vars. To prevent corrupting env vars of
   // the current process all checks are done in separated processes.
   EXPECT_TEMP_DIR(_wputenv_s(L"TMP", L"C:\\OtherFolder"), "C:\\OtherFolder");
   EXPECT_TEMP_DIR(_wputenv_s(L"TMP", L"C:/Unix/Path/Seperators"),
                   "C:\\Unix\\Path\\Seperators");
   EXPECT_TEMP_DIR(_wputenv_s(L"TMP", L"Local Path"), ".+\\Local Path$");
   EXPECT_TEMP_DIR(_wputenv_s(L"TMP", L"F:\\TrailingSep\\"), "F:\\TrailingSep");
   EXPECT_TEMP_DIR(
       _wputenv_s(L"TMP", L"C:\\2\x03C0r-\x00B5\x00B3\\\x2135\x2080"),
       "C:\\2\xCF\x80r-\xC2\xB5\xC2\xB3\\\xE2\x84\xB5\xE2\x82\x80");
 
   // Test $TMP empty, $TEMP set.
   EXPECT_TEMP_DIR(
       {
         _wputenv_s(L"TMP", L"");
         _wputenv_s(L"TEMP", L"C:\\Valid\\Path");
       },
       "C:\\Valid\\Path");
 
   // All related env vars empty
   EXPECT_TEMP_DIR(
       {
         _wputenv_s(L"TMP", L"");
         _wputenv_s(L"TEMP", L"");
         _wputenv_s(L"USERPROFILE", L"");
       },
       "C:\\Temp");
 
   // Test evn var / path with 260 chars.
   SmallString<270> Expected{"C:\\Temp\\AB\\123456789"};
   while (Expected.size() < 260)
     Expected.append("\\DirNameWith19Charss");
   ASSERT_EQ(260, Expected.size());
   EXPECT_TEMP_DIR(_putenv_s("TMP", Expected.c_str()), Expected.c_str());
 }