See what is making a revision immutable

[jennings]

I have a revision that is immutable. How can I see what is making it immutable?

[jennings]

Revisions are immutable if it has a descendant in immutable_heads(). So, if you have an immutable revision REV, there must be an immutable head somewhere in REV::.

You can see what's making it immutable with the following command:

jj log -r 'REV | roots(REV:: & immutable_heads())'

Explaining this revset from the beginning:

Revset expression                       Explanation
--------------------------------------  --------------------------------------------------------------
            REV::                       Include a revision and all its descendants...

            REV:: & immutable_heads()   ...which are immutable heads

      roots(REV:: & immutable_heads())  Only show the "first" immutable head in a line of descendants

REV | roots(REV:: & immutable_heads())  Include REV, so the output shows the lineage between
                                        REV and the revisions making it immutable

You can make this a revset alias to make it reusable:

[revset-aliases]
'why_immutable(r)' = 'r | roots(r:: & immutable_heads())'

$ jj log -r 'why_immutable(xyz)'

[joyously]

This explanation should be in the FAQ or the revset page.
And perhaps a built-in alias.

[hotsphink]

I like it! I'd prefer (r & immutable()) | roots(r:: & immutable_heads()) so that it outputs nothing if r is in fact mutable.

[arxanas]

In general, it would be great to have a tool that walks through the evaluation of a revset to explain why a certain revision is or is not a member of each sub-term. I often needed to debug stuff when working on my perfect default log config, and it would have saved a lot of time if I knew exactly which function/operator was including/excluding the commit I wanted. (I think I often get confused by the exact behavior of .., for example.)

[bryceberger]

I have written such a tool. Currently https://github.com/bryceberger/jj/tree/revset-evaluator, permalink bryceberger@0c3f168. Has a few rough edges, especially since it doesn't actually know what is a revset, so it will try to evaluate 2 as a revset given something like ancestors(@, 2).

[blackeyeddan]

I ran into an immutable commit issue today while trying to rebase, but because of elided revisions I could not get the source change id I needed.

What I finally understood was all descendants must be tracked. A co-worker's bookmark was based on my first immutable commit. Since it wasn't my code, I had no reason to think I should track it. It turns out it must also be tracked!

I think if the wording 'all descendants must be tracked' was written somewhere in the documentation I may have understood much earlier.

[jennings]

That's a consequence of the default value of immutable_heads() being trunk() | tags() | untracked_remote_bookmarks(). The untracked_remote_bookmarks() is what causes it. If you change immutable_heads(), you can lift this restriction.

It probably makes sense to explain why the default value is what is, and that's where this explanation would go. Where do you think that should be? I think probably the documentation explaining what immutable_heads() is may be a good place for it. Would you be willing to add that documentation and send a PR?

That page is reference documentation, but when someone encounters this, they probably don't know what reference to look for. So, it probably makes sense for this sort of thing to be in a tutorial or explanation too, but we might not currently have an obvious place for that.