formatter: remove superfluous pass statements

exchange: remove superfluous pass statements

commandserver: remove superfluous pass statements

cmdutil: remove superfluous pass statements

byterange: remove superfluous pass statements

branchmap: remove superfluous pass statements

convert: remove superfluous pass statements

bugzilla: remove superfluous pass statements

merge with stable

copytrace: use ctx.mutable() instead of adhoc constant of non-public phases

exchange: fix test for remote support of binary phases If the remote do not support phases, the "get" call will return None. We change that default return to empty tuple to fix the membership testing. This was a bug in the initial series. Thanks to yuja for catching this.

exchange: perform stream clone with clone bundle with --uncompressed Previously, `hg clone --uncompressed` would always clone from the origin server, even if a streaming clone bundle were available. With this change, we invoke the clone bundle mechanism before the stream clone mechanism, giving clone bundles the opportunity to handle --uncompressed (which is mapped to pullop.streamclonepreferred). The clone bundle filtering code now filters out entries that aren't stream clones when a stream clone is requested. If a stream clone clone bundle entry is present, it will be used. Otherwise, the client will fall back to a server-based streaming clone. .. feature:: `hg clone --uncompressed` uses clone bundles when possible Differential Revision: https://phab.mercurial-scm.org/D833

tests: add tests for clone bundles with --uncompressed Currently, --uncompressed will always clone from the origin server, even if a stream clone bundle is present. Let's add tests demonstrating this behavior. Differential Revision: https://phab.mercurial-scm.org/D832

py3: work around bytes/unicode divergence in parsedate()

py3: replace bytes[n] with slicing in checkwinfilename()

py3: manually escape control character to be embedded in win filename error

py3: replace str(None) with literal in convcmd.py

py3: remove use of str() in hgwebdir '%d' can't be used here since port may be either integer or byte string.

config: use copy-on-write to improve copy performance Previously, chg's `verify` call could take 30+ms loading and checking new config files. With one socket redirection, that adds up to around 70ms, which is a lot for fast commands (ex. `bookmark --hidden`). When investigating closer, A lot of time was spent on actually spent on ui copying, which is mainly about `config.config` and `dict` copying. This patch makes that 20x faster by adopting copy-on-write. The copy-on-write is performed at config section level. Before: In [1]: %timeit ui.copy() 100 loops, best of 3: 2.32 ms per loop After: In [1]: %timeit ui.copy() 10000 loops, best of 3: 128 us per loop 2ms may look not that bad, but it adds up pretty quickly with multiple calls. A typical chg run may call it 4 times, which is about 10ms. Differential Revision: https://phab.mercurial-scm.org/D808

Added signature for changeset 2f427b57bf90

Added tag 4.3.3 for changeset 2f427b57bf90

rebase: move bookmarks with --keep (issue5682) This is a regression caused by 3b7cb3d17137. We have documented the behavior in rebase help: Rebase will destroy original commits unless you use "--keep". It will also move your bookmarks (even if you do). So let's restore the old behavior. It is done by changing `scmutil.cleanupnodes` to accept more information so a node could have different "movement destination" from "successors". It also helps simplifying the callsite as a side effect - the special bookmark movement logic in rebase is removed. Differential Revision: https://phab.mercurial-scm.org/D727

cleanupnodes: rename "mapping" to "replacements" The next patch will pass in overrides for bookmark moves, which is a mapping itself, so let's rename "mapping" to "replacements" to distinguish them better. Differential Revision: https://phab.mercurial-scm.org/D749

cleanupnodes: separate out bookmark destination calculation from actual update We will soon want to pass in overrides for bookmark movements and this will make that patch simpler. I also think this makes the code easier to follow regardless of the later patch. Differential Revision: https://phab.mercurial-scm.org/D748

