rust-matchers: use the `regex` crate Instead of falling back to Python when a code path with "ignore" functionality is reached and `Re2` is not installed, the default compilation (i.e. without the `with-re2` feature) will use the `regex` crate for all regular expressions business. As with the introduction of `Re2` in a previous series, this yields a big performance boost compared to the Python + C code in `status`, `diff`, `commit`, `update`, and maybe others. For now `Re2` looks to be faster at compiling the DFA (1.5ms vs 5ms for Netbeans' `.hgignore`) and a bit faster in actual use: (123ms vs 137ms for the parallel traversal of Netbeans' clean repo). I am in talks with the author of `regex` to see whether that performance difference is a bug, a "won't fix", or a tuning issue. The `regex` crate is already one of our dependencies and using this code does not require any additional work from the end-user than to use the Rust extensions. Differential Revision: https://phab.mercurial-scm.org/D8323

templater: add subsetparents(rev, revset) function Naming suggestions are welcome. And this could be flagged as an (ADVANCED) function since the primary use case is to draw a graph. This provides all data needed for drawing revisions graph filtered by revset, and allows us to implement a GUI graph viewer in some languages better than Python. A frontend grapher will be quite similar to our graphmod since subsetparents() just returns parent-child relations in the filtered sub graph. Frontend example: https://hg.sr.ht/~yuja/hgv/browse/default/core/hgchangesetgrapher.cpp However, the resulting graph will be simpler than the one "hg log -G" would generate because redundant edges are eliminated. This should be the same graph rendering strategy as TortoiseHg. This function could be implemented as a revset predicate, but that would mean the scanning state couldn't be cached and thus slow. Test cases are split to new file since test-template-functions.t is quite big and we'll need a new branchy repository anyway.

templater: remember cache key of evaluated revset This provides a hint for caching further computation result of the given revset. See the next patch for example.

templater: fix cbor() filter to accept smartset So the wrapper type can return a bare smartset.

templater: introduce wrapper for smartset (API) I want to add a template function which takes a revset as an argument: {somefunc(..., revset(...))} ^^^^^^^^^^^ evaluates to a revslist This wrapper will provide a method to get an underlying smartset. It should also be good for performance since count(revset(...)) will no longer have to fully consume the smartset for example, but that isn't the point of this change.

setup: build C extensions with -Werror=declaration-after-statement MSVC 2008 still needs declarations at the top of the scope. I added it to the 3rd party code too in case somebody vendors a new version with a problem- they'll get an early warning. Clang seems to ignore this (at least on 10.14 with Xcode 10), and gcc 7.4 will error out as desired on Ubuntu 18.04. Thanks to Yuya for remembering the name of the option. Differential Revision: https://phab.mercurial-scm.org/D8318

merge with stable

osutil: move declaration to top of the scope Otherwise the build would fail with -Werror=declaration-after-statement.

phabricator: remove *-argument from _getdrevs() It can't take more than one specs arguments per len(*specs).

revset: leverage internal _rev() function to implement rev() Now 'rev(n)' is identical to 'present(_rev(n))'.

revset: fix crash by repo.revs('%d', tip + 1) IndexError shouldn't be raised from a revset predicate. The error message is copied from scmutil.revsymbol().

revset: allow repo.revs('%d', wdirrev) Otherwise we can't write repo.revs('null:%d', subset.max()) to build a smartset covering the range {null .. tip} + {wdir} if subset includes wdir.

ui: use "procutil.shellsplit" to parse command A commandline containing a space ('"C:\\Program Files\\bar.exe" "..."') must not simply split at whitespace, instead quoting has to be taken into account. Use "shlex.split()" to parse it instead. This can improve the error message if we fail to launch a user configured editor which does not exist. Consider [ui] editor = "C:\Program Files\editor\editor.exe" where the path does not exist. "hg histedit" currently aborts with > Abort: edit failed: Program exited with status 1 here "Program" is not part of the message but the name of the program that failed (i.e. `basename("C:\\Program ")`). With this change the message instead reads > Abort: edit failed: C:\Program Files\editor\editor.exe exited with > status 1 which is also not ideal since infact "cmd.exe" exited with code 1, not the editor. But the real error message ("File not found") gets swallowed by `procutil` and including the correct path improves the error message nevertheless.

