revlog: update the split + transaction test We add section, increase the amount of comments and simplify some of the constructs. We are about to build more on top this tests so lets do a small cleanup first.

transaction: allow to backup file that already have an offset This will be useful in the next changeset to deal with rolling back the split of inline revlog on transaction failure. This involve deeper change to the transaction logic as we need to make sure we restore the backup -before- the truncation step. Otherwise, the truncation would act on the wrong file and be overwritten by the backup restoration later.

transaction: move the restoration of backup file in a small closure We are about to use that logic in two different location, making is a small reusable closure prepares that.

transaction: raise on backup restoration error A few line above, similar errors in the truncation code result in raising the associated exception. We should do the same here. This means the transaction recover is more strict now, which might be a problem when running `hg recover` in a share different from the one where the transaction fails. However this has always been a problem and need to be be addressed independently.

transaction: add clarifying comment about why ignoring some error is fine It is less scary when explained.

transaction: properly clean up backup file outside of .hg/store/ Oops.

statprof: with Python 3.12, lineno is (more) often None test-profile.t failed with errors like: TypeError: %d format: a real number is required, not NoneType statprof.py already handled None values as -1 in some cases. Do the same in more cases.

py3: fix for Python 3.12 emitting SyntaxWarning on invalid escape sequences Mercurial became very noisy after https://github.com/python/cpython/commit/a60ddd31be7ff96a8189e7483bf1eb2071d2bddf , for example: $ python3.12 mercurial/store.py mercurial/store.py:406: SyntaxWarning: invalid escape sequence '\.' EXCLUDED = re.compile(b'.*undo\.[^/]+\.(nd?|i)$') This verbosity made some tests fail. The problems were mostly insufficiently escaped regexps, relying on the Python parser/scanner preserving invalid escape sequences.

cext: fix for PyLong refactoring in CPython 3.12 Compiling Mercurial with Python 3.12 a5 would fail with: mercurial/cext/dirs.c: In function '_addpath': mercurial/cext/dirs.c:19:44: error: 'PyLongObject' {aka 'struct _longobject'} has no member named 'ob_digit' 19 | #define PYLONG_VALUE(o) ((PyLongObject *)o)->ob_digit[0] | ^~ mercurial/cext/dirs.c:97:25: note: in expansion of macro 'PYLONG_VALUE' 97 | PYLONG_VALUE(val) += 1; | ^~~~~~~~~~~~ mercurial/cext/dirs.c:19:44: error: 'PyLongObject' {aka 'struct _longobject'} has no member named 'ob_digit' 19 | #define PYLONG_VALUE(o) ((PyLongObject *)o)->ob_digit[0] | ^~ mercurial/cext/dirs.c:108:17: note: in expansion of macro 'PYLONG_VALUE' 108 | PYLONG_VALUE(val) = 1; | ^~~~~~~~~~~~ mercurial/cext/dirs.c: In function '_delpath': mercurial/cext/dirs.c:19:44: error: 'PyLongObject' {aka 'struct _longobject'} has no member named 'ob_digit' 19 | #define PYLONG_VALUE(o) ((PyLongObject *)o)->ob_digit[0] | ^~ mercurial/cext/dirs.c:145:23: note: in expansion of macro 'PYLONG_VALUE' 145 | if (--PYLONG_VALUE(val) <= 0) { | ^~~~~~~~~~~~ This was caused by https://github.com/python/cpython/commit/c1b1f51cd1632f0b77dacd43092fb44ed5e053a9 .

histedit: fix diff colors The problem here is that indexing a bytestring gives you integers, not chars, so the comparison to b'+' ends up being wrong. We don't really have a way to test curses output, so no tests to verify the correctness of this behaviour.

dirstate: fix a potential traceback when in `copy` and `rename` Before this changes, calling `hg copy` or `hg rename` could trigger a traceback about using an invalidated dirstate. This wasn't caught by the test as it needed the blackbox extension to preload the dirstate first in a way "refresh" invalidates it. Changing the context creation patterns fixes it.

dirstate: fix the bug in [status] dealing with committed&ignored directories In particular, these directories can "infect" their sibling directories with ignored status due to using a shared memoization cell by accident. This fixes bug #6795.

tests: demonstrate a bug with committed&ignored dirs

rust: remove out-of-date comment We've migrated to a newer version of Rust, so it doesn't make sense anymore.

rust: upgrade `rayon` dependency This includes a potential soundness fix as well as some improvements to performance which should be helpful.

rust: update zstd dependency Let's try to be the most up-to-date for this cycle. Fedora already has this version packaged, it's an added bonus.

tests: simplify a bit

dirstate-v2: fix an incorrect handling of readdir errors Make sure not to cache the results of a failed readdir call.

tests: demonstrate a bug in dirstate-v2 handling of errors

tests: add a rewriting step to detect EACCES errors