ui: check for progress singleton when clearing progress bar (issue5684) A combination of wrapping `ui` and progress bars interrupted by exceptions can lead to the progress bar not being cleared when the exception error is printed. This results in corrupted-looking output like this: ``` updating [===============================> ] 1/2u nresolved conflicts (see hg resolve, then hg rebase --continue) ``` This is because in `ui._progclear`, we only check the local reference to the progress bar, not whether or not there is an instance of the singleton. When a progress bar is interrupted by an exception, the exception printing in `scmutil.callcatch` uses the original instance of the `ui` object, not the wrapped copy that has `_progbar` set. When consider whether or not to clear the progress bar, check for the existence of the singleton, rather than just whether or not we have a local reference to it. Differential Revision: https://phab.mercurial-scm.org/D743

py3: whitelist 15 more tests passing on Python 3 We have reached the count of 75 tests passing on Python 3. Differential Revision: https://phab.mercurial-scm.org/D858

py3: use pycompat.bytestr instead of str Differential Revision: https://phab.mercurial-scm.org/D855

py3: explicitly convert dict.keys() and dict.items() into a list Differential Revision: https://phab.mercurial-scm.org/D853

py3: use '%d' instead of '%s' for integers Differential Revision: https://phab.mercurial-scm.org/D856

py3: use pycompat.strkwargs() before passing a dict as keyword argument Differential Revision: https://phab.mercurial-scm.org/D854

py3: return False early while checking whether None is a key in lazymanifest In this patch we returns False early if we are trying to check whether None is a key in lazymanifest. The reason I added a diff is that on Python 3, it goes into the lazy manifest code an returns a TypeError. I checked with Durham that whether None can be a possible key in lazymanifest and he said "no". So it's safe to have this if statement. This fixes `hg merge` on Python 3. Differential Revision: https://phab.mercurial-scm.org/D852

dirstate: use keyword arguments to clarify status()'s callers The arguments are especially non-obvious because the order is different from dirstate.walk(). Differential Revision: https://phab.mercurial-scm.org/D847

dirstate: use keyword arguments to clarify walk()'s callers The arguments are especially non-obvious because the order is different from dirstate.status(). Differential Revision: https://phab.mercurial-scm.org/D846

perf: remove fallbacks to ancient versions of dirstate.walk() If the call to dirstate.walk() failed, we would try to fall back to older versions. These were removed in d3d1d39da2fa (walk: remove cmdutil.walk, 2008-05-12) and f8299c84b5b6 (dirstate: fold statwalk and walk, 2008-06-26). We don't care about testing performance of versions that old versions at this point, so let's clean up. Differential Revision: https://phab.mercurial-scm.org/D845

releasenotes: update docstrings with information on additional flags This patch adds documentation related to the two new flags --check and --list for releasenotes extension. Differential Revision: https://phab.mercurial-scm.org/D544

releasenotes: raise error on simultaneous usage of flags The releasenotes command is supposed to raise an error when --list and --rev/--check flags are used together. This patch adds the above functionality. Differential Revision: https://phab.mercurial-scm.org/D831

dirstate: move parents source of truth to dirstatemap As part of moving dirstate storage to its own class, let's move the source of truth for the dirstate parents to dirstatemap. This requires that dirstate._pl no longer be a cache, and that all sets go through dirstatemap.setparents. Differential Revision: https://phab.mercurial-scm.org/D759

dirstate: move parent reading to the dirstatemap class As part of moving dirstate storage logic to a separate class, let's move the function that reads the parents from the file. This will allow extensions to write dirstate's that store the parents in other ways. Differential Revision: https://phab.mercurial-scm.org/D758

dirstate: move opendirstatefile to dirstatemap As part of moving the dirstate storage logic to another class, let's move opendirstatefile to dirstatemap. This will allow extensions to replace the pending abstraction. Future patches will move the consumers of _opendirstatefile into dirstatemap as well. Differential Revision: https://phab.mercurial-scm.org/D757

dirstate: move _copymap to dirstatemap As part of moving all dirstate storage to a new class, let's move the copymap onto that class. In a future patch this will let us move the read/write functions to the dirstatemap class, and for extensions this lets us replace the copy storage with alternative storage. Differential Revision: https://phab.mercurial-scm.org/D756

