Update profiles to use std::filesystem::path

src/libcmd/command.cc

@@ -297,7 +297,7 @@ void MixProfile::updateProfile(const BuiltPaths & buildables)
 
 MixDefaultProfile::MixDefaultProfile()
 {
-    profile = getDefaultProfile();
+    profile = getDefaultProfile().string();
 }
 
 MixEnvironment::MixEnvironment()
@@ -391,7 +391,7 @@ void createOutLinks(const std::filesystem::path & outLink, const BuiltPaths & bu
                     auto symlink = outLink;
                     if (i)
                         symlink += fmt("-%d", i);
-                    store.addPermRoot(bo.path, absPath(symlink.string()));
+                    store.addPermRoot(bo.path, absPath(symlink).string());
                 },
                 [&](const BuiltPath::Built & bfd) {
                     for (auto & output : bfd.outputs) {
@@ -400,7 +400,7 @@ void createOutLinks(const std::filesystem::path & outLink, const BuiltPaths & bu
                             symlink += fmt("-%d", i);
                         if (output.first != "out")
                             symlink += fmt("-%s", output.first);
-                        store.addPermRoot(output.second, absPath(symlink.string()));
+                        store.addPermRoot(output.second, absPath(symlink).string());
                     }
                 },
             },

src/libexpr/eval-settings.cc

@@ -60,18 +60,18 @@ EvalSettings::EvalSettings(bool & readOnlyMode, EvalSettings::LookupPathHooks lo
 Strings EvalSettings::getDefaultNixPath()
 {
     Strings res;
-    auto add = [&](const Path & p, const std::string & s = std::string()) {
+    auto add = [&](const std::filesystem::path & p, const std::string & s = std::string()) {
         if (std::filesystem::exists(p)) {
             if (s.empty()) {
-                res.push_back(p);
+                res.push_back(p.string());
             } else {
-                res.push_back(s + "=" + p);
+                res.push_back(s + "=" + p.string());
             }
         }
     };
 
-    add(getNixDefExpr() + "/channels");
-    add(rootChannelsDir() + "/nixpkgs", "nixpkgs");
+    add(std::filesystem::path{getNixDefExpr()} / "channels");
+    add(rootChannelsDir() / "nixpkgs", "nixpkgs");
     add(rootChannelsDir());
 
     return res;
@@ -108,4 +108,4 @@ Path getNixDefExpr()
     return settings.useXDGBaseDirectories ? getStateDir() + "/defexpr" : getHome() + "/.nix-defexpr";
 }
 
-} // namespace nix
+} // namespace nix

src/libstore-test-support/include/nix/store/tests/nix_api_store.hh

@@ -50,7 +50,8 @@ protected:
 #else
         // resolve any symlinks in i.e. on macOS /tmp -> /private/tmp
         // because this is not allowed for a nix store.
-        auto tmpl = nix::absPath(std::filesystem::path(nix::defaultTempDir()) / "tests_nix-store.XXXXXX", true);
+        auto tmpl =
+            nix::absPath(std::filesystem::path(nix::defaultTempDir()) / "tests_nix-store.XXXXXX", std::nullopt, true);
         nixDir = mkdtemp((char *) tmpl.c_str());
 #endif
 

src/libstore/build/derivation-building-goal.cc

@@ -307,7 +307,7 @@ Goal::Co DerivationBuildingGoal::tryToBuild()
            crashes.  If we can't acquire the lock, then continue; hopefully some
            other goal can start a build, and if not, the main loop will sleep a few
            seconds and then retry this goal. */