undo-files: cleanup legacy files when applicable The "journal" code is much more compact in 6.4, and so is the "undo" files as a result. However the previous version were much noisier, so let us cleanup undo files from older version too.

undo-files: clean existing files up before writing new one the in the initial design of journal/undo interaction, ages ago, new file always overwrote previous files. This is no longer the case for a long while, so it is time to properly clean things up before writing new ones. Otherwise, inconsistent "undo" state might exist on disk, leading `hg rollback` to misbehave (more that intended).

undo-files: make the undo-prefix configurable in `cleanup_undo_files` The transaction is configuration undo prefix, so we "need" it too.

undo-files: no longer pass the `repo` to `cleanup_undo_files` As foretold in the previous changesets, we no longer need a full repository object here.

undo-files: relies on a explicit list of possible undo files Instead of infering the list of undo files from the `_journalfiles` method on `localrepository`, we explicitly have the list of file in a constant next to the cleanup code. In practice this does not change much as `_journalfiles` is already returning the same "static" list and no internal or extensions extensions seems to actually wrap that. In addition, that list is not "too short" for cleanup, in case we need to cleanup undo files from older version of Mercurial that used to use more of them. this will be dealt with in a later changesets. This change is a step toward our goal to use the `cleanup_undo_files` within the transaction. The transaction has no reference to the `repo` object, so we need to move toward `cleanup_undo_files` not having one either.

undo-files: move the undo cleanup code in the transaction module Now that undo creation is gathered in the transaction module, let us move the code cleaning them up there too. This will be useful to better clean previous undo files up before creating new ones.

undo-files: drop the old undo rename logic It is no longer necessary I am not changing the transaction.__init__ signature since we are on stable right now.

undo-files: have the transaction directly tracks and manages journal rename This is much simpler this way.

undo-files: add a undoname closure to the _write_undo method We will also needs it when the transaction will take care of the other journal files, which is soon™.

undo-files: cleanup backup when cleaning undos Previously, the backups were left behind, by operation cleaning the undo's like strip, narrow and stream clone. The remaining elevant in the room is the transaction itself, who does not properly cleanup undo backup before copying the new ones.

undo-files: factor the vfs map in a repository property We define it in multiple locations and inconsistencies are appearing. So we now have a single definition point.

undo-files: add a utility function to read the backup-files definition We will need it in multiple places. so lets factor the logic around.

undo-files: use the cleanup function in streamclone Lets use the same code, so that we can fix things only once.

undo-files: also remove the undo.backupfiles The undo.backupfiles is dealt is directly managed by the transaction instead of going through the `localrepo.undofiles`. We start doing minimal management for it before using `cleanup_undo_files` on more situation. Proper handling of it is an intermediate goal of this series.

undo-files: use the cleanup function in narrow Lets use the same code, so that we can fix things only once.

undo-files: extract the cleanup code from strip in a function This logic is duplicated in multiple places and it missing some important parts. So lets start dealing with the duplication first.

run-tests: fix a crash when using the coverage options 35bf7f23b84c attempted to transition away from `distutils`, but the `packaging` code lacks `StrictVersion`. I have no idea when `packaging.version` became available, but I have it in python 3.6, so that should be good enough. For some reason, the import checker thinks this is a local import, and needs help to decide otherwise. Alternately we could ditch the version check entirely, because `coverage` is currently at 7.2.1, and the original check was added back in 2010.

rust: fix building on macOS (issue6801) The VFS change is copied over from Cargo, and likely to apply to other platforms as well. The dirstate change is essentially a replay of 440972d2175d, which was reverted in e98fd81bb151, part of !383, to silence some clippy warnings.

tests: fix timeout adjustement in delaypush.py Doing integer arithmetic with string is bound to fail.

relnotes: add 6.4 and empty next

Added signature for changeset 05de4896508e

Added tag 6.4rc0 for changeset 05de4896508e

branching: merge default into stable

transaction: drive the aberratant branch special case away shoo shoo shoo shoo. Happy to remove this awful special case (that I introduced myself last week…)

transaction: remove the `branch` backup for transaction We can now back it up at the end of the transaction as we do for the rest of the dirstate.

dirstate: deprecate calling `setbranch` without a transaction parameter The new way is now enforced.

branch: pass current transaction when writing branch for transaction backup This will requires more change soon (as we can simplify this backup). This will be done in later changesets.

branch: pass current transaction when writing branch in shelve

branch: pass current transaction when writing branch in import

branch: pass current transaction when writing branch in backout command

branch: pass current transaction when writing branch in branch command

branch: pass current transaction when writing branch in merge

branch: pass current transaction when writing branch in rebase

branch: pass current transaction when writing branch in keyword

branch: pass current transaction when writing branch in histedit

dirstate: write the `branch` as part of the transaction if any Bypassing the transaction means we could get out of sync with the dirstatemap content. The branch is stil written right away if no transaction is around, but at least it no longer bypass the transaction. Actual caller of this still need to be updated.