dirstate: move _dirs to dirstatemap As part of moving the dirstate storage logic to a new class, lets move the _dirs computation onto the class so extensions can replace it with a persisted index of directories. Differential Revision: https://phab.mercurial-scm.org/D755

dirstate: move filefoldmap to dirstatemap As part of moving the dirstate storage logic to a separate class, lets move the filfoldmap computation to that class. This will allow extensions to replace the dirstate storage with something that persists the filefoldmap. Differential Revision: https://phab.mercurial-scm.org/D754

dirstate: move nonnormalentries to dirstatemap As part of moving dirstate storage to its own class, let's move the nonnormalentries logic onto the dirstatemap class. This will let extensions replace the nonnormalentries logic with a persisted cache. Differential Revision: https://phab.mercurial-scm.org/D753

dirstate: create new dirstatemap class This is part of a larger refactor to move the dirstate storage logic to a separate class, so it's easier to rewrite the dirstate storage layer without having to rewrite all the algorithms as well. Step one it to create the class, and replace dirstate._map with it. The abstraction bleeds through in a few places where the main dirstate class has to access self._map._map, but those will be cleaned up in future patches. Differential Revision: https://phab.mercurial-scm.org/D752

style: always use `x is not None` instead of `not x is None` Differential Revision: https://phab.mercurial-scm.org/D842

templatekw: add new-style template expansion to {manifest} The goal is to allow us to easily access to nested data. The dot operator will be introduced later so we can write '{p1.files}' instead of '{revset("p1()") % "{files}"}' for example. In the example above, 'p1' needs to carry a mapping dict along with its string representation. If it were a list or a dict, it could be wrapped semi-transparently with the _hybrid class, but for non-list/dict types, it would be difficult to proxy all necessary functions to underlying value type because several core operations may conflict with the ones of the underlying value: - hash(value) should be different from hash(wrapped(value)), which means dict[wrapped(value)] would be invalid - 'value == wrapped(value)' would be false, breaks 'ifcontains' - len(wrapped(value)) may be either len(value) or len(iter(wrapped(value))) So the wrapper has no proxy functions and its scope designed to be minimal. It's unwrapped at eval*() functions so we don't have to care for a wrapped object unless it's really needed: # most template functions just call evalfuncarg() unwrapped_value = evalfuncarg(context, mapping, args[n]) # if wrapped value is needed, use evalrawexp() maybe_wrapped_value = evalrawexp(context, mapping, args[n]) Another idea was to wrap every template variable with a tagging class, but which seemed uneasy without a static type checker. This patch updates {manifest} to a mappable as an example.

templater: adjust binding strength of '%' and '|' operators (BC) This makes 'foo|bar%baz' parsed as '(foo|bar)%baz', not 'foo|(bar%baz)'. Perhaps it was a mistake that '%' preceded '|'. Both '|' and '%' can be considered a kind of function application, and '|' is more like a '.' operator seen in OO languages. So IMHO '|' should have the same (or higher) binding as '%'. The BC breakage should be minimal since both '|' and '%' operators have strict requirements for their operands and 'foo|bar%baz' was invalid: - right-hand side of '|' must be a symbol - left-hand side of '%' must be a dict or list - right-hand side of '%' must be a string or symbol

templatekw: just pass underlying value (or key) to joinfmt() function Before, iter(hybrid) was proxied to hybrid.gen, which generated formatted strings. That's why we had to apply joinfmt() to the dicts generated by hybrid.itermaps(). Since this weird API was fixed at a0f2d83f8083, we can get rid of the makemap() calls from join().

scmutil: extract helper functions that returns human-readable change id We do "'%d:%s' % (ctx...)" at several places, so let's formalize it. A low- level function, formatrevnode(ui, rev, node), is extracted so we can pass a manifest rev/node pair. Note that hex() for manifest output can be replaced with hexfunc() because it is printed only when debugflag is set. i18n/de.po is updated so test-log.t passes with no error.

