rhg: use generic DestArr in hash_mangle This simplifies code a bit more, but comes with an extra memory copy in case [destlen == dest_vec.len()]. This is probably fine, but a follow-up change is removing that too.

rhg: in path_encode, make DestArr generic over its size

rhg: in path_encode add a DestArr type This is an implementation of Sink trait that writes into a fixed-size buffer on the stack, so identical to what was done before, but it makes the code of [hash_encode] easier to understand by dropping all these slice manipulations.

rhg: reduce verbosity in path_encode by using a trait for writing Hopefully this makes the code easier to read and understand and shorter overall. It also lets us later tweak the type we use as a [Sink], without having to change the encoding functions, including using two different types for size measurement and for the actual serialization.

refactor: simplify code in rust version of path_encode Moving the addition of '/' separator to the end of the loop makes the rest of the logic much simpler because the first iteration is no longer special.

dirstate: phase-divergent update to 4e95341c89aa Heptapod published the obsolete version of those.

dirstate: phase-divergent update to 65943224c184 Heptapod published the obsolete version of those.

dirstate: phase-divergent update to 3433723d1b9b Heptapod published the obsolete version of those.

dirstate: enforce change context for hacky_extension_update_file This was the last method not scoped yet

large-files: use a `changing_files` context when initializing the dirstate We are obviously mutating the dirstate, so lets scope this mutation.

dirstate: enforce context set_clean and set_possibly_dirty We don't want them called within a `changing_parents` context, but we still want them called within a context. So we update the decorator accordingly

keyword: wrap dirstate mutation in `changing_files` context This is the way.

keyword: wrap dirstate mutation in `changing_files` context This is the way.

dirstate: enforce `running_status` context for calling `status` Now that the context is working as intended and that the callers are updated. We can enforce it.

dirstate: have `running_status` warn when exiting with a dirty dirstate If running_status was started without the lock, all changes should have been explicitly written (with the lock) or invalidated before exiting the context.

dirstate: have `running_status` write the dirstate when holding the lock This is simple and harmless.

dirstate: check that dirstate is clean at the initial context opening More checking that we are not doing anything weird.

dirstate: start tracking that we are within a `running_status` context

dirstate: add documentation about the expectation of `running_status` context

contrib-perf: use `running_status` in `perf::status` This is the way.

large-files: also open the context in the subdirstate

large-files: use `running_status` in `mergeupdate`

large-files: use `running_status` in `scmutiladdremove` This is the way.

large-files: open the transaction sooner in `scmutiladdremove` We want it to encompass the status call.

large-files: use `running_status` in `overriderevert` This is the way

large-files: use `running_status` in `updatestandinsbymatch` This is the way.

large-files: wrap reposetup's status in a `running_status` context This is the way.

narrow: use `running_status` in `updateworkingcopy` This is the way.

status: use `running_status` in dirstate status This is the way.

status: pre-indent the dirstate status code This make the next changeset clearer.

dirstate: introduce a (noop) running_status context Let us start with a simplistic context so we can scope the appropriate code before adding more logic.

status: invalidate dirstate on LockError If we cannot take the lock, someone else is modifying the repository. Let us discard dirstate uncommitted data before exiting the status code. Having a clean dirstate after such operation seems safer. Strictly speaking, there is a small behavior change in the following situation: * process A call `status` outside of the `wlock` * process B grab the `wlock` * process A fails to acquires the lock to write status fixup * process B release the `wlock` *without touching the dirstate* * process A later grab the `wlock` * process A can write dirstate update from earlier `status` However this is a fairly hypothetical situation : * process A has to be raced * process B have to not update the dirstate * process A has to run another *unrelated* operation later. This seems rare enough to overlook. I am stating that the two operations in process A has to be unrelated. Otherwise, collecting status data outside of the lock to use them inside the lock is racy. Any other process could move things around (eg: the working copy) making the data collected during status irrelevantor even harmful. If such code exists, it should be fixed ASAP.