Junio C Hamano <gitster@xxxxxxxxx> writes:
> I just checked. The repository the push is run in is bare and its
> HEAD is detached, pointing at a commit directly.
Thanks, I was able to reproduce the segfault using your config.
>> "current_branch" is allowed to be NULL when HEAD does not point to a
>> branch.
>
> Good point. It is a good justification to make the remote_state
> available to the function, as branch==NULL that signals "there is no
> current branch in the repository" cannot be dereferenced to get to
> either the repository or the remote_state, yet the function needs
> access to remote_state even when branch==NULL.
Yes, I wish we had noticed this sooner in our discussion and the fault
is mine. It seems that pushremote_for_branch() is a prime example of
"get the settings from the branch if possible, but default to the
correct repository settings otherwise.", which is difficult to express
if remote_state is not available to the function.
> What "branch" is pushremote_for_branch() meant to take? Is there a
> caller that asks a hypothetical "I know this is not a branch that is
> the current branch in the repository, but to which remote would we
> push if this branch _were_ the current one?" (and passes NULL to
> mean "there is a checked out branch, but what happens if our HEAD
> were detached?") question? Even if there isn't currently, do we
> want to add such callers in the future?
>
> If the answer is yes, then the function need to take both branch and
> remote_state as two separate parameters. If the answer is no (i.e.
> we never ask hypothetical questions, we just ask what we should do
> in the current, real, state), then the function can just take the
> remote_state and remote_state->branch being NULL would be used as a
> signal that the HEAD is detached. I suspect it is the former, as
> this information is used in string-name-to-object translation for
> "topic@{push}" in object-name.c::interpret_branch_mark() function.
I agree that the need for hypothetical "what happens if HEAD were
detached?" questions may arise, though I'm not sure if there are any
right now. When we call branch_get(NULL), the expected return value is
the "current_branch". If there is no "current_branch" i.e. the return
value of branch_get() is the NULL branch. A NULL branch is not usable -
branch_get_push() and branch_get_upstream() return error messages
indicating "HEAD does not point to a branch". (these are the functions
used by object-name.c::interpret_branch_mark()).
Given the convention of "NULL branch == detached HEAD", how do we
proceed? Some options:
a) Represent detached HEAD with a non-NULL "struct branch". This will
let us continue using the remote_state backpointer, which makes many
interfaces clean, but is somewhat invasive, error-prone and it uses
"struct branch" for something that is not a branch, which is itself
an error-prone interface.
b) Keep the backpointer, but add remote_state as a parameter to
pushremote_for_branch(). The least possible effort to fix the problem
and might be 'easy' but is inconsistent with the other functions and
is prone to misuse because the backpointer and parameter can be
different.
c) Replace the backpointer with a remote_state parameter. Expressive and
fits the paradigm of "defaulting to the repo when needed", but
interfaces are repetitive and shifts the responsibility of
correctness to the caller (see v2).
d) Default to the_repository in pushremote_for_branch(). Easy, but
incorrect in general.
e) Some kind of reimagining of the remotes interfaces that doesn't
have this problem. One possible approach is to remove branches from
the remotes system altogether, since remotes are primarily concerned
with _branch tracking information_ and not really _branches_ per se;
perhaps we are being led astray by our terminology. If possible, this
is probably the most elegant long term solution, but it's
time-consuming and it's not clear how we will get there.
Currently, my preference is to go with (c). We can create a clear
expectation to callers that branch tracking information is not complete
without a repository, thus a repository is always supplied, explicitly
or not. If so, the remote_state parameter looks less like an
implementation detail, especially since a NULL branch is allowed.
I know we have already considered and abandoned (c) after v2, but has
your opinion changed after considering the new information?