templater: extract helper to just evaluate template expression A named function can be easily grepped and is probably good for code readability.

templater: do not destructure operands in buildmap() This makes the next patch slightly simpler.

templater: use helper function to get name of non-iterable keyword

pull: remove inadequate use of operations records to update stepdone The 'stepdone' set is design to be a client side mechanism. If the client used some advanced capabilities to request necessary information (changeset, obsmarkers, phases, etc). It marks the steps as done to avoid having a less advanced mechanism issue a duplicated request. So, the "stepdone.add('phases')" should be the result of a client choice, because only the client can know it has requested all it needed to request. In 4a08cf1a2cfe this principle was broken because any phase-heads part sent by the server to the client would declare the phases retrieval complete. Now that there is an official phases related capability and code associated to it. We do not need the change in 4a08cf1a2cfe anymore and we can back it out. This brings back 'stepdone' management for 'phases' in line with the rest of the code (including other phases handing). Here is an example of potential misbehavior that 4a08cf1a2cfe introduced: Imagine a server that pre-computes bundles. The bundles contains a changegroup part and an (advisory) 'phase-heads' part. When a pull occurs, precomputed bundled are reused if available. As the phase part is advisory it can be sent to all clients. However they could be relevant changesets without phase information. Either because they are already common or because they had no precomputed bundle for them yet. If receiving any 'phase-heads' parts disable subsequent phases re-trivial parts, the client will not request phase data for all relevant changesets. For example common changesets will not turn public.

pull: use 'phase-heads' to retrieve phase information A new bundle2 capability 'phases' has been added. If 'heads' is part of the supported value for 'phases', the server supports reading and sending 'phase- heads' bundle2 part. Server is now able to process a 'phases' boolean parameter to 'getbundle'. If 'True', a 'phase-heads' bundle2 part will be included in the bundle with phase information relevant to the whole pulled set. If this method is available the phases listkey namespace will no longer be listed. Beside the more efficient encoding of the data, this new method will greatly improve the phase exchange efficiency for repositories with non-served changesets (obsolete, secret) since we'll no longer send data about the filtered heads. Add a new 'devel.legacy.exchange' config item to allow fallback to the old 'listkey in bundle2' method. Reminder: the pulled set is not just the changesets bundled by the pull. It also contains changeset selected by the "pull specification" on the client side (eg: everything for bare pull). One of the reason why the 'pulled set' is important is to make sure we can move -common- nodes to public.

bundle2: only grab a transaction when 'phase-heads' affect the repository The next patch will use the 'phase-heads' part to exchange phase data relevant to the pulled set. 'handlephases' currently acquires a transaction even in case of no-op pull, which would results in an empty transaction and messing with the existing journal. Pass the transaction fetcher to updatephases so it can fetch it if necessary.

phases: move the binary decoding function in the phases module We move the decoding function near the encoding one in a place where they can be reused in other place (current target, 'exchange.py').

phases: move binary encoding into a reusable function We want to use binary phases for pushing and pulling. We extract the encoding function out of the bundle2 module first.

phases: use a Struct object for binary encoding and decoding We will move the binary encoding and decoding code to 'phases.py' in order to make it easier to reuse. First, let's cleanup it a bit.

discovery: avoid dropping remote heads hidden locally An extra post processing was added to recognize remote heads that are hidden locally as "common" instead of "unknown". However, this processing was removing such hidden heads from the remote heads sets. It had no impact because we used to pull phase information from all remote heads. This series will replace the phase pulling operation to a more efficient process but requires the unmodified pulled set information.

test-patchbomb: use mocktime The test was using system time for displaying ETAs, which could be flaky if the sysload is high. This patch extracts mocktime.py from test-progress.t to make sure test-patchbomb.t is unaffected by system time. Differential Revision: https://phab.mercurial-scm.org/D844