addset: use base implementation for __add__

addset: use base implementation for __sub__

addset: use base implementation for __and__

addset: promote to real smartset Better revset performance are also achieved with less overlay. There is no good reason for addset to not be a smartset. We can replace the `_orderedsetmixin` inheritance since `abstractsmartset` has efficient min and max too.

addset: add a __nonzero__ method This is required to be a full smartset (not sure what was happening before that...)

addset: offer a fastasc and fastdesc methods If the underlying object offers fast iterators, we use them to provide fast iterators too.

addset: split simple and ordered iteration We have two goals here. First, we would like to restore the former iteration order we had in 2.9. Second, we want this logic to be reusable for `fastasc` and `fastdesc` methods.

generatorset: promote to smartset This is not going to be efficient but we need all basic set classes to be smartsets for the other classes to work.

generatorset: implement __nonzero__ This is necessary to become a real smartset.

spanset: use base implementation for __add__

spanset: use base implementation for __sub__

spanset: use base implementation for __and__

spanset: use base implementation for filter

filteredset: use base implementation for filter

filteredset: use base implementation for __add__

filteredset: use base implementation for __sub__

filteredset: use base implementation for __and__

abstractsmartset: add default implementation for __sub__

abstractsmartset: add default implementation for __add__

abstractsmartset: add default implementation for __and__

abstractsmartset: add default implementation for filter

lazyset: rename the class to filteredset All smartsets try to be lazy. The purpose of this class is to apply a filter on another set. So we rename the class (and all its occurences) to `filteredset`.

lazyset: add order awareness to the class Just a bit of extra code makes the lazyset aware of order. This renders orderedlazyset useless. At some point, the `subset` will become responsible for this ordering logic. But we are not there yet because the various objects used as subsets are not good enough.

lazyset: remove min/max This is now handled by abstractsmartset.

baseset: remove min/max methods This is now handled by the base class.

abstractsmartset: add a default implementation for min and max This default implementation takes advantage of the fast iterator if available.

lazyset: drop now useless ascending/descending definition

lazyset: inherit the fastasc and fastdesc method from subset When the filtered subset has such methods, we can use them. It is implemented as properties to be able to quickly return None if no corresponding fastasc exists on the subset.

lazyset: split the iteration logic from the condition filtering logic So that the filter can be reused by `fastasc` or `fastdesc`.

spanset: do a single range check in __contains__ Now that `start <= end` is always true, we can simplify this function.

spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Instead of having the direction of iteration enforced through the ordering of `start` and `end` attributes of spanset, we encode the iteration direction in an explicit attribute and always store start < end. The logic for sort and reverse has to be updated. The __iter__ is now based on the newly introduced `fastasc` and `fastdesc` methods. This will allow other code simplifications in the future.

abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods See the in-line documentation for details. (This is the beginning of a massive overhaul of revset).

spanset: remove ascending/descending implementation We can rely on their implementation in abstractsmartset.

baseset: remove ascending/descending redefinition We can rely on the abstractsmartset implementation.

abstractsmartset: default implementation for `ascending` and `descending` These two methods are actually silly aliases for `sort()` and `sort(reverse=True)`. So we get that aliasing at the abstractsmartset level. We will slowly phase out all the custom implementations and eventually remove any mentions of it from the code.

revert: bring back usage of `subset & ps` in `parents` Changeset 95af98616aa7 switched the order of the operand of the "&" computation to work around an issue from repo-wide spanset. The need for a workaround has been alleviated by the introduction of `fullreposet`. So we restore it to normal. The benchmark shows no significant changes as expected. We also revert the bogus test change introduced by 95af98616aa7. The order is actually important.

color: update docstring for debug option 964dd1c491ca updated the format for the --color=debug option. This updates the documentation to match this new format.

color: document the possibility to colourise tabs in diffs This is a no-op change that simply suggests that tabs can be colourised, but defaults to no colour effects for tabs. This complements cset c343557a8442. Like the similar effects for phases from f8e2aebbb24c, we set the default effects to '' instead of None, so that this is a true noop change. Otherwise, the diff.tab effect would override (i.e. neutralise) the effect of the surrounding label.

contrib/synthrepo: walk a repo's directory structure during analysis Augments the analyze command to additionally walk the repo's current directory structure (or of any directory tree), counting how many files appear in which paths. This data is saved in the repo model to be used by synthesize, for creating an initial commit with many files. This change is aimed at developing, testing and measuring scaling improvements when importing/converting a large repository to mercurial.

contrib/synthrepo: generate initial repo contents using directory shape model Augments the synthesize command to use an additional parameter to the analyzed repo model: the number of files in each directory at a given snapshot. Before synthesizing history, an arbitrary number of files will be generated in a distribution matching the analyzed directory structure. Intended for developing, testing and measuring scaling improvements when importing/converting a large repository to Mercurial.

filemerge: switch the default name for internal tools from internal:x to :x

filemerge: introduce :x as short version of internal:x merge tool name "internal:" is so much typing - it is frequently specified on the command line and gives options that are longer than any other I have seen.

branches: include active, closed and current flags in template output

branches: merge white space to format string Diffs of test output should be harmless. A white space character is moved into "log.changeset" color region.

branches: port to generic templater

branches: format rev as integer that is necessary for generic templater

formatter: add general way to switch hex/short functions This seems a bit awkward, but it can avoid duplicates in annotate, tags, branches and bookmarks. I guess fm.hexfunc can eventually be removed (or redesigned) when it gets template backend.

locarepo: remove the `pull` method (API) All the logic of this function is in the `exchange.pull` function for some time. We just stop calling `localrepo.pull` in `command.pull` to have access to more information. Leaving `localrepo.pull` in place will let third-party extensions wrap it but it would never be called by `hg pull` making the wrapping useless. Therefore, the method is removed so that third-party code fail noisily and get properly upgraded.

transplant: use exchange.pull localrepo.pull is going away. See 4d52e6eb98ea for details.

convert-hg: use localrepo.pull localrepo.pull is going away. See 4d52e6eb98ea for details.

fetch: use exchange.pull localrepo.pull is going away. See 4d52e6eb98ea for details.

localrepo: use exchange.pull when cloning localrepo.pull is going away. See 4d52e6eb98ea for details.

subrepo: use exchange.pull localrepo.pull is going away, see 4d52e6eb98ea for details.

commands: directly use exchange.pull localrepo.pull is going away. See explanations in 4d52e6eb98ea.

exchange: have `pull` return the pulloperation object We mimic what was done for `push` for similar reason. We are about to drop `localrepo.pull` (for consistency with dropping `localrepo.push` and we better have an API as extensible as `push` is. Find explanations about localrepo.push removal in 4d52e6eb98ea.

revset: introduce an abstractsmartset class This class documents all methods required by a smartset. This makes it easier for people to respect the API and ensure we fail loudly when something does not. It will later also contain common default implementations for multiple methods, making it easier to have smartset classes with minimal work.