[PATCH] D15465: [git-clang-format]: New option to perform formatting against staged changes only

[Alexander Shukaev via Phabricator via cfe-commits]

Alexander-Shukaev added a comment.

Man, I have to admit it's really a shame that I didn't find time to work on this further but I'm truly too busy these days.  However, I believe the primary point why I didn't have motivation to do this is because the flaw that was pointed out actually never bothered me in real life simply because I've never ever hit this case in production.  I confess that I use this solution, namely the one linked on Stack Overflow (to my personal Bitbucket repository) every single day and we even introduced it in my company.  Nobody ever complained so far.  It's true that sometimes one would want to stage only some changes and commit them, while having other changes unstaged, but I don't remember when I was in that situation last time.  If you really want to leave something out for another commit, then you can also stash those unstaged changes before you format/commit the staged ones.  Furthermore, let me clarify why the proposal by @lodato might not even fit into the picture (i.e. there is no universal solution this problem as I see it until now).  In particular, his example does not illustrate another side of the medal, namely let's say that the staged code was, in fact, badly formatted (not like in his example), and then you apply some code on top of it that is not yet staged (same like in his example).  By "on top" I mean really like he shows it, that those changes overlap, that is if you'd stage them, they'd overwrite the previously staged ones (which in our imaginary example are badly formatted now).  Now let's think what will happen if we follow his proposal.  We'd apply formatting purely to the "staged" version of the file by piping it from index as a blob directly to formatter, so far so good.  Or wait a minute, how would you actually format that file in place then?  That is you already have unstaged and potentially conflicting changes with the ones you'd get as a result of formatting the staged ones but how to reconcile these two versions now?  That is how do you put those formatted changes into unstaged state when you already have something completely different but also unstaged at the same line?  Turns out that the answer is, you can't, without introducing explicit conflicts in the unstaged tree, which is even more confusing to my taste.  Or would you just report the diff with an error message to the user leaving the act of applying those to them manually?  You could, but then you give up on that cool feature of automatic formatting.  To conclude, which approach you take, is all about pros and cons.  On the daily basis and from productivity standpoint, I care more about doing my changes for the target commit, trying to commit, if something is wrong getting it automatically formatted in the unstaged tree, reviewing this unstaged diff quickly, staging it, and finally committing my work.  That corner case with some irrelevant changes hanging in the unstaged tree and fooling formatter can rarely be a problem.  And even then, I treat it more like an answer from a formatter: "Hey bro, you have some unstaged crap out there, can you please already decide whether you need it now or not, otherwise I can't do my job for you?!", in which case I will

- either actually stage them if I really need them,
- or stash them if I want to deal with them later,
- or discard them altogether if they are garbage,

all of which will allow formatter to do it's job and me to finally produce the commit.


Repository:
  rL LLVM

https://reviews.llvm.org/D15465