path: remove repository argument from worktree_git_path()

worktree_git_path() takes a struct repository and a struct worktree
which also contains a struct repository. The repository argument
was added by a973f60dc7c (path: stop relying on `the_repository` in
`worktree_git_path()`, 2024-08-13) and exists because the worktree
argument is optional. Having two ways of passing a repository is
a potential foot-gun as if the the worktree argument is present the
repository argument must match the worktree's repository member. Since
the last commit there are no callers that pass a NULL worktree so lets
remove the repository argument. This removes the potential confusion
and lets us delete a number of uses of "the_repository".

worktree_git_path() has the following callers:

 - builtin/worktree.c:validate_no_submodules() which is called from
   check_clean_worktree() and move_worktree(), both of which supply
   a non-NULL worktree.

 - builtin/fsck.c:cmd_fsck() which loops over all worktrees.

 - revision.c:add_index_objects_to_pending() which loops over all
   worktrees.

 - worktree.c:worktree_lock_reason() which dereferences wt before
   calling worktree_git_path().

 - wt-status.c:wt_status_check_bisect() and wt_status_check_rebase()
   which are always called with a non-NULL worktree after the last
   commit.

 - wt-status.c:git_branch() which is only called by
   wt_status_check_bisect() and wt_status_check_rebase().

Signed-off-by: Phillip Wood <phillip.wood@dunelm.org.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/fsck.c b/builtin/fsck.c
index 0512f78a87fe1da9ceb8786da89d94a3e17df72e..42ba0afb91a905da83b8c6974f1ad6da1a356c80 100644 (file)
--- a/builtin/fsck.c
+++ b/builtin/fsck.c
@@ -1137,7 +1137,7 @@ int cmd_fsck(int argc,
                         * and may get overwritten by other calls
                         * while we're examining the index.
                         */
-                       path = xstrdup(worktree_git_path(the_repository, wt, "index"));
+                       path = xstrdup(worktree_git_path(wt, "index"));
                        wt_gitdir = get_worktree_git_dir(wt);
 
                        read_index_from(&istate, path, wt_gitdir);

diff --git a/builtin/worktree.c b/builtin/worktree.c
index fbdaf2eb2eb85ce33e2001dfa5030fca9ddaeaf4..1019093bce80fb3f5a12ca3b43f67a2e23f86d5d 100644 (file)
--- a/builtin/worktree.c
+++ b/builtin/worktree.c
@@ -1191,14 +1191,14 @@ static void validate_no_submodules(const struct worktree *wt)
 
        wt_gitdir = get_worktree_git_dir(wt);
 
-       if (is_directory(worktree_git_path(the_repository, wt, "modules"))) {
+       if (is_directory(worktree_git_path(wt, "modules"))) {
                /*
                 * There could be false positives, e.g. the "modules"
                 * directory exists but is empty. But it's a rare case and
                 * this simpler check is probably good enough for now.
                 */
                found_submodules = 1;
-       } else if (read_index_from(&istate, worktree_git_path(the_repository, wt, "index"),
+       } else if (read_index_from(&istate, worktree_git_path(wt, "index"),
                                   wt_gitdir) > 0) {
                for (i = 0; i < istate.cache_nr; i++) {
                        struct cache_entry *ce = istate.cache[i];

diff --git a/path.c b/path.c
index d726537622cda67f222229358b8b7edd25c34f1b..073f631b914745ec125ba774415b17f9778d24ac 100644 (file)
--- a/path.c
+++ b/path.c
@@ -486,17 +486,16 @@ const char *mkpath(const char *fmt, ...)
        return cleanup_path(pathname->buf);
 }
 
-const char *worktree_git_path(struct repository *r,
-                             const struct worktree *wt, const char *fmt, ...)
+const char *worktree_git_path(const struct worktree *wt, const char *fmt, ...)
 {
        struct strbuf *pathname = get_pathname();
        va_list args;
 
-       if (wt && wt->repo != r)
-               BUG("worktree not connected to expected repository");
+       if (!wt)
+               BUG("%s() called with NULL worktree", __func__);
 
        va_start(args, fmt);
-       repo_git_pathv(r, wt, pathname, fmt, args);
+       repo_git_pathv(wt->repo, wt, pathname, fmt, args);
        va_end(args);
        return pathname->buf;
 }

diff --git a/path.h b/path.h
index 0ec95a0b079c905ec82b0f5455b8663827b70db7..cbcad254a0a0b590cb019fdf759f88d02b1c9b89 100644 (file)
--- a/path.h
+++ b/path.h
@@ -66,13 +66,11 @@ const char *repo_git_path_replace(struct repository *repo,
 
 /*
  * Similar to repo_git_path() but can produce paths for a specified
- * worktree instead of current one. When no worktree is given, then the path is
- * computed relative to main worktree of the given repository.
+ * worktree instead of current one.
  */
-const char *worktree_git_path(struct repository *r,
-                             const struct worktree *wt,
+const char *worktree_git_path(const struct worktree *wt,
                              const char *fmt, ...)
-       __attribute__((format (printf, 3, 4)));
+       __attribute__((format (printf, 2, 3)));
 
 /*
  * The `repo_worktree_path` family of functions will construct a path into a

diff --git a/revision.c b/revision.c
index 9b131670f79b96b72272ef554fefb511facab4b8..6e9e914d863842ffe09890165a7fe657a56e5e01 100644 (file)
--- a/revision.c
+++ b/revision.c
@@ -1847,7 +1847,7 @@ void add_index_objects_to_pending(struct rev_info *revs, unsigned int flags)
                wt_gitdir = get_worktree_git_dir(wt);
 
                if (read_index_from(&istate,
-                                   worktree_git_path(the_repository, wt, "index"),
+                                   worktree_git_path(wt, "index"),
                                    wt_gitdir) > 0)
                        do_add_index_objects_to_pending(revs, &istate, flags);
 

diff --git a/worktree.c b/worktree.c
index 218c332a66dc5c2a47b3b1a92c055b423e15f8b9..6e2f0f78283dbf4ed969d90aa14b539f35857673 100644 (file)
--- a/worktree.c
+++ b/worktree.c
@@ -308,7 +308,7 @@ const char *worktree_lock_reason(struct worktree *wt)
        if (!wt->lock_reason_valid) {
                struct strbuf path = STRBUF_INIT;
 
-               strbuf_addstr(&path, worktree_git_path(the_repository, wt, "locked"));
+               strbuf_addstr(&path, worktree_git_path(wt, "locked"));
                if (file_exists(path.buf)) {
                        struct strbuf lock_reason = STRBUF_INIT;
                        if (strbuf_read_file(&lock_reason, path.buf, 0) < 0)

diff --git a/wt-status.c b/wt-status.c
index eceb41fb659746be7ccae12d18961b81ffd6da78..e8234b2fa23e84d618d62a5baa4a033764eef21e 100644 (file)
--- a/wt-status.c
+++ b/wt-status.c
@@ -1624,7 +1624,7 @@ static char *get_branch(const struct worktree *wt, const char *path)
        struct object_id oid;
        const char *branch_name;
 
-       if (strbuf_read_file(&sb, worktree_git_path(the_repository, wt, "%s", path), 0) <= 0)
+       if (strbuf_read_file(&sb, worktree_git_path(wt, "%s", path), 0) <= 0)
                goto got_nothing;
 
        while (sb.len && sb.buf[sb.len - 1] == '\n')
@@ -1726,18 +1726,18 @@ int wt_status_check_rebase(const struct worktree *wt,
        if (!wt)
                BUG("wt_status_check_rebase() called with NULL worktree");
 
-       if (!stat(worktree_git_path(the_repository, wt, "rebase-apply"), &st)) {
-               if (!stat(worktree_git_path(the_repository, wt, "rebase-apply/applying"), &st)) {
+       if (!stat(worktree_git_path(wt, "rebase-apply"), &st)) {
+               if (!stat(worktree_git_path(wt, "rebase-apply/applying"), &st)) {
                        state->am_in_progress = 1;
-                       if (!stat(worktree_git_path(the_repository, wt, "rebase-apply/patch"), &st) && !st.st_size)
+                       if (!stat(worktree_git_path(wt, "rebase-apply/patch"), &st) && !st.st_size)
                                state->am_empty_patch = 1;
                } else {
                        state->rebase_in_progress = 1;
                        state->branch = get_branch(wt, "rebase-apply/head-name");
                        state->onto = get_branch(wt, "rebase-apply/onto");
                }
-       } else if (!stat(worktree_git_path(the_repository, wt, "rebase-merge"), &st)) {
-               if (!stat(worktree_git_path(the_repository, wt, "rebase-merge/interactive"), &st))
+       } else if (!stat(worktree_git_path(wt, "rebase-merge"), &st)) {
+               if (!stat(worktree_git_path(wt, "rebase-merge/interactive"), &st))
                        state->rebase_interactive_in_progress = 1;
                else
                        state->rebase_in_progress = 1;
@@ -1756,7 +1756,7 @@ int wt_status_check_bisect(const struct worktree *wt,
        if (!wt)
                BUG("wt_status_check_bisect() called with NULL worktree");
 
-       if (!stat(worktree_git_path(the_repository, wt, "BISECT_LOG"), &st)) {
+       if (!stat(worktree_git_path(wt, "BISECT_LOG"), &st)) {
                state->bisect_in_progress = 1;
                state->bisecting_from = get_branch(wt, "BISECT_START");
                return 1;