Merge pull request #9939 from edolstra/slash-operator

roberth · web-flow · commit a31f2cb0cd4a · 2024-02-05T15:55:27.000+01:00
CanonPath, SourcePath: Change operator + to /
diff --git a/src/libexpr/eval.cc b/src/libexpr/eval.cc
@@ -2689,14 +2689,14 @@ SourcePath resolveExprPath(SourcePath path)
         // Basic cycle/depth limit to avoid infinite loops.
         if (++followCount >= maxFollow)
             throw Error("too many symbolic links encountered while traversing the path '%s'", path);
-        auto p = path.parent().resolveSymlinks() + path.baseName();
+        auto p = path.parent().resolveSymlinks() / path.baseName();
         if (p.lstat().type != InputAccessor::tSymlink) break;
         path = {path.accessor, CanonPath(p.readLink(), path.path.parent().value_or(CanonPath::root))};
     }
 
     /* If `path' refers to a directory, append `/default.nix'. */
     if (path.resolveSymlinks().lstat().type == InputAccessor::tDirectory)
-        return path + "default.nix";
+        return path / "default.nix";
 
     return path;
 }
diff --git a/src/libexpr/primops.cc b/src/libexpr/primops.cc
@@ -1816,7 +1816,7 @@ static void prim_readDir(EvalState & state, const PosIdx pos, Value * * args, Va
             // detailed node info quickly in this case we produce a thunk to
             // query the file type lazily.
             auto epath = state.allocValue();
-            epath->mkPath(path + name);
+            epath->mkPath(path / name);
             if (!readFileType)
                 readFileType = &state.getBuiltin("readFileType");
             attr.mkApp(readFileType, epath);
diff --git a/src/libfetchers/filtering-input-accessor.cc b/src/libfetchers/filtering-input-accessor.cc
@@ -5,26 +5,26 @@ namespace nix {
 std::string FilteringInputAccessor::readFile(const CanonPath & path)
 {
     checkAccess(path);
-    return next->readFile(prefix + path);
+    return next->readFile(prefix / path);
 }
 
 bool FilteringInputAccessor::pathExists(const CanonPath & path)
 {
-    return isAllowed(path) && next->pathExists(prefix + path);
+    return isAllowed(path) && next->pathExists(prefix / path);
 }
 
 std::optional<InputAccessor::Stat> FilteringInputAccessor::maybeLstat(const CanonPath & path)
 {
     checkAccess(path);
-    return next->maybeLstat(prefix + path);
+    return next->maybeLstat(prefix / path);
 }
 
 InputAccessor::DirEntries FilteringInputAccessor::readDirectory(const CanonPath & path)
 {
     checkAccess(path);
     DirEntries entries;
-    for (auto & entry : next->readDirectory(prefix + path)) {
-        if (isAllowed(path + entry.first))
+    for (auto & entry : next->readDirectory(prefix / path)) {
+        if (isAllowed(path / entry.first))
             entries.insert(std::move(entry));
     }
     return entries;
@@ -33,12 +33,12 @@ InputAccessor::DirEntries FilteringInputAccessor::readDirectory(const CanonPath
 std::string FilteringInputAccessor::readLink(const CanonPath & path)
 {
     checkAccess(path);
-    return next->readLink(prefix + path);
+    return next->readLink(prefix / path);
 }
 
 std::string FilteringInputAccessor::showPath(const CanonPath & path)
 {
-    return next->showPath(prefix + path);
+    return next->showPath(prefix / path);
 }
 
 void FilteringInputAccessor::checkAccess(const CanonPath & path)
diff --git a/src/libfetchers/fs-input-accessor.cc b/src/libfetchers/fs-input-accessor.cc
@@ -48,7 +48,7 @@ struct FSInputAccessor : InputAccessor, PosixSourceAccessor
 
     CanonPath makeAbsPath(const CanonPath & path)
     {
-        return root + path;
+        return root / path;
     }
 
     std::optional<CanonPath> getPhysicalPath(const CanonPath & path) override
diff --git a/src/libfetchers/git-utils.cc b/src/libfetchers/git-utils.cc
@@ -295,7 +295,7 @@ struct GitRepoImpl : GitRepo, std::enable_shared_from_this<GitRepoImpl>
             throw Error("getting working directory status: %s", git_error_last()->message);
 
         /* Get submodule info. */
-        auto modulesFile = path + ".gitmodules";
+        auto modulesFile = path / ".gitmodules";
         if (pathExists(modulesFile.abs()))
             info.submodules = parseSubmodules(modulesFile);
 
diff --git a/src/libfetchers/git.cc b/src/libfetchers/git.cc
@@ -319,7 +319,7 @@ struct GitInputScheme : InputScheme
         if (!repoInfo.isLocal)
             throw Error("cannot commit '%s' to Git repository '%s' because it's not a working tree", path, input.to_string());
 
-        writeFile((CanonPath(repoInfo.url) + path).abs(), contents);
+        writeFile((CanonPath(repoInfo.url) / path).abs(), contents);
 
         auto result = runProgram(RunOptions {
             .program = "git",
@@ -680,7 +680,7 @@ struct GitInputScheme : InputScheme
             std::map<CanonPath, nix::ref<InputAccessor>> mounts;
 
             for (auto & submodule : repoInfo.workdirInfo.submodules) {
-                auto submodulePath = CanonPath(repoInfo.url) + submodule.path;
+                auto submodulePath = CanonPath(repoInfo.url) / submodule.path;
                 fetchers::Attrs attrs;
                 attrs.insert_or_assign("type", "git");
                 attrs.insert_or_assign("url", submodulePath.abs());
diff --git a/src/libfetchers/mercurial.cc b/src/libfetchers/mercurial.cc
@@ -141,7 +141,7 @@ struct MercurialInputScheme : InputScheme
         if (!isLocal)
             throw Error("cannot commit '%s' to Mercurial repository '%s' because it's not a working tree", path, input.to_string());
 
-        auto absPath = CanonPath(repoPath) + path;
+        auto absPath = CanonPath(repoPath) / path;
 
         writeFile(absPath.abs(), contents);
 
diff --git a/src/libfetchers/path.cc b/src/libfetchers/path.cc
@@ -84,7 +84,7 @@ struct PathInputScheme : InputScheme
         std::string_view contents,
         std::optional<std::string> commitMsg) const override
     {
-        writeFile((CanonPath(getAbsPath(input)) + path).abs(), contents);
+        writeFile((CanonPath(getAbsPath(input)) / path).abs(), contents);
     }
 
     CanonPath getAbsPath(const Input & input) const
diff --git a/src/libstore/binary-cache-store.cc b/src/libstore/binary-cache-store.cc
@@ -235,14 +235,14 @@ ref<const ValidPathInfo> BinaryCacheStore::addToStoreCommon(
             std::regex regex2("^[0-9a-f]{38}\\.debug$");
 
             for (auto & [s1, _type] : narAccessor->readDirectory(buildIdDir)) {
-                auto dir = buildIdDir + s1;
+                auto dir = buildIdDir / s1;
 
                 if (narAccessor->lstat(dir).type != SourceAccessor::tDirectory
                     || !std::regex_match(s1, regex1))
                     continue;
 
                 for (auto & [s2, _type] : narAccessor->readDirectory(dir)) {
-                    auto debugPath = dir + s2;
+                    auto debugPath = dir / s2;
 
                     if (narAccessor->lstat(debugPath).type != SourceAccessor::tRegular
                         || !std::regex_match(s2, regex2))
diff --git a/src/libstore/local-fs-store.cc b/src/libstore/local-fs-store.cc
@@ -28,7 +28,7 @@ struct LocalStoreAccessor : PosixSourceAccessor
         auto [storePath, rest] = store->toStorePath(path.abs());
         if (requireValidPath && !store->isValidPath(storePath))
             throw InvalidPath("path '%1%' is not a valid store path", store->printStorePath(storePath));
-        return CanonPath(store->getRealStoreDir()) + storePath.to_string() + CanonPath(rest);
+        return CanonPath(store->getRealStoreDir()) / storePath.to_string() / CanonPath(rest);
     }
 
     std::optional<Stat> maybeLstat(const CanonPath & path) override
diff --git a/src/libstore/nar-accessor.cc b/src/libstore/nar-accessor.cc
@@ -277,7 +277,7 @@ json listNar(ref<SourceAccessor> accessor, const CanonPath & path, bool recurse)
             json &res2 = obj["entries"];
             for (const auto & [name, type] : accessor->readDirectory(path)) {
                 if (recurse) {
-                    res2[name] = listNar(accessor, path + name, true);
+                    res2[name] = listNar(accessor, path / name, true);
                 } else
                     res2[name] = json::object();
             }
diff --git a/src/libutil/archive.cc b/src/libutil/archive.cc
@@ -77,20 +77,20 @@ void SourceAccessor::dumpPath(
                     std::string name(i.first);
                     size_t pos = i.first.find(caseHackSuffix);
                     if (pos != std::string::npos) {
-                        debug("removing case hack suffix from '%s'", path + i.first);
+                        debug("removing case hack suffix from '%s'", path / i.first);
                         name.erase(pos);
                     }
                     if (!unhacked.emplace(name, i.first).second)
                         throw Error("file name collision in between '%s' and '%s'",
-                            (path + unhacked[name]),
-                            (path + i.first));
+                            (path / unhacked[name]),
+                            (path / i.first));
                 } else
                     unhacked.emplace(i.first, i.first);
 
             for (auto & i : unhacked)
-                if (filter((path + i.first).abs())) {
+                if (filter((path / i.first).abs())) {
                     sink << "entry" << "(" << "name" << i.first << "node";
-                    dump(path + i.second);
+                    dump(path / i.second);
                     sink << ")";
                 }
         }
diff --git a/src/libutil/canon-path.cc b/src/libutil/canon-path.cc
@@ -63,7 +63,7 @@ void CanonPath::extend(const CanonPath & x)
         path += x.abs();
 }
 
-CanonPath CanonPath::operator + (const CanonPath & x) const
+CanonPath CanonPath::operator / (const CanonPath & x) const
 {
     auto res = *this;
     res.extend(x);
@@ -78,7 +78,7 @@ void CanonPath::push(std::string_view c)
     path += c;
 }
 
-CanonPath CanonPath::operator + (std::string_view c) const
+CanonPath CanonPath::operator / (std::string_view c) const
 {
     auto res = *this;
     res.push(c);
diff --git a/src/libutil/canon-path.hh b/src/libutil/canon-path.hh
@@ -190,14 +190,14 @@ public:
     /**
      * Concatenate two paths.
      */
-    CanonPath operator + (const CanonPath & x) const;
+    CanonPath operator / (const CanonPath & x) const;
 
     /**
      * Add a path component to this one. It must not contain any slashes.
      */
     void push(std::string_view c);
 
-    CanonPath operator + (std::string_view c) const;
+    CanonPath operator / (std::string_view c) const;
 
     /**
      * Check whether access to this path is allowed, which is the case
diff --git a/src/libutil/fs-sink.cc b/src/libutil/fs-sink.cc
@@ -34,7 +34,7 @@ void copyRecursive(
         sink.createDirectory(to);
         for (auto & [name, _] : accessor.readDirectory(from)) {
             copyRecursive(
-                accessor, from + name,
+                accessor, from / name,
                 sink, to + "/" + name);
             break;
         }
diff --git a/src/libutil/git.cc b/src/libutil/git.cc
@@ -259,7 +259,7 @@ Mode dump(
     {
         Tree entries;
         for (auto & [name, _] : accessor.readDirectory(path)) {
-            auto child = path + name;
+            auto child = path / name;
             if (!filter(child.abs())) continue;
 
             auto entry = hook(child);
diff --git a/src/libutil/source-path.cc b/src/libutil/source-path.cc
@@ -41,11 +41,11 @@ std::optional<CanonPath> SourcePath::getPhysicalPath() const
 std::string SourcePath::to_string() const
 { return accessor->showPath(path); }
 
-SourcePath SourcePath::operator+(const CanonPath & x) const
-{ return {accessor, path + x}; }
+SourcePath SourcePath::operator / (const CanonPath & x) const
+{ return {accessor, path / x}; }
 
-SourcePath SourcePath::operator+(std::string_view c) const
-{  return {accessor, path + c}; }
+SourcePath SourcePath::operator / (std::string_view c) const
+{ return {accessor, path / c}; }
 
 bool SourcePath::operator==(const SourcePath & x) const
 {
diff --git a/src/libutil/source-path.hh b/src/libutil/source-path.hh
@@ -89,14 +89,15 @@ struct SourcePath
     /**
      * Append a `CanonPath` to this path.
      */
-    SourcePath operator + (const CanonPath & x) const;
+    SourcePath operator / (const CanonPath & x) const;
 
     /**
      * Append a single component `c` to this path. `c` must not
      * contain a slash. A slash is implicitly added between this path
      * and `c`.
      */
-    SourcePath operator+(std::string_view c) const;
+    SourcePath operator / (std::string_view c) const;
+
     bool operator==(const SourcePath & x) const;
     bool operator!=(const SourcePath & x) const;
     bool operator<(const SourcePath & x) const;
diff --git a/src/nix-env/nix-env.cc b/src/nix-env/nix-env.cc
@@ -97,7 +97,7 @@ static bool isNixExpr(const SourcePath & path, struct InputAccessor::Stat & st)
 {
     return
         st.type == InputAccessor::tRegular
-        || (st.type == InputAccessor::tDirectory && (path + "default.nix").resolveSymlinks().pathExists());
+        || (st.type == InputAccessor::tDirectory && (path / "default.nix").resolveSymlinks().pathExists());
 }
 
 
@@ -116,7 +116,7 @@ static void getAllExprs(EvalState & state,
            are implemented using profiles). */
         if (i == "manifest.nix") continue;
 
-        auto path2 = (path + i).resolveSymlinks();
+        auto path2 = (path / i).resolveSymlinks();
 
         InputAccessor::Stat st;
         try {
diff --git a/src/nix/ls.cc b/src/nix/ls.cc
@@ -72,7 +72,7 @@ struct MixLs : virtual Args, MixJSON
             if (st.type == SourceAccessor::Type::tDirectory && !showDirectory) {
                 auto names = accessor->readDirectory(curPath);
                 for (auto & [name, type] : names)
-                    showFile(curPath + name, relPath + "/" + name);
+                    showFile(curPath / name, relPath + "/" + name);
             } else
                 showFile(curPath, relPath);
         };
diff --git a/src/nix/run.cc b/src/nix/run.cc
@@ -124,7 +124,7 @@ struct CmdShell : InstallablesCommand, MixEnvironment
             if (true)
                 pathAdditions.push_back(store->printStorePath(path) + "/bin");
 
-            auto propPath = CanonPath(store->printStorePath(path)) + "nix-support" + "propagated-user-env-packages";
+            auto propPath = CanonPath(store->printStorePath(path)) / "nix-support" / "propagated-user-env-packages";
             if (auto st = accessor->maybeLstat(propPath); st && st->type == SourceAccessor::tRegular) {
                 for (auto & p : tokenizeString<Paths>(accessor->readFile(propPath)))
                     todo.push(store->parseStorePath(p));
diff --git a/src/nix/why-depends.cc b/src/nix/why-depends.cc
@@ -225,7 +225,7 @@ struct CmdWhyDepends : SourceExprCommand, MixOperateOnOptions
                 if (st->type == SourceAccessor::Type::tDirectory) {
                     auto names = accessor->readDirectory(p);
                     for (auto & [name, type] : names)
-                        visitPath(p + name);
+                        visitPath(p / name);
                 }
 
                 else if (st->type == SourceAccessor::Type::tRegular) {
diff --git a/tests/unit/libutil/canon-path.cc b/tests/unit/libutil/canon-path.cc
@@ -80,29 +80,29 @@ namespace nix {
         {
             CanonPath p1("a//foo/bar//");
             CanonPath p2("xyzzy/bla");
-            ASSERT_EQ((p1 + p2).abs(), "/a/foo/bar/xyzzy/bla");
+            ASSERT_EQ((p1 / p2).abs(), "/a/foo/bar/xyzzy/bla");
         }
 
         {
             CanonPath p1("/");
             CanonPath p2("/a/b");
-            ASSERT_EQ((p1 + p2).abs(), "/a/b");
+            ASSERT_EQ((p1 / p2).abs(), "/a/b");
         }
 
         {
             CanonPath p1("/a/b");
             CanonPath p2("/");
-            ASSERT_EQ((p1 + p2).abs(), "/a/b");
+            ASSERT_EQ((p1 / p2).abs(), "/a/b");
         }
 
         {
             CanonPath p("/foo/bar");
-            ASSERT_EQ((p + "x").abs(), "/foo/bar/x");
+            ASSERT_EQ((p / "x").abs(), "/foo/bar/x");
         }
 
         {
             CanonPath p("/");
-            ASSERT_EQ((p + "foo" + "bar").abs(), "/foo/bar");
+            ASSERT_EQ((p / "foo" / "bar").abs(), "/foo/bar");
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -5,26 +5,26 @@ namespace nix {`
`5`	`5`	`std::string FilteringInputAccessor::readFile(const CanonPath & path)`
`6`	`6`	`{`
`7`	`7`	`checkAccess(path);`
`8`		`- return next->readFile(prefix + path);`
	`8`	`+ return next->readFile(prefix / path);`
`9`	`9`	`}`
`10`	`10`
`11`	`11`	`bool FilteringInputAccessor::pathExists(const CanonPath & path)`
`12`	`12`	`{`
`13`		`- return isAllowed(path) && next->pathExists(prefix + path);`
	`13`	`+ return isAllowed(path) && next->pathExists(prefix / path);`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`std::optional<InputAccessor::Stat> FilteringInputAccessor::maybeLstat(const CanonPath & path)`
`17`	`17`	`{`
`18`	`18`	`checkAccess(path);`
`19`		`- return next->maybeLstat(prefix + path);`
	`19`	`+ return next->maybeLstat(prefix / path);`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`InputAccessor::DirEntries FilteringInputAccessor::readDirectory(const CanonPath & path)`
`23`	`23`	`{`
`24`	`24`	`checkAccess(path);`
`25`	`25`	`DirEntries entries;`
`26`		`- for (auto & entry : next->readDirectory(prefix + path)) {`
`27`		`- if (isAllowed(path + entry.first))`
	`26`	`+ for (auto & entry : next->readDirectory(prefix / path)) {`
	`27`	`+ if (isAllowed(path / entry.first))`
`28`	`28`	`entries.insert(std::move(entry));`
`29`	`29`	`}`
`30`	`30`	`return entries;`
`@@ -33,12 +33,12 @@ InputAccessor::DirEntries FilteringInputAccessor::readDirectory(const CanonPath`
`33`	`33`	`std::string FilteringInputAccessor::readLink(const CanonPath & path)`
`34`	`34`	`{`
`35`	`35`	`checkAccess(path);`
`36`		`- return next->readLink(prefix + path);`
	`36`	`+ return next->readLink(prefix / path);`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`std::string FilteringInputAccessor::showPath(const CanonPath & path)`
`40`	`40`	`{`
`41`		`- return next->showPath(prefix + path);`
	`41`	`+ return next->showPath(prefix / path);`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`void FilteringInputAccessor::checkAccess(const CanonPath & path)`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ struct FSInputAccessor : InputAccessor, PosixSourceAccessor`
`48`	`48`
`49`	`49`	`CanonPath makeAbsPath(const CanonPath & path)`
`50`	`50`	`{`
`51`		`- return root + path;`
	`51`	`+ return root / path;`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`std::optional<CanonPath> getPhysicalPath(const CanonPath & path) override`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ struct PathInputScheme : InputScheme`
`84`	`84`	`std::string_view contents,`
`85`	`85`	`std::optional<std::string> commitMsg) const override`
`86`	`86`	`{`
`87`		`- writeFile((CanonPath(getAbsPath(input)) + path).abs(), contents);`
	`87`	`+ writeFile((CanonPath(getAbsPath(input)) / path).abs(), contents);`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`CanonPath getAbsPath(const Input & input) const`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ struct LocalStoreAccessor : PosixSourceAccessor`
`28`	`28`	`auto [storePath, rest] = store->toStorePath(path.abs());`
`29`	`29`	`if (requireValidPath && !store->isValidPath(storePath))`
`30`	`30`	`throw InvalidPath("path '%1%' is not a valid store path", store->printStorePath(storePath));`
`31`		`- return CanonPath(store->getRealStoreDir()) + storePath.to_string() + CanonPath(rest);`
	`31`	`+ return CanonPath(store->getRealStoreDir()) / storePath.to_string() / CanonPath(rest);`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`std::optional<Stat> maybeLstat(const CanonPath & path) override`