Re: Proposal: tell git a file has been renamed

[Jacob Keller <jacob.e.keller@intel.com>]

On 4/24/2023 12:25 PM, Felipe Contreras wrote:
> Erik Cervin Edin wrote:
>> On Mon, Apr 24, 2023 at 1:17 PM Jeremy Morton <admin@game-point.net> wrote:
>>>
>>> There's no getting away from the fact that this adds a lot of (IMHO
>>> unnecessary) work if you've already done a rename that git can't
>>> detect and have both that and a bunch of other changes sitting in the
>>> index.  What feels like it would be a natural resolution in these
>>> cases, though, is a "no, this remove/add is actually a rename" command.
>>
>> It can definitely be both arduous and non-obvious how to deal with this.
>>
>> The problem is that such a command cannot exist atm. because renames
>> don't exist, they are only interpreted. So the only way to achieve
>> this is to revert enough of the contents staged to the index such that
>> the rename is detected. The only way to do that in a foolproof manner
>> is reverting all the staged changes except the path so that the moved
>> file in the index is identical to the old file in HEAD.
> 
> I agree recording renames explicitely might be a good addition to git, but the
> real question is how are they going to be stored in the object storage.
> 
> My guess is that it can be added in the commit object after "committer", just
> add a "renames" field with all the renames, or one "rename" field per rename.
> It would be backwards compatible because any field can be added this way.
> 
> How to generate these fields is a separate issue: first things first.
> 

I think such a renames field might work, but I know historically there
was a lot of resistance to "baking in" such rename logic because you
can't "fix" it later.

I know there are some big threads from early days of git discussing
this, with many objections on baking in renames for various reasons.

I think the argument can be made that there is still value in a commit
which says "I as the commiter know this is renaming the file, please
show it as such and track it as such", and I think the other use cases
(code moving from one file to another without a full rename, multiple
copies of a file getting deleted, etc) can be handled in other ways or
with an escape hatch to disable the commit rename indicator if necessary.

In the more complex cases where code is moved without a full rename,
there are tools for handling this such as pickaxe or the proposed magic
blame tool that was brought up in the discussions against static renames
being coded into the object storage. I think those are interesting but
separate problems from "I am renaming this file and some of its contents".

At commit basically is the only way this could be baked into the object
storage, since blobs don't store filenames and trees don't store any
method of difference individually. The commit is the only place to
really do it.

The alternative would be something like Junio suggested where we have a
separate rename storage database which is computed ahead of time (kind
of like commit graph storage) and which could be overridden manually.
This doesn't "bake" anything into the objects, but obviously requires
manually keeping up to date and adds some difficulty in sharing such
updates across remotes.