-        PathSet lockFiles;
+        std::set<std::filesystem::path> lockFiles;
         /* FIXME: Should lock something like the drv itself so we don't build same
            CA drv concurrently */
         if (auto * localStore = dynamic_cast<LocalStore *>(&worker.store)) {

src/libstore/include/nix/store/pathlocks.hh

@@ -1,6 +1,8 @@
 #pragma once
 ///@file
 
+#include <filesystem>
+
 #include "nix/util/file-descriptor.hh"
 
 namespace nix {
@@ -10,12 +12,12 @@ namespace nix {
  * -1 is returned if create is false and the lock could not be opened
  * because it doesn't exist.  Any other error throws an exception.
  */
-AutoCloseFD openLockFile(const Path & path, bool create);
+AutoCloseFD openLockFile(const std::filesystem::path & path, bool create);
 
 /**
  * Delete an open lock file.
  */
-void deleteLockFile(const Path & path, Descriptor desc);
+void deleteLockFile(const std::filesystem::path & path, Descriptor desc);
 
 enum LockType { ltRead, ltWrite, ltNone };
 
@@ -24,14 +26,14 @@ bool lockFile(Descriptor desc, LockType lockType, bool wait);
 class PathLocks
 {
 private:
-    typedef std::pair<Descriptor, Path> FDPair;
+    typedef std::pair<Descriptor, std::filesystem::path> FDPair;
     std::list<FDPair> fds;
     bool deletePaths;
 
 public:
     PathLocks();
-    PathLocks(const PathSet & paths, const std::string & waitMsg = "");
-    bool lockPaths(const PathSet & _paths, const std::string & waitMsg = "", bool wait = true);
+    PathLocks(const std::set<std::filesystem::path> & paths, const std::string & waitMsg = "");
+    bool lockPaths(const std::set<std::filesystem::path> & _paths, const std::string & waitMsg = "", bool wait = true);
     ~PathLocks();
     void unlock();
     void setDeletion(bool deletePaths);

src/libstore/include/nix/store/profiles.hh

@@ -7,12 +7,13 @@
  * See the manual for additional information.
  */
 
-#include "nix/util/types.hh"
-#include "nix/store/pathlocks.hh"
-
+#include <filesystem>
 #include <optional>
 #include <time.h>
 
+#include "nix/util/types.hh"
+#include "nix/store/pathlocks.hh"
+
 namespace nix {
 
 class StorePath;
@@ -47,9 +48,9 @@ struct Generation
      * distinct contents to avoid bloat, but nothing stops two
      * non-adjacent generations from having the same contents.
      *
-     * @todo Use `StorePath` instead of `Path`?
+     * @todo Use `StorePath` instead of `std::filesystem::path`?
      */
-    Path path;
+    std::filesystem::path path;
 
     /**
      * When the generation was created. This is extra metadata about the
@@ -81,7 +82,7 @@ typedef std::list<Generation> Generations;
  *
  * Note that the current/active generation need not be the latest one.
  */
-std::pair<Generations, std::optional<GenerationNumber>> findGenerations(Path profile);
+std::pair<Generations, std::optional<GenerationNumber>> findGenerations(std::filesystem::path profile);
 
 struct LocalFSStore;
 
@@ -96,7 +97,7 @@ struct LocalFSStore;
  * The behavior of reusing existing generations like this makes this
  * procedure idempotent. It also avoids clutter.
  */
-Path createGeneration(LocalFSStore & store, Path profile, StorePath outPath);
+std::filesystem::path createGeneration(LocalFSStore & store, std::filesystem::path profile, StorePath outPath);
 
 /**
  * Unconditionally delete a generation
@@ -111,7 +112,7 @@ Path createGeneration(LocalFSStore & store, Path profile, StorePath outPath);
  *
  * @todo Should we expose this at all?
  */
-void deleteGeneration(const Path & profile, GenerationNumber gen);
+void deleteGeneration(const std::filesystem::path & profile, GenerationNumber gen);
 
 /**
  * Delete the given set of generations.
@@ -128,7 +129,8 @@ void deleteGeneration(const Path & profile, GenerationNumber gen);
  * Trying to delete the currently active generation will fail, and cause
  * no generations to be deleted.
  */
-void deleteGenerations(const Path & profile, const std::set<GenerationNumber> & gensToDelete, bool dryRun);
+void deleteGenerations(
+    const std::filesystem::path & profile, const std::set<GenerationNumber> & gensToDelete, bool dryRun);
 
 /**
  * Delete generations older than `max` passed the current generation.
@@ -142,7 +144,7 @@ void deleteGenerations(const Path & profile, const std::set<GenerationNumber> &
  * @param dryRun Log what would be deleted instead of actually doing
  * so.
  */
-void deleteGenerationsGreaterThan(const Path & profile, GenerationNumber max, bool dryRun);
+void deleteGenerationsGreaterThan(const std::filesystem::path & profile, GenerationNumber max, bool dryRun);
 
 /**
  * Delete all generations other than the current one
@@ -153,7 +155,7 @@ void deleteGenerationsGreaterThan(const Path & profile, GenerationNumber max, bo
  * @param dryRun Log what would be deleted instead of actually doing
  * so.
  */
-void deleteOldGenerations(const Path & profile, bool dryRun);
+void deleteOldGenerations(const std::filesystem::path & profile, bool dryRun);
 
 /**
  * Delete generations older than `t`, except for the most recent one
@@ -165,7 +167,7 @@ void deleteOldGenerations(const Path & profile, bool dryRun);
  * @param dryRun Log what would be deleted instead of actually doing
  * so.
  */
-void deleteGenerationsOlderThan(const Path & profile, time_t t, bool dryRun);
+void deleteGenerationsOlderThan(const std::filesystem::path & profile, time_t t, bool dryRun);
 
 /**
  * Parse a temp spec intended for `deleteGenerationsOlderThan()`.
@@ -180,19 +182,19 @@ time_t parseOlderThanTimeSpec(std::string_view timeSpec);
  *
  * @todo Always use `switchGeneration()` instead, and delete this.
  */
-void switchLink(Path link, Path target);
+void switchLink(std::filesystem::path link, std::filesystem::path target);
 
 /**
  * Roll back a profile to the specified generation, or to the most
  * recent one older than the current.
  */
-void switchGeneration(const Path & profile, std::optional<GenerationNumber> dstGen, bool dryRun);
+void switchGeneration(const std::filesystem::path & profile, std::optional<GenerationNumber> dstGen, bool dryRun);
 
 /**
  * Ensure exclusive access to a profile.  Any command that modifies
  * the profile first acquires this lock.
  */
-void lockProfile(PathLocks & lock, const Path & profile);
+void lockProfile(PathLocks & lock, const std::filesystem::path & profile);
 
 /**
  * Optimistic locking is used by long-running operations like `nix-env
@@ -205,34 +207,34 @@ void lockProfile(PathLocks & lock, const Path & profile);
  * store.  Most of the time, only the user environment has to be
  * rebuilt.
  */
-std::string optimisticLockProfile(const Path & profile);
+std::string optimisticLockProfile(const std::filesystem::path & profile);
 
 /**
  * Create and return the path to a directory suitable for storing the user’s
  * profiles.
  */
-Path profilesDir();
+std::filesystem::path profilesDir();
 
 /**
  * Return the path to the profile directory for root (but don't try creating it)
  */
-Path rootProfilesDir();
+std::filesystem::path rootProfilesDir();
 
 /**
  * Create and return the path to the file used for storing the users's channels
  */
-Path defaultChannelsDir();
+std::filesystem::path defaultChannelsDir();
 
 /**
  * Return the path to the channel directory for root (but don't try creating it)
  */
-Path rootChannelsDir();
+std::filesystem::path rootChannelsDir();
 
 /**
  * Resolve the default profile (~/.nix-profile by default,
  * $XDG_STATE_HOME/nix/profile if XDG Base Directory Support is enabled),
  * and create if doesn't exist
  */
-Path getDefaultProfile();
+std::filesystem::path getDefaultProfile();
 
 } // namespace nix

src/libstore/include/nix/store/store-api.hh

@@ -996,6 +996,12 @@ OutputPathMap resolveDerivedPath(Store &, const DerivedPath::Built &, Store * ev
  */
 std::string showPaths(const PathSet & paths);
 
+/**
+ * Display a set of paths in human-readable form (i.e., between quotes
+ * and separated by commas).
+ */
+std::string showPaths(const std::set<std::filesystem::path> paths);
+
 std::optional<ValidPathInfo>
 decodeValidPathInfo(const Store & store, std::istream & str, std::optional<HashResult> hashGiven = std::nullopt);
 

src/libstore/pathlocks.cc

@@ -13,7 +13,7 @@ PathLocks::PathLocks()
 {
 }
 
-PathLocks::PathLocks(const PathSet & paths, const std::string & waitMsg)
+PathLocks::PathLocks(const std::set<std::filesystem::path> & paths, const std::string & waitMsg)
     : deletePaths(false)
 {
     lockPaths(paths, waitMsg);