refactoring: lockfile-path documentation and implementation cleanup

src/cargo/util/command_prelude.rs

@@ -13,14 +13,13 @@ use crate::util::{
     print_available_packages, print_available_tests,
 };
 use crate::CargoResult;
-use anyhow::{bail, Context};
+use anyhow::bail;
 use cargo_util::paths;
 use cargo_util_schemas::manifest::ProfileName;
 use cargo_util_schemas::manifest::RegistryName;
 use cargo_util_schemas::manifest::StringOrVec;
 use clap::builder::UnknownArgumentValueParser;
 use std::ffi::{OsStr, OsString};
-use std::fs;
 use std::path::Path;
 use std::path::PathBuf;
 
@@ -299,9 +298,8 @@ pub trait CommandExt: Sized {
 
     fn arg_lockfile_path(self) -> Self {
         self._arg(
-            opt("lockfile-path", "Path to the Cargo.lock file (unstable)")
+            opt("lockfile-path", "Path to Cargo.lock (unstable)")
                 .value_name("FILE")
-                // TODO: seemed to be the best option, but maybe should be something else?
                 .help_heading(heading::MANIFEST_OPTIONS),
         )
     }
@@ -1007,18 +1005,14 @@ pub fn lockfile_path(
     lockfile_path: Option<&Path>,
     gctx: &GlobalContext,
 ) -> CargoResult<Option<PathBuf>> {
-    let path;
+    let Some(lockfile_path) = lockfile_path else {
+        return Ok(None);
+    };
 
-    if let Some(lockfile_path) = lockfile_path {
-        if !gctx.cli_unstable().unstable_options {
-            bail!("`--lockfile-path` option requires `-Zunstable-options`")
-        }
+    gctx.cli_unstable()
+        .fail_if_stable_opt("--lockfile-path", 5707)?;
 
-        if lockfile_path.is_absolute() {
-            path = lockfile_path.to_path_buf();
-        } else {
-            path = gctx.cwd().join(lockfile_path);
-        }
+    let path = gctx.cwd().join(lockfile_path);
 
     if !path.ends_with(LOCKFILE_NAME) && !crate::util::toml::is_embedded(&path) {
         bail!(
@@ -1034,31 +1028,12 @@ pub fn lockfile_path(
     }
     if !path.exists() {
         // Root case should already be covered above
-            let parent_path = lockfile_path
-                .parent()
-                .unwrap_or_else(|| unreachable!("Lockfile path can't be root"));
+        let parent_path = lockfile_path.parent().expect("lockfile path can't be root");
 
-            let exists = parent_path.try_exists().with_context(|| {
-                format!(
-                    "Failed to fetch lock file's parent path metadata {}",
-                    parent_path.display()
-                )
-            })?;
-
-            if !exists {
-                fs::create_dir_all(parent_path).with_context(|| {
-                    format!(
-                        "Failed to create lockfile-path parent directory {}",
-                        parent_path.display()
-                    )
-                })?
-            }
+        paths::create_dir_all(parent_path)?;
     }
 
     return Ok(Some(path));
-    }
-
-    Ok(None)
 }
 
 #[track_caller]

src/doc/man/generated_txt/cargo-add.txt

@@ -198,14 +198,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-bench.txt

@@ -369,14 +369,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-build.txt

@@ -303,14 +303,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-check.txt

@@ -288,14 +288,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-clean.txt

@@ -124,14 +124,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-doc.txt

@@ -259,14 +259,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-fetch.txt

@@ -103,14 +103,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-fix.txt

@@ -361,14 +361,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-generate-lockfile.txt

@@ -82,14 +82,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-metadata.txt

@@ -439,14 +439,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-package.txt

@@ -213,14 +213,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-pkgid.txt

@@ -117,14 +117,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-publish.txt

@@ -161,14 +161,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-remove.txt

@@ -94,14 +94,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-run.txt

@@ -207,14 +207,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-rustc.txt

@@ -305,14 +305,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-rustdoc.txt

@@ -275,14 +275,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-test.txt

@@ -395,14 +395,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-tree.txt

@@ -244,14 +244,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-update.txt

@@ -141,14 +141,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/generated_txt/cargo-vendor.txt

@@ -86,14 +86,14 @@ OPTIONS
            Equivalent to specifying both --locked and --offline.
 
        --lockfile-path PATH
-           Changes the path of the lockfile from the default (./Cargo.lock) to
-           PATH. PATH must end with Cargo.lock (e.g. --lockfile-path
-           /tmp/temporary-lockfile/Cargo.lock). Note that providing
-           --lockfile-path will ignore existing default lockfile
-           (./Cargo.lock), if exists, and instead will either use PATH lockfile
-           (or write a new lockfile into the provided path if it doesn’t
-           exist). This flag can be used to run most commands in read-only
-           directories, writing lockfile into the provided PATH.
+           Changes the path of the lockfile from the default
+           (<workspace_root>/Cargo.lock) to PATH. PATH must end with Cargo.lock
+           (e.g. --lockfile-path /tmp/temporary-lockfile/Cargo.lock). Note that
+           providing --lockfile-path will ignore existing default lockfile
+           (<workspace_root>/Cargo.lock), if exists, and instead will either
+           use PATH lockfile (or write a new lockfile into the provided path if
+           it doesn’t exist). This flag can be used to run most commands in
+           read-only directories, writing lockfile into the provided PATH.
 
            This option is only available on the nightly channel
            <https://doc.rust-lang.org/book/appendix-07-nightly-rust.html> and

src/doc/man/includes/options-lockfile-path.md

@@ -1,7 +1,7 @@
 {{#option "`--lockfile-path` _PATH_"}}
-Changes the path of the lockfile from the default (`./Cargo.lock`) to _PATH_. _PATH_ must end with 
+Changes the path of the lockfile from the default (`<workspace_root>/Cargo.lock`) to _PATH_. _PATH_ must end with 
 `Cargo.lock` (e.g. `--lockfile-path /tmp/temporary-lockfile/Cargo.lock`). Note that providing 
-`--lockfile-path` will ignore existing default lockfile (`./Cargo.lock`), if exists, and instead will 
+`--lockfile-path` will ignore existing default lockfile (`<workspace_root>/Cargo.lock`), if exists, and instead will 
 either use _PATH_ lockfile (or write a new lockfile into the provided path if it doesn't exist). 
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided _PATH_.
 

src/doc/src/commands/cargo-add.md

@@ -217,9 +217,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-add---lockfile-path"><a class="option-anchor" href="#option-cargo-add---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-bench.md

@@ -406,9 +406,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-bench---lockfile-path"><a class="option-anchor" href="#option-cargo-bench---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-build.md

@@ -337,9 +337,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-build---lockfile-path"><a class="option-anchor" href="#option-cargo-build---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-check.md

@@ -319,9 +319,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-check---lockfile-path"><a class="option-anchor" href="#option-cargo-check---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-clean.md

@@ -140,9 +140,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-clean---lockfile-path"><a class="option-anchor" href="#option-cargo-clean---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-doc.md

@@ -294,9 +294,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-doc---lockfile-path"><a class="option-anchor" href="#option-cargo-doc---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-fetch.md

@@ -107,9 +107,9 @@ if there might be a newer version as indicated in the local copy of the index.</
 
 
 <dt class="option-term" id="option-cargo-fetch---lockfile-path"><a class="option-anchor" href="#option-cargo-fetch---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-fix.md

@@ -399,9 +399,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-fix---lockfile-path"><a class="option-anchor" href="#option-cargo-fix---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-generate-lockfile.md

@@ -92,9 +92,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-generate-lockfile---lockfile-path"><a class="option-anchor" href="#option-cargo-generate-lockfile---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-metadata.md

@@ -460,9 +460,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-metadata---lockfile-path"><a class="option-anchor" href="#option-cargo-metadata---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-package.md

@@ -234,9 +234,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-package---lockfile-path"><a class="option-anchor" href="#option-cargo-package---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-pkgid.md

@@ -120,9 +120,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-pkgid---lockfile-path"><a class="option-anchor" href="#option-cargo-pkgid---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-publish.md

@@ -181,9 +181,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-publish---lockfile-path"><a class="option-anchor" href="#option-cargo-publish---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-remove.md

@@ -111,9 +111,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-remove---lockfile-path"><a class="option-anchor" href="#option-cargo-remove---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-run.md

@@ -239,9 +239,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-run---lockfile-path"><a class="option-anchor" href="#option-cargo-run---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-rustc.md

@@ -333,9 +333,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-rustc---lockfile-path"><a class="option-anchor" href="#option-cargo-rustc---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-rustdoc.md

@@ -314,9 +314,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-rustdoc---lockfile-path"><a class="option-anchor" href="#option-cargo-rustdoc---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-test.md

@@ -435,9 +435,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-test---lockfile-path"><a class="option-anchor" href="#option-cargo-test---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-tree.md

@@ -252,9 +252,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-tree---lockfile-path"><a class="option-anchor" href="#option-cargo-tree---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-update.md

@@ -151,9 +151,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-update---lockfile-path"><a class="option-anchor" href="#option-cargo-update---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/doc/src/commands/cargo-vendor.md

@@ -98,9 +98,9 @@ offline.</p>
 
 
 <dt class="option-term" id="option-cargo-vendor---lockfile-path"><a class="option-anchor" href="#option-cargo-vendor---lockfile-path"></a><code>--lockfile-path</code> <em>PATH</em></dt>
-<dd class="option-desc">Changes the path of the lockfile from the default (<code>./Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
+<dd class="option-desc">Changes the path of the lockfile from the default (<code>&lt;workspace_root&gt;/Cargo.lock</code>) to <em>PATH</em>. <em>PATH</em> must end with
 <code>Cargo.lock</code> (e.g. <code>--lockfile-path /tmp/temporary-lockfile/Cargo.lock</code>). Note that providing
-<code>--lockfile-path</code> will ignore existing default lockfile (<code>./Cargo.lock</code>), if exists, and instead will
+<code>--lockfile-path</code> will ignore existing default lockfile (<code>&lt;workspace_root&gt;/Cargo.lock</code>), if exists, and instead will
 either use <em>PATH</em> lockfile (or write a new lockfile into the provided path if it doesn’t exist).
 This flag can be used to run most commands in read-only directories, writing lockfile into the provided <em>PATH</em>.</p>
 <p>This option is only available on the <a href="https://doc.rust-lang.org/book/appendix-07-nightly-rust.html">nightly

src/etc/man/cargo-add.1

@@ -257,9 +257,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-bench.1

@@ -457,9 +457,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-build.1

@@ -375,9 +375,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-check.1

@@ -356,9 +356,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-clean.1

@@ -156,9 +156,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-doc.1

@@ -323,9 +323,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-fetch.1

@@ -122,9 +122,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-fix.1

@@ -451,9 +451,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-generate-lockfile.1

@@ -108,9 +108,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-metadata.1

@@ -479,9 +479,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-package.1

@@ -263,9 +263,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-pkgid.1

@@ -162,9 +162,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-publish.1

@@ -195,9 +195,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-remove.1

@@ -122,9 +122,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-run.1

@@ -260,9 +260,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-rustc.1

@@ -374,9 +374,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-rustdoc.1

@@ -342,9 +342,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-test.1

@@ -484,9 +484,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-tree.1

@@ -307,9 +307,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-update.1

@@ -184,9 +184,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

src/etc/man/cargo-vendor.1

@@ -103,9 +103,9 @@ Equivalent to specifying both \fB\-\-locked\fR and \fB\-\-offline\fR\&.
 .sp
 \fB\-\-lockfile\-path\fR \fIPATH\fR
 .RS 4
-Changes the path of the lockfile from the default (\fB\&./Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
+Changes the path of the lockfile from the default (\fB<workspace_root>/Cargo.lock\fR) to \fIPATH\fR\&. \fIPATH\fR must end with
 \fBCargo.lock\fR (e.g. \fB\-\-lockfile\-path /tmp/temporary\-lockfile/Cargo.lock\fR). Note that providing
-\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB\&./Cargo.lock\fR), if exists, and instead will
+\fB\-\-lockfile\-path\fR will ignore existing default lockfile (\fB<workspace_root>/Cargo.lock\fR), if exists, and instead will
 either use \fIPATH\fR lockfile (or write a new lockfile into the provided path if it doesn\[cq]t exist).
 This flag can be used to run most commands in read\-only directories, writing lockfile into the provided \fIPATH\fR\&.
 .sp

tests/testsuite/cargo_add/help/stdout.term.svg

@@ -175,7 +175,7 @@
 </tspan>
     <tspan x="10px" y="1414px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan>
 </tspan>
-    <tspan x="10px" y="1432px"><tspan>          Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="1432px"><tspan>          Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="1450px">
 </tspan>

tests/testsuite/cargo_bench/help/stdout.term.svg

@@ -125,7 +125,7 @@
 </tspan>
     <tspan x="10px" y="964px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="982px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="982px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="1000px"><tspan>      </tspan><tspan class="fg-cyan bold">--ignore-rust-version</tspan><tspan>   Ignore `rust-version` specification in packages</tspan>
 </tspan>

tests/testsuite/cargo_build/help/stdout.term.svg

@@ -123,7 +123,7 @@
 </tspan>
     <tspan x="10px" y="946px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="964px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="964px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="982px"><tspan>      </tspan><tspan class="fg-cyan bold">--ignore-rust-version</tspan><tspan>   Ignore `rust-version` specification in packages</tspan>
 </tspan>

tests/testsuite/cargo_check/help/stdout.term.svg

@@ -119,7 +119,7 @@
 </tspan>
     <tspan x="10px" y="910px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="928px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="928px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="946px"><tspan>      </tspan><tspan class="fg-cyan bold">--ignore-rust-version</tspan><tspan>   Ignore `rust-version` specification in packages</tspan>
 </tspan>

tests/testsuite/cargo_clean/help/stdout.term.svg

@@ -69,7 +69,7 @@
 </tspan>
     <tspan x="10px" y="460px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="478px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="478px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="496px"><tspan>      </tspan><tspan class="fg-cyan bold">--locked</tspan><tspan>                Assert that `Cargo.lock` will remain unchanged</tspan>
 </tspan>

tests/testsuite/cargo_doc/help/stdout.term.svg

@@ -113,7 +113,7 @@
 </tspan>
     <tspan x="10px" y="856px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="874px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="874px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="892px"><tspan>      </tspan><tspan class="fg-cyan bold">--ignore-rust-version</tspan><tspan>   Ignore `rust-version` specification in packages</tspan>
 </tspan>

tests/testsuite/cargo_fetch/help/stdout.term.svg

@@ -53,7 +53,7 @@
 </tspan>
     <tspan x="10px" y="316px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="334px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="334px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="352px"><tspan>      </tspan><tspan class="fg-cyan bold">--locked</tspan><tspan>                Assert that `Cargo.lock` will remain unchanged</tspan>
 </tspan>

tests/testsuite/cargo_fix/help/stdout.term.svg

@@ -127,7 +127,7 @@
 </tspan>
     <tspan x="10px" y="982px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="1000px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="1000px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="1018px"><tspan>      </tspan><tspan class="fg-cyan bold">--ignore-rust-version</tspan><tspan>   Ignore `rust-version` specification in packages</tspan>
 </tspan>

tests/testsuite/cargo_generate_lockfile/help/stdout.term.svg

@@ -47,7 +47,7 @@
 </tspan>
     <tspan x="10px" y="262px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="280px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="280px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="298px"><tspan>      </tspan><tspan class="fg-cyan bold">--ignore-rust-version</tspan><tspan>   Ignore `rust-version` specification in packages (unstable)</tspan>
 </tspan>

tests/testsuite/cargo_metadata/help/stdout.term.svg

@@ -69,7 +69,7 @@
 </tspan>
     <tspan x="10px" y="460px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="478px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="478px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="496px"><tspan>      </tspan><tspan class="fg-cyan bold">--locked</tspan><tspan>                Assert that `Cargo.lock` will remain unchanged</tspan>
 </tspan>

tests/testsuite/cargo_package/help/stdout.term.svg

@@ -91,7 +91,7 @@
 </tspan>
     <tspan x="10px" y="658px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="676px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="676px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="694px"><tspan>      </tspan><tspan class="fg-cyan bold">--locked</tspan><tspan>                Assert that `Cargo.lock` will remain unchanged</tspan>
 </tspan>

tests/testsuite/cargo_pkgid/help/stdout.term.svg

@@ -59,7 +59,7 @@
 </tspan>
     <tspan x="10px" y="370px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="388px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="388px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="406px"><tspan>      </tspan><tspan class="fg-cyan bold">--locked</tspan><tspan>                Assert that `Cargo.lock` will remain unchanged</tspan>
 </tspan>

tests/testsuite/cargo_publish/help/stdout.term.svg

@@ -87,7 +87,7 @@
 </tspan>
     <tspan x="10px" y="622px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="640px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="640px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="658px"><tspan>      </tspan><tspan class="fg-cyan bold">--locked</tspan><tspan>                Assert that `Cargo.lock` will remain unchanged</tspan>
 </tspan>

tests/testsuite/cargo_remove/help/stdout.term.svg

@@ -71,7 +71,7 @@
 </tspan>
     <tspan x="10px" y="478px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="496px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="496px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="514px"><tspan>      </tspan><tspan class="fg-cyan bold">--locked</tspan><tspan>                Assert that `Cargo.lock` will remain unchanged</tspan>
 </tspan>

tests/testsuite/cargo_run/help/stdout.term.svg

@@ -101,7 +101,7 @@
 </tspan>
     <tspan x="10px" y="748px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="766px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="766px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="784px"><tspan>      </tspan><tspan class="fg-cyan bold">--ignore-rust-version</tspan><tspan>   Ignore `rust-version` specification in packages</tspan>
 </tspan>

tests/testsuite/cargo_rustc/help/stdout.term.svg

@@ -123,7 +123,7 @@
 </tspan>
     <tspan x="10px" y="946px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="964px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="964px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="982px"><tspan>      </tspan><tspan class="fg-cyan bold">--ignore-rust-version</tspan><tspan>   Ignore `rust-version` specification in packages</tspan>
 </tspan>

tests/testsuite/cargo_rustdoc/help/stdout.term.svg

@@ -121,7 +121,7 @@
 </tspan>
     <tspan x="10px" y="928px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="946px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="946px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="964px"><tspan>      </tspan><tspan class="fg-cyan bold">--ignore-rust-version</tspan><tspan>   Ignore `rust-version` specification in packages</tspan>
 </tspan>

tests/testsuite/cargo_test/help/stdout.term.svg

@@ -131,7 +131,7 @@
 </tspan>
     <tspan x="10px" y="1018px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="1036px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="1036px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="1054px"><tspan>      </tspan><tspan class="fg-cyan bold">--ignore-rust-version</tspan><tspan>   Ignore `rust-version` specification in packages</tspan>
 </tspan>

tests/testsuite/cargo_tree/help/stdout.term.svg

@@ -97,7 +97,7 @@
 </tspan>
     <tspan x="10px" y="712px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="730px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="730px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="748px"><tspan>      </tspan><tspan class="fg-cyan bold">--locked</tspan><tspan>                Assert that `Cargo.lock` will remain unchanged</tspan>
 </tspan>

tests/testsuite/cargo_update/help/stdout.term.svg

@@ -63,7 +63,7 @@
 </tspan>
     <tspan x="10px" y="406px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="424px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="424px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="442px"><tspan>      </tspan><tspan class="fg-cyan bold">--ignore-rust-version</tspan><tspan>   Ignore `rust-version` specification in packages (unstable)</tspan>
 </tspan>

tests/testsuite/cargo_vendor/help/stdout.term.svg

@@ -63,7 +63,7 @@
 </tspan>
     <tspan x="10px" y="406px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="424px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to the Cargo.lock file (unstable)</tspan>
+    <tspan x="10px" y="424px"><tspan>      </tspan><tspan class="fg-cyan bold">--lockfile-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FILE&gt;</tspan><tspan>  Path to Cargo.lock (unstable)</tspan>
 </tspan>
     <tspan x="10px" y="442px"><tspan>      </tspan><tspan class="fg-cyan bold">--locked</tspan><tspan>                Assert that `Cargo.lock` will remain unchanged</tspan>
 </tspan>

tests/testsuite/lockfile_path.rs

@@ -181,15 +181,16 @@ fn assert_broken_symlink(
         "Cannot create a file when that file already exists. (os error 183)"
     };
 
-
     make_execs(&mut p.cargo(command), lockfile_path_argument.to_string())
         .with_status(101)
         .with_stderr_data(&format!(
-            r#"[ERROR] Failed to create lockfile-path parent directory somedir/link
+            r#"[ERROR] failed to create directory `somedir/link`
 
 Caused by:
   {}
-"#, err_msg))
+"#,
+            err_msg
+        ))
         .replace_crates_io(registry.index_url())
         .run();
 }
@@ -215,21 +216,21 @@ fn assert_loop_symlink(
     let registry = RegistryBuilder::new().http_api().http_index().build();
 
     let err_msg = if cfg!(windows) {
-        "The name of the file cannot be resolved by the system. (os error 1921)"
-    } else if cfg!(target_os = "macos") {
-        "Too many levels of symbolic links (os error 62)"
+        "Cannot create a file when that file already exists. (os error 183)"
     } else {
-        "Too many levels of symbolic links (os error 40)"
+        "File exists (os error 17)"
     };
 
     make_execs(&mut p.cargo(command), lockfile_path_argument.to_string())
         .with_status(101)
         .with_stderr_data(&format!(
-            r#"[ERROR] Failed to fetch lock file's parent path metadata somedir/link
+            r#"[ERROR] failed to create directory `somedir/link`
 
 Caused by:
   {}
-"#, err_msg))
+"#,
+            err_msg
+        ))
         .replace_crates_io(registry.index_url())
         .run();
 }