phabricator: allow multiple DREVSPEC args to phabread|phabimport|phabupdate Per Augie's request. Like regular revsets, the result is the union of all given specs. Unlike regular revsets, these don't resolve in parent -> child order, and should be specified as such on the command line. This change invalidated a previous test using an empty `hg phabread`, so it has been switched to `hg debugcallconduit` to preserve that coverage. Differential Revision: https://phab.mercurial-scm.org/D8233

phabricator: add a helper function to convert DREVSPECs to a DREV dict list Prep work for allowing multiple DREVSPECs to various commands, and properly validating the input. Differential Revision: https://phab.mercurial-scm.org/D8232

merge with stable

tests: avoid logging a commit with a Unicode character in test-phabricator.t The previous output was generated on Windows, and should have been wrapped in `HGENCODING=utf-8` like it is earlier in the test. It's simpler to just avoid it. I only noticed the output change when I got around to running it on a Mac. Differential Revision: https://phab.mercurial-scm.org/D8303

fix: mark -r as advanced See the previous patch for reasoning. I planned to even mark it deprecated, but someone (timeless?) on the #mercurial IRC channel said they sometimes wanted to use `-r` with its existing semantics. Differential Revision: https://phab.mercurial-scm.org/D8288

fix: add a -s option to format a revision and its descendants `hg fix -r abc123` will format that commit but not its descendants. That seems expected given the option name (`-r`), but it's very rarely what the user wants to do. The problem is that any descendants of that commit will not be formatted, leaving them as orphans that are hard to evolve. They are hard to evolve because the new parent will have formatting changes that the orphan doesn't have. I talked to Danny Hooper (who wrote most of the fix extension) about the problem and we agreed that deprecating `-r` in favor of a new `-s` argument (mimicing rebase's `-s`) would be a good way of reducing the risk that users end up with these hard-to-evolve orphans. So that's what this patch implements. Differential Revision: https://phab.mercurial-scm.org/D8287

fix: move handling of --all into getrevstofix() for consistency Differential Revision: https://phab.mercurial-scm.org/D8286

rust-status: add trace-level logging for Rust status fallback for debugging The added `log` crate is already a sub-dependency. Differential Revision: https://phab.mercurial-scm.org/D8300

hg: make _local() behave consistently on Python 3.8 (issue6287) Python 3.8 makes os.path.isfile quietly eat "path invalid" errors and return False instead of allowing the exception to propagate. Given that this is a change from 2018 (sigh) and it's mentioned in the release notes (double sigh) we're definitely too late to complain to Python about the behavior change, so open-code part of os.path.isfile() in this method so we can catch invalid-path errors and handle them appropriately. I confirmed that posixpath and ntpath both delegate to genericpath, which uses os.stat() under the covers. Differential Revision: https://phab.mercurial-scm.org/D8302

remotefilelog: add fake heads() method that allows viewing a file in hgweb As best I can discern, this is not going to hurt anything, but it'll cause a couple of options to exist in the UI that are nonsensical. That seems fine, given the nature of remotefilelog. Differential Revision: https://phab.mercurial-scm.org/D8299

tests: add test for remotefilelog interactions with hgweb It's not uncommon for hg users to rely on hgweb as a simple GUI and history browser (I do this all the time on Mercurial), but we lack any tests to ensure things keep working. At present, this merely demonstrates the "view contents of a single file" endpoint is broken. I'll fix that in a subsequent change. Differential Revision: https://phab.mercurial-scm.org/D8298

phabricator: remove duplicated byteskwargs conversion Fixes things on Python 3. Differential Revision: https://phab.mercurial-scm.org/D8301

chistedit: support histedit.summary-template in curses histedit plan Differential Revision: https://phab.mercurial-scm.org/D8296

vfs: fix typo in comment (remove extra "l") Differential Revision: https://phab.mercurial-scm.org/D8297

tests: make test-doctest.t automatically find files to run tests on Differential Revision: https://phab.mercurial-scm.org/D8294

tests: make test-doctest.t module list match reality Differential Revision: https://phab.mercurial-scm.org/D8280

tests: remove doctest in narrowspec, it is broken I think every item here is considered incorrect (if we fix doctest to run it), so let's just delete it. Differential Revision: https://phab.mercurial-scm.org/D8279

rust-core: add missing `Debug` traits Turns out you need them when trying to use `hg-core` as a library. Who knew. Differential Revision: https://phab.mercurial-scm.org/D8278

fix: refactor getrevstofix() to define revisions first, then validate them This refactoring makes it easier to add a new way of specifying revisions (I'm about to add a `--source`, which adds the specified revisions and their descendants). Differential Revision: https://phab.mercurial-scm.org/D8285

fix: disallow `hg fix --all --working-dir` `--all` implies `--working-dir`, so it's probably a mistake if the user uses both. Differential Revision: https://phab.mercurial-scm.org/D8284

tests: simplify test-fix-topology.t slightly by using a `(case !)` Differential Revision: https://phab.mercurial-scm.org/D8283

tests: fix rebase test broken by earlier cleanup It turns out I broke one of the rebase tests in dd2833e4d660 (tests: use drawdag in test-rebase-collapse.t, 2018-03-18) and didn't notice until now. Differential Revision: https://phab.mercurial-scm.org/D8277

rebase: accept multiple --base arguments (BC) Same reasoning as for the previous patch. Rebase has worked well with `--base 'A + B'` since 51e7c83e05ee (rebase: calculate ancestors for --base separately (issue5420), 2016-11-28). Differential Revision: https://phab.mercurial-scm.org/D8293

rebase: accept multiple --source arguments (BC) I think it's a little surprising that `hg rebase -s A -s B` rebases only `B::` and ignores `A`. That's because the `-s` flag is not a repeated flag. This patch makes it a repeated flag. Differential Revision: https://phab.mercurial-scm.org/D8292

rebase: mention -r argument in synopsis I'm guessing that we simply forgot to mention it there. I was wondering if maybe `-r` was experimental as long as evolution is, but that doesn't seem to be the case (`-r` is not marked experimental). Differential Revision: https://phab.mercurial-scm.org/D8295

rebase: remove unused defaults argument values from _definedestmap() The caller always provides values for these arguments. Differential Revision: https://phab.mercurial-scm.org/D8291

phabricator: add a config knob to create obsolete markers when importing This too can get a tristate switch if desired. But if so, that needs to happen by having evolve add the option. Differential Revision: https://phab.mercurial-scm.org/D8138

phabricator: add a config knob to import in the secret phase For my use anyway, it's better to have a config knob that's always set than to try to remember a switch. But we can add a tristate switch if desired. Differential Revision: https://phab.mercurial-scm.org/D8137

phabricator: add a `phabimport` command I've had `alias.phabimport = $hg phabread --stack $1 | $hg import --bypass -` for a while now, and I suspect others do too. That's limited though, in that it can't use the information on Phabricator to restore it in the original location, so I'm making it a first class command. This doesn't do anything ambitious like that- this is mostly a simplification of `hg import` to get the equivalent of the alias mentioned above. The `--bypass` option is hardcoded to be enabled and the message about amending rejects dropped (rejects aren't created with `--bypass`), because editing patches on Phabricator seems like an unusual workflow. This will need other options, like `--obsolete` and `--secret`. I think these would be more useful as config settings, as I imagine the workflows are pretty fixed depending on roles. Reviewers who don't queue patches probably never want `--obsolete`, but may need `--secret`. Reviewers who do will want the former, but not the latter. I left `--stack` as an option, but that should probably be a config knob too (or at least default to on)- if the point of this is to avoid rejects, it doesn't make sense to skip dependencies in most cases. Evolve is going to need a fix to its wrapping of `cmdutil.tryimportone()`, as it currently assumes `opts` has an `obsolete` key. It's worked around for now. Differential Revision: https://phab.mercurial-scm.org/D8136

rust: update the README with more up-to-date and thorough information Differential Revision: https://phab.mercurial-scm.org/D8274

transactions: convert changes['phases'] to list of ranges Consecutive revisions are often in the same phase, especially public revisions. This means that a dictionary keyed by the revision for the phase transitions is highly redundant. Build a list of (range, (old, new)) entries instead and aggressively merge ranges with the same transition. For the test case in issue5691, this reduces memory use by ~20MB. Differential Revision: https://phab.mercurial-scm.org/D8125

test-install: don't print Rust re2 bindings information if Rust is not in use Differential Revision: https://phab.mercurial-scm.org/D8273

tests: drop an extraneous (glob) from test-debugbackupbundle.t Since this was not needed, it ends up causing the test to end with an error saying that the output changed, but with no diff and a message at the end saying "no result code from test". Differential Revision: https://phab.mercurial-scm.org/D8269

pull: add `--confirm` flag to confirm before writing changes This introduces a new flag to pull command `--confirm` and also a config option named `pull.confirm` which if used will prompt user describing changes which are pulled and asking whether to accept them or not. Differential Revision: https://phab.mercurial-scm.org/D8200

scmutil: add option to register summary callbacks as transaction validators We have a list of summary callbacks which are run after the transaction is closed to show what has changed and what not. This patch makes it possible to register those callbacks as transaction validators so that we can show summary before committing the transaction and prompt user to accept the changes. The goal of this is to implement `pull --confirm`. Differential Revision: https://phab.mercurial-scm.org/D8199

transaction: add functionality to have multiple validators This will help us in adding more validators which can aggregate data from transaction and prompt user whether to commit the transaction or not. The current target is to use this to implement `pull --confirm`. Differential Revision: https://phab.mercurial-scm.org/D8198

hgit: make sure repository is local before checking for store type httppeer (and maybe others too) does not have a store attribute. This was causing `hg pull` being broken on a hg repository when the extension is enabled. localpeer.local() does returns a non-None value but I am not sure if it matters. Differential Revision: https://phab.mercurial-scm.org/D8217

hg-core: add function timing information This change makes use of the newly added logging infrastructure to trace the execution time of some important calls. This approach is very much complementary to using a profiler and will not guard against out-of-order execution or other kinds of compiler optimizations. That said, it is useful to get a rough high-level idea of where time is spent. Differential Revision: https://phab.mercurial-scm.org/D8253

rust: add logging utils This change adds the `log` crate, the community-approved logging facade backed by Rust core developers as well as the logging-consumer crate `simple_logger` to build a foundation for logging from Rust. Using this setup allows us to choose how to log depending on the way `hg-core` is used: if it's within the context of `hg-cpython`, we might not want to use it the same way as with a direct cli for example. Differential Revision: https://phab.mercurial-scm.org/D8252

rust-status: traverse working directory in parallel Using `rayon` for this task ensures that we are using the same work-stealing threadpool for everything. This change introduces `crossbeam` as an explicit dependency, although it is already a dependency of `rayon`. It provides better structures for multi-threaded tasks than the stdlib. Differential Revision: https://phab.mercurial-scm.org/D8251

rust-status: wrap `stat_dmap_entries` to ease profiling Differential Revision: https://phab.mercurial-scm.org/D8250

rust-status: refactor handling of unknown files Differential Revision: https://phab.mercurial-scm.org/D8249

rust-status: move to recursive traversal to prepare for parallel traversal I have looked into traversing the working directory in parallel either by a recursive or an iterative algorithm. The recursive approach won quite decisively both in terms of performance and code readability. You can look at my experiment here: https://heptapod.octobus.net/Alphare/rayon-recursive-traversal The chance of a stack overflow happening because the directories get too nested seems slim. This change does not yet do anything in parallel. Differential Revision: https://phab.mercurial-scm.org/D8215

rust-pathauditor: use interior mutability for use in multi-threaded contexts The usual recommendation for using `RwLock` or `Mutex` is that if there are about as many write as there are reads, use `Mutex`, and if there are more reads than writes, use `RwLock`. If after the main bottleneck (i.e. parallel traversal) is removed this shows up on profiles, we should investigate using the `parking_lot` since we don't need a poisoning API, or maybe move to different types of caches entirely. Differential Revision: https://phab.mercurial-scm.org/D8213

rust-pathauditor: actually populate the `audited_dirs` cache I forgot this when rewriting this logic during the review process. Differential Revision: https://phab.mercurial-scm.org/D8212

rust-pathauditor: actually split Windows shortname aliases at `~` Right now, splitting with a max of 1 parts is useless. Differential Revision: https://phab.mercurial-scm.org/D8211

debuginstall: add entry about re2 Rust bindings when applicable Differential Revision: https://phab.mercurial-scm.org/D8226

rust-cpython: add `debug` module to expose debug information to Python This will be mostly used in `debuginstall`. Differential Revision: https://phab.mercurial-scm.org/D8225

rust-status: use bare hg status fastpath from Python This change also adds a test case for subrepos. Repeating the benchmark information from the `hg-core` commit: On the Netbeans repository: C: 840ms Rust+C: 556ms Mozilla Central with the one pattern that causes a fallback removed: C: 2.315s Rust+C: 1.700s Differential Revision: https://phab.mercurial-scm.org/D7931

rust-status: update rust-cpython bridge to account for the changes in core Differential Revision: https://phab.mercurial-scm.org/D7930

rust-status: add bare `hg status` support in hg-core A lot of performance remains to be gained, most notably by doing more things in parallel, but also by caching, not falling back to Python but switching to another regex engine, etc.. I have measured on multiple repositories that this change, when in combination with the next two patches, improve bare `hg status` performance, and has no observable impact when falling back (because it does so early). On the Netbeans repository: C: 840ms Rust+C: 556ms Mozilla Central with the one pattern that causes a fallback removed: C: 2.315s Rust+C: 1.700 s Differential Revision: https://phab.mercurial-scm.org/D7929

rust-status: add function for sequential traversal of the working directory This change also introduces helper structs to make things clearer. Differential Revision: https://phab.mercurial-scm.org/D7928

rust-status: add missing variants to `Dispatch` enum Differential Revision: https://phab.mercurial-scm.org/D8088

rust-status: rename `StatusResult` to `DirstateStatus` "Result" has a special meaning in the Rust world, this should be clearer. Differential Revision: https://phab.mercurial-scm.org/D8087

rust-status: refactor options into a `StatusOptions` struct Differential Revision: https://phab.mercurial-scm.org/D8086

rust-status: add util for listing a directory I debated moving it to utils, but it is not used anywhere else for now, and its skip behavior is pretty specific to status. Differential Revision: https://phab.mercurial-scm.org/D7927

rust-matchers: add `IgnoreMatcher` This is a big change but all of the pieces call each other, so it makes sense to have this all in one patch. Differential Revision: https://phab.mercurial-scm.org/D7925

rust-matchers: add `build_regex_match` function This function will be used to help build the upcoming `IncludeMatcher`. Differential Revision: https://phab.mercurial-scm.org/D7924

rust-matchers: add functions to get roots, dirs and parents from patterns These functions will be used to help build the upcoming `IncludeMatcher`. Differential Revision: https://phab.mercurial-scm.org/D7923

rust-matchers: add function to generate a regex matcher function This function will be used to help build the upcoming `IncludeMatcher`. While Re2 is still used and behind a feature flag, this function returns an error meant for fallback in the default case. Differential Revision: https://phab.mercurial-scm.org/D7922

run-tests: restrict Rust thread pool to 3 threads during tests Differential Revision: https://phab.mercurial-scm.org/D8270

nodemap: make sure the nodemap docket is updated after the changelog It is better to have a lagging nodemap than a nodemap pointing to node that does not exists yet. (strictly speaking, the order was already right, however we make it more explicit). Differential Revision: https://phab.mercurial-scm.org/D8188

nodemap: make sure hooks have access to an up-to-date version We make sure hooks can read persistent nodemap data and that they access something up-to-date with the pending transaction. Differential Revision: https://phab.mercurial-scm.org/D8187

nodemap: track the tip_node for validation Differential Revision: https://phab.mercurial-scm.org/D8184

nodemap: add a todo list for getting out of experimental This is all the requirement I can think off. More might be added as they emerge. The first ones are mostly simple technical matters that will be taken care of soon. The question about the "status" of the persistent nodemap and the revlogs that will use it requires more discussion and thinking. Differential Revision: https://phab.mercurial-scm.org/D8181

rust-nodemap: automatically use the rust index for persistent nodemap The persistent nodemap requires the rust index to be used to provides any gains. So we automatically enable it for revlog using the persistent nodemap. We keep it off for other revset because now that the rust revlog fully initialise the nodemap using it everywhere introduce a fairly significant regression (eg: hg diff moving from 0.8s to 2.3s on mozilla-try) Differential Revision: https://phab.mercurial-scm.org/D8164

nodemap: use data from the index in debugnodemap --dump-new It is better to run the actual code when generating a new nodemap cache from scratch. So we do. Differential Revision: https://phab.mercurial-scm.org/D8163

rust-nodemap: also clear Rust data in `clearcaches` Differential Revision: https://phab.mercurial-scm.org/D8161

rust-nodemap: add binding to `nodemap_update_data` Differential Revision: https://phab.mercurial-scm.org/D8160

rust-nodemap: add binding for `nodemap_data_incremental` Differential Revision: https://phab.mercurial-scm.org/D8159

rust-nodemap: add binding for `nodemap_data_all` Differential Revision: https://phab.mercurial-scm.org/D8158

rust-nodemap: use proper Index API instead of using the C API Differential Revision: https://phab.mercurial-scm.org/D8157

rust-nodemap: add utils for propagating errors This also updates the copyright notice Differential Revision: https://phab.mercurial-scm.org/D8156

rust-nodemap: add utils to create `Node`s from Python objects Differential Revision: https://phab.mercurial-scm.org/D8155

rust-index: add `append` method to cindex/Index This will be used by `MixedIndex` in a later patch. Differential Revision: https://phab.mercurial-scm.org/D8154

rust-index: moved constructor in separate impl block with the upcoming addition of the nodemap logic, it's going to become more complicated. Being in the separate impl block has the advantage to be subject to rustfmt, whereas code inside macro calls isn't. Differential Revision: https://phab.mercurial-scm.org/D8153

revlog: using two new functions in C capsule from Rust code We expose `index_length` and `index_node` in the C capsule, so that the Rust representation of the C index can implement the `RevlogIndex` trait. Because our `Node` is actually a one-field struct, we have to decorate it for direct FFI exchange with the C `char*` It would be a good thing to get a length from the C layer, but doing so right now would probably interfere with the upcoming changes that will happen there for the hash length. Differential Revision: https://phab.mercurial-scm.org/D8152

nodemap: refresh the persistent data on nodemap creation The logic to read the data and validate the docket are still in python, so we need to "help" whatever compiled code live in the index to refresh it. Otherwise clearing the cache could lead to an expensive full recomputation and disk update even when the persisted data are still valid. Differential Revision: https://phab.mercurial-scm.org/D8174

tests: check availability of pyflakes by trying to import pyflakes module Since e397c6d74652, we use the pyflakes module instead of the pyflakes executable. As was pointed out during the review, the hghave check can be rewritten to try to import the pyflakes module instead of spawning a new subprocess.

nodemap: deal with the "debugupdatecache" case using a "fake" transaction We are going to need more and more methods of the transaction. So lets change approach. The `hg debugupdatecache` case do not need a transaction, because has the repositories locked, but is not adding any "store" data to it. Differential Revision: https://phab.mercurial-scm.org/D8186

changelog: change the implementation of `_divertopener` During a transaction, new data to the changelog index are "diverted". The previous implementat ways pretty basic, we need something better to be able to use the changelog vfs fully during transaction. (eg: accessing the vfs options). Differential Revision: https://phab.mercurial-scm.org/D8185

nodemap: test that an outdated nodemap can catch up If the persistent nodemap does not contains all revision that the index contains, this is should be detected and dealt with. We add a test for this case. Differential Revision: https://phab.mercurial-scm.org/D8183

nodemap: document the docket attributes More documentation rarely hurts. Differential Revision: https://phab.mercurial-scm.org/D8182

git: key off `git` in .hg/requires rather than separate file Differential Revision: https://phab.mercurial-scm.org/D8265

git: correctly handle p1() on dirstate when underlying git repo is empty This shows up in my next change, which ends up making an empty git repo and then running hg. Differential Revision: https://phab.mercurial-scm.org/D8271

rust: clean remains of direct-ffi code Since b55bec1ea972, the cext entry poitn have been removed, so we drop the code for consistency.

heptapod-ci: use the new `--rust/--no-rust` flag to run the tests

run-tests: add option for running with and without Rust extensions This provide a simple and clear way to run the test with or without rust.

run-tests: rename "pure" variable to setup_opts There are more useful flag than just `--pure`. We clarify the variable name before adding more options.

setup-rust: add a --no-rust flag This new flag will make sure the rust extension will not be build. If neither `--rust` nor `--no-rust` is specified the `HGWITHRUSTEXT` is used.

cext: drop the WITH_RUST block These were used by the `direct-ffi` mode that just got dropped.

setup: use printf instead of print Yuya Nishihara pointed `printf` to me, so I will respect the cargo cult.

git: don't fail import when pygit2 is not install `test-duplicateoptions.py` was failing on py2 for be because I didn't have pygit2 installed. It failed because we depend on pygit2 at import time. This patch makes it so we successfully load the git extension even if pygit2 doesn't exist -- we just won't be able to use it in that case. Differential Revision: https://phab.mercurial-scm.org/D8268

hghave: add a check for pygit2 This will make it easy to use availability of pygit2 as in conditions such as `#if pygit2` and `(pygit2 !)`. It also makes it a little clearer why the test case skipped (when that happens). Differential Revision: https://phab.mercurial-scm.org/D8267

localrepo: add git extension to autoextensions list Differential Revision: https://phab.mercurial-scm.org/D8266

gitlog: implement __iter__ on changelog This allows `hg phase --force --draft -r .` to work, for example. Differential Revision: https://phab.mercurial-scm.org/D8264

gitlog: fix embarassing bug that prevented log from showing correct parents We had the correct parents in the database, but the changelog was always returning p1 for all parents. Oops. Differential Revision: https://phab.mercurial-scm.org/D8263

git: add readfast() method to manifest Mysteriously, on a different system a handful of things don't work without this, including log. This is especially odd to be because log works in the test. In any event, it's legal for readfast() to just return read(), so that's what we do. Differential Revision: https://phab.mercurial-scm.org/D8262

git: make {shortest()} return shortest *unique* prefix It used to return the prefix of the specified length as long as the full node was unique (i.e. always). Differential Revision: https://phab.mercurial-scm.org/D8256

git: skeleton of a new extension to _directly_ operate on git repos This is based in part of work I did years ago in hgit, but it's mostly new code since I'm using pygit2 instead of dulwich and the hg storage interfaces have improved. Some cleanup of old hgit code by Pulkit, which I greatly appreciate. test-git-interop.t does not cover a whole lot of cases, but it passes. It includes status, diff, making a new commit, and `hg annotate` working on the git repository. This is _not_ (yet) production quality code: this is an experiment. Known technical debt lurking in this implementation: * Writing bookmarks just totally ignores transactions. * The way progress is threaded down into the gitstore is awful. * Ideally we'd find a way to incrementally reindex DAGs. I'm not sure how to do that efficiently, so we might need a "known only fast-forwards" mode on the DAG indexer for use on `hg commit` and friends. * We don't even _try_ to do anything reasonable for `hg pull` or `hg push`. * Mercurial need an interface for the changelog type. Tests currently require git 2.24 as far as I'm aware: `git status` has some changed output that I didn't try and handle in a compatible way. This patch has produced some interesting cleanups, most recently on the manifest type. I expect continuing down this road will produce other meritorious cleanups throughout our code. Differential Revision: https://phab.mercurial-scm.org/D6734

merge with stable

tests: use native string type for parsed hghave log lines Before this change, on Python 2, the parsed messages were decoded to unicode, causing an implicit conversion from unicode to str later.

tests: avoid implicit bytes -> unicode -> bytes roundtrip on Python 2 Before the change, there were two implicit conversions: * The format string was converted to unicode because the substituted values were unicode. * When printing the message in log(), the string was converted from unicode to str.

cext: make HgRevlogIndex_GetParents private again The rust's direct-ffi code need to access this function. Now that it `direct-ffi` is no more. We can make this function `static` again. This change was suggested by `Yuya Nishihara`.

setup-rust: remove the legacy 'direct-ffi' variant This variant have been abandoned for a while. Keeping it around just get people confused.

hghave: add a `rust` keyword to detect the use of compiled rust code The content of some on disk cache can varies when using rust (because it is faster to do so in the rust variant). So we need to be able to detect this case for some test. Differential Revision: https://phab.mercurial-scm.org/D8162

nodemap: check that a simple lookup works fine I realised the code was not exercised much. Differential Revision: https://phab.mercurial-scm.org/D8180