directaccess: add some commands to the directaccess list Before this patch we had a limited list of commands in the directaccess list. This patch adds about 20 commands to that list: - all the read-only commands in core supporting a rev as an argument - 'outgoing': since people can use 'outgoing' to know what is going to be pushed, the output of hg outgoing should be consistent with to the output of hg push and must therefore disallow directaccess since hg push forbids it.

evolve: move test for evolve --rev ordering in a separate file evolve --rev reordering is a complicated enough topic to justify a separate test.

evolve: properly evolve stacked unstable with --rev Before this patch, _singlesuccessor was not returning a revision number for the case where the parent of the argument was not obsolete. This resulted in bug when testing membership with the set of revisions. This patch fixes it and adds a test.

directaccess: disable directaccess for push and serve Before this patch, push and serve were subject to directaccess. This patch makes them throw error when trying to access hidden hashes.

directaccess: change rule from opt-in to opt-out Before this patch we would opt-in commands for direct access and the default filter for new repository was 'visible'. With this patch, the default filter for new repos is 'visible-directaccess-warn'. It means that by default all the commands have directaccess with warnings.

inhibit: move transaction wrapping outside of repo setup Before this patch, transaction wrapping code was done in reposetup. It happened to cause stackoverflows in repos with a lot of subreps. This patch moves the wrapping to extsetup and avoids this problem.

tests: ignores other core output in capability testing This will avoid breaking the test anytime core changes.

evolve: make uncommit respect allowunsable Before this patch, the uncommit command was performing the same way regardless of the value of experimental.evolution. With this patch if the configuration does not allow unstability, uncommit won't create instability.

directaccess: use cached filteredrevs Before this patch we were calling directly repoview.computehidden(repo) to compute the revisions visible with direct access, without going through the caching mechanism for the filtered revisions. There was two issues with that: (1) Performance: We were not leverating the cached values of the 'visible' revs (2) Stability: If there were to be a cache inconsistency with the computation of 'visible' we would crash in the branchmap consistency check partial.validfor. Consider the scenario of rebase with bookmarks: - when we delete a bookmark on an obsolete changeset (like what rebase does when moving the bookmark after rebasing the changesets) - then this changes the value returned by repoview.computehidden(repo) as bookmarks are used as dynamic blockers in repoview.computehidden(repo) - as of now, we don't invalidate the cache in the case of bookmark change - if we have a cached value from before the bookmark change, repoview.filterrevs(repo, 'visible') considers the cached value correct and returns something different than repoview.computehidden(repo) - in turn, if we use repoview.computehidden(repo) in directaccess, the subset relationship is broken and the cache consistency assertion (parial.validfor) fails if branchmap.updatecache is called in this time window This patch leverages the caching infrastructure in place to speed up the computation of the filteredrevs for visible-directaccess-nowarn and visible-directaccess-warn. Incidentally it prevents the bug discussed in (2) from crashing when running a rebase with a bookmark. Note that there still needs to be a fix in core for the case discussed in (2). The test for this side of the fix (not core's fix for (2) is very hard to implement without introducing a lot of dependencies and does not belong here. It is much easier to have the test of the fix for the scenario (2) in core along with the fix.

inhibit: improve performance of transaction wrapping Before this patch, transaction wrapping was the most expensive part of inhibit computation wise. This patch changes the revset that we use in the transaction wrapping to make it ~50x faster to compute: revset #0: obsolete() - hidden() 0) wall 0.000214 comb 0.000000 user 0.000000 sys 0.000000 (best of 11209) vs revset #0: (not hidden()) and obsolete() 0) wall 0.010965 comb 0.010000 user 0.010000 sys 0.000000 (best of 237)

evolve: extract the code computing dependencies in a separate function The code to compute dependencies between unstable changeset can be reused to compute the next reveset. This patch extracts it in its own function to make it reusable.

directaccess: add mechanism to load directaccess after some other extensions directaccess needs to load after some extensions to avoid interfering with them. This patch adds a mechanism to specify what extension directaccess needs to load after.

evolve: add another test for evolve --rev This patch adds one test for three conditions not covered before: - evolve --rev on a stack with obsolete commits without successors - evolve --rev on two sets of stacks in parallel - evolve --rev on a set of stack partially solvable (because all of the commits of the stack are not specified with --rev)

evolve: add a more complex test for evolve --rev The previous tests of evolve --rev would have passed with an ordering of revs by increasing revision numbers. This patch adds a test that would fail if that was what we were doing and therefore tests the implementation better.