configitems: register the 'convert.git.skipsubmodules' config

configitems: register the 'convert.git.similarity' config

configitems: register the 'convert.git.saverev' config

configitems: register the 'convert.git.renamelimit' config

configitems: register the 'convert.git.remoteprefix' config

configitems: register the 'convert.git.findcopiesharder' config

configitems: register the 'convert.git.extrakeys' config

configitems: register the 'convert.git.committeractions' config

configitems: register the 'convert.cvsps.mergeto' config

configitems: register the 'convert.cvsps.mergefrom' config

configitems: register the 'convert.cvsps.fuzz' config

configitems: register the 'convert.cvsps.cache' config The convert extensions has code a bit all around, but it seems simpler to use a central declaration of options at the root first.

bundle2: move exception handling into part iterator As part of separating the part iteration logic from the part handling logic, let's move the exception handling to the part iterator class. Differential Revision: https://phab.mercurial-scm.org/D705

bundle2: move part counter to partiterator As part of moving the part iterator logic to a separate class, let's move the part counting logic and the output for it. Differential Revision: https://phab.mercurial-scm.org/D704

bundle2: move part iterator a separate class Currently, the part iterator logic is tightly coupled with the part handling logic, which means it's hard to replace the part handling logic without duplicating the part iterator bits. In a future diff we'll want to be able to replace all part handling, so let's begin refactoring the part iterator logic to it's own class. Differential Revision: https://phab.mercurial-scm.org/D703

changegroup: add source parameter to generatemanifests Extensions, like remotefilelog, will want to look at the source of a pull when determining what manifests to add to a changegroup. For instance, on push they will include everything, while on pull they won't. Differential Revision: https://phab.mercurial-scm.org/D686

changegroup: remove changegroup dependency from revlog.addgroup Previously revlog.addgroup would accept a changegroup and a linkmapper and use it to iterate of the deltas. As part of untangling the revlog-changegroup interdependency, let's move the changegroup delta iteration logic to it's own function and pass the simple iterator to the revlog instead. This will make it easier to introduce non-revlogs stores in the future, without reinventing any changegroup specific logic. Differential Revision: https://phab.mercurial-scm.org/D688

revlog: refactor chain variable Previously the addgroup loop would set chain to be the result of self._addrevision(node,...). Since _addrevision now always returns the passed in node, we can drop that behavior and just always set chain = node in the loop. This will be useful in a future patch where we refactor the cg.deltachunk logic to another function and therefore chain disappears entirely from this function. Differential Revision: https://phab.mercurial-scm.org/D699

scmutil: don't append .orig to backups in origbackuppath (BC) When ui.origbackuppath is set, .orig files are stored outside of the working copy, however they still have a .orig suffix appended to them. This can cause unexpected conflicts, particularly when tracked files or directories have .orig at the end. This change removes the .orig suffix from files stored in an out-of-tree origbackuppath. Test Plan: Update and run unit tests. Differential Revision: https://phab.mercurial-scm.org/D679

ssh: fix flakey ssh errors on BSD systems This is a trivial backport of c037fd655b47 performed by augie@google.com, but the change is still really Durham's not mine, so I [augie] am leaving him as the author.

repair: preserve phase also when not using generaldelta (issue5678) It seems like we used to pick the oldest possible version of the changegroup to use for bundles created by the repair module (used e.g. by "hg strip" and for temporary bundles by "hg rebase"). I tried to preserve that behavior when I created the changegroup.safeversion() method in 3b2ac2115464 (changegroup: introduce safeversion(), 2016-01-19). However, we have recently chagned our minds and decided that these commands are only used locally and downgrades are unlikely. That decicion allowed us to start adding obsmarker and phase information to these bundles. However, as the bug report shows, it means we get different behavior e.g. when generaldelta is not enabled (because when it was enabled, it forced us to use bundle2). The commit that actually caused the reported bug was 8e3021fd1a44 (strip: include phases in bundle (BC), 2017-06-15). So, since we now depend on having more information in the bundles, let's make sure we instead pick the newest possible changegroup version. Differential Revision: https://phab.mercurial-scm.org/D715

tests: add test for issue5678 In addition to a test case for the direct problem described in the bug report, this also adds a test case showing how obsmarkers can also get lost when not using generaldelta. Differential Revision: https://phab.mercurial-scm.org/D714

merge: move cwd-missing detection to helper functions This will exist in two places with defered writes, so we want to avoid duplication. Differential Revision: https://phab.mercurial-scm.org/D626

doctest: enable tests by default on Python 3 Still several tests fail mostly because of the string issues, sigh. I'll fix them one by one.

doctest: normalize b'', u'' and exception output on Python 3 The idea is described in the following page. https://dirkjan.ochtman.nl/writing/2014/07/06/single-source-python-23-doctests.html # no-check-commit

doctest: coerce dict.keys() to list Otherwise it would be printed as odict_keys([...]) on Python 3.

doctest: upgrade old-style "except" clause

doctest: use print_function and convert bytes to unicode where needed

doctest: do not embed non-ascii characters in docstring Since the outer docstring is parsed as a unicode on Python 3, we have to either double-escape or construct non-ascii string from ascii string.

doctest: pass encoding name as system string

doctest: replace str() with bytes()

doctest: replace chr() with pycompat.bytechr()

doctest: replace .iteritems() with .items()

doctest: bulk-replace string literals with b'' for Python 3 Our code transformer can't rewrite string literals in docstrings, and I don't want to make the transformer more complex.

debuginstall: do not pass exception object to formatter (issue5676)

debuginstall: use codecs.lookup() to detect invalid encoding encoding.fromlocal() never tries to decode an ascii string since 853574db5b12, and there's no universal non-ascii string which can be decoded as any valid character set.

extensions: fix wrapcommand/function of class instance 5361771f9714 changed _updatewrapper() to copy the __name__ attribute, but not all callable objects has __name__. Spotted by loading mq with extdiff.

changegroup: avoid creating empty changegroup part Previously this check happened in the changegroup code itself. Since its refactor, this logic needs to move out to callers that care about it, such as this one. Otherwise we get empty bundle devel-warnings in certain extensions. Differential Revision: https://phab.mercurial-scm.org/D690

tests: split test-revset.t in half This test has gotten so large that running it can exceed the normal timeout on systems under load (like if we're running all the tests in parallel). This patch splits the test cleanly in half. Differential Revision: https://phab.mercurial-scm.org/D694

merge: flush any deferred writes just before recordupdates() ``recordupdates`` calls into the dirstate which requires the files to be there, so this is the last possible moment we can flush anything. Differential Revision: https://phab.mercurial-scm.org/D673

merge: flush any deferred writes before, and after, running any workers Since we fork to create workers, any changes they queue up will be lost after the worker terminates, so the easiest solution is to have each worker flush the writes they accumulate--we are close to the end of the merge in any case. To prevent duplicated writes, we also have the master processs flush before forking. In an in-memory merge (M2), we'll instead disable the use of workers. Differential Revision: https://phab.mercurial-scm.org/D628

filemerge: flush if using deferred writes when running a merge tool Since merge tools might read from the filesystem, we need to write out our deferred writes here. No-ops if not using deferred writes. Differential Revision: https://phab.mercurial-scm.org/D627

merge: pass wctx to premerge, filemerge In the in-memory merge branch. we'll need to call a function (``flushall``) on the wctx inside of _xmerge. This prepares the way so it can be done without hacks like ``fcd.ctx()``. Differential Revision: https://phab.mercurial-scm.org/D449

cmdutil: fix amend when passing a date Following https://phab.mercurial-scm.org/D636, passing the same date that the changeset to amend would results in no new commits but the output changed from: $ hg amend -d '0 0' nothing changed [1] to: $ hg amend -d '0 0' Restore the old behavior by parsing the date passed as parameter so the condition "date == old.date()" correctly works in cases both dates are identical. Add a test for covering this regression. This bug was found thanks to Evolve test suite. Differential Revision: https://phab.mercurial-scm.org/D691

merge with stable

configitems: register the 'eol.only-consistent' config

configitems: register the 'eol.native' config

configitems: register the 'eol.fix-trailing-newline' config

configitems: register the 'patchbomb.publicurl' config

configitems: register the 'patchbomb.intro' config

configitems: register the 'patchbomb.from' config

configitems: register the 'patchbomb.flagtemplate' config

configitems: register the 'patchbomb.confirm' config

configitems: register the 'patchbomb.bundletype' config

blackbox: remove _bbvfs state `_bbvfs` is redundant because it could be calcualted from `_bbrepo`. Differential Revision: https://phab.mercurial-scm.org/D651

blackbox: do not cache file objects Having the blackbox file objects cached in `ui._bbfp` could in theory be troublesome if multiple processes (ex. chg servers) have file objects referring to a same file. (Although I spent some time and failed to build a convincing test case) This patch makes blackbox re-open the file every time to make the situation better. Ideally we also need proper locking. The caching logic traces back to the commit introducing blackbox (18242716a). That commit does not have details about why caching is necessary. Consider the fact that blackbox logs are not many, it seems fine to remove the fp cache to be more confident. Differential Revision: https://phab.mercurial-scm.org/D650

blackbox: inline _bbwrite There is no need to make it a separate method. This makes the next change easier to read. Differential Revision: https://phab.mercurial-scm.org/D649

blackbox: fix rotation with chg The added test will show: $ $PYTHON showsize.py .hg/blackbox* .hg/blackbox.log: < 500 .hg/blackbox.log.1: < 500 .hg/blackbox.log.2: < 500 .hg/blackbox.log.3: < 500 .hg/blackbox.log.4: < 500 .hg/blackbox.log.5: >= 500 with previous code. The issue is caused by blackbox caching file objects *by path*, and the rotation size check could run on a wrong file object (i.e. it should check "blackbox.log", but `filehandles["blackbox.log"]` contains a file object that has been renamed to "blackbox.log.5"). This patch removes the "filehandlers" global cache added by 45313f5a3a8c to solve the issue. I think the original patch was trying to make different ui objects use a same file object if their blackbox.log path is the same. In theory it could also be problematic in the rotation case. Anyway, that should become unnecessary after D650. Differential Revision: https://phab.mercurial-scm.org/D648

test-blackbox: make it compatible with chg Differential Revision: https://phab.mercurial-scm.org/D647

ssh: fix flakey ssh errors on BSD systems There's been a persistent issue with flakiness on BSD systems (like OSX) where the 'no suitable response from remote hg' message would sometimes not appear. This was caused by one of the earlier calls failing with a "IOError: Broken pipe". Catching those errors and printing the same message removes the flakiness. Differential Revision: https://phab.mercurial-scm.org/D687

context: add overlayworkingcontext and overlayworkingfilectx These two classes will be used extensively in the first in-memory merge milestone. Differential Revision: https://phab.mercurial-scm.org/D616

changegroup: rename getsubsetraw to makestream Now that nothing uses getsubsetraw except makestream, let's move the functionality into the makestream. This removes the last remaining excess changegroup creation function, getsubsetraw. Differential Revision: https://phab.mercurial-scm.org/D671

changegroup: remove external uses of getbundler Now that makestream and makechangegroup are the primary creation methods for changegroups, let's get rid of this rogue use of getbundler and getsubsetraw. Differential Revision: https://phab.mercurial-scm.org/D670

changegroup: replace getchangegroup with makechangegroup As part of reducing the number of changegroup creation APIs, let's replace getchangegroup with calls to makechangegroup. This is mostly a drop in replacement, but it does change the version specifier to be required, so it's more obvious which callers are creating old version 1 changegroups still. Differential Revision: https://phab.mercurial-scm.org/D669

changegroup: replace changegroup with makechangegroup As part of reducing the number of changegroup creation APIs, let's replace the changegroup function with makechangegroup. This pushes the responsibility of creating the outgoing set to the caller, but that seems like a simple and reasonable concept for the caller to be aware of. Differential Revision: https://phab.mercurial-scm.org/D668

changegroup: delete getlocalchangegroup As part of reducing the number of changegroup creation APIs, let's go ahead and delete this unused function. It appears to have been deprecated in the last release anyway. Differential Revision: https://phab.mercurial-scm.org/D667

changegroup: replace getlocalchangegroupraw with makestream As part of reducing the number of changegroup creation apis, let's replace calls to getlocalchangegroupraw with calls to makestream. Aside from one case of checking if there are no outgoing commits and returning None, this is pretty much a drop in replacement. Differential Revision: https://phab.mercurial-scm.org/D666

changegroup: replace changegroupsubset with makechangegroup As part of getting rid of all the permutations of changegroup creation, let's remove changegroupsubset and call makechangegroup instead. This moves the responsibility of creating the outgoing set to the caller, but that seems like a relatively reasonable unit of functionality for the caller to have to care about (i.e. what commits should be bundled). Differential Revision: https://phab.mercurial-scm.org/D665

changegroup: replace getsubset with makechangegroup The current changegroup APIs are a bit of a mess. Currently you can use getsubsetraw, getsubset, changegroupsubset, getlocalchangegroupraw, getchangegroup, and getlocalchangroup to produce changegroups. This patch is the beginning of a refactor to boil all of that away to just makechangegroup and makestream. The first step adds the new functions and replaces getsubset function with them. Differential Revision: https://phab.mercurial-scm.org/D664

rebase: remove unnecessary '.unfiltered()' calls Now we have a clear centric place to control whether `rbsrt.repo` is unfiltered or not, we can drop `unfiltered()` in other places. Differential Revision: https://phab.mercurial-scm.org/D645

rebase: remove complex unhiding code This is similar to Martin von Zweigbergk's previous patch [1]. Previous patches are adding more `.unfiltered()` to the rebase code. So I wonder: are we playing whack-a-mole regarding on `unfiltered()` in rebase? Thinking about it, I believe most of the rebase code *should* just use an unfiltered repo. The only exception is before we figuring out a `rebasestate`. This patch makes it so. See added comment in code for why that's more reasonable. This would make the code base cleaner (not mangling the `repo` object), faster (no need to invalidate caches), simpler (less LOC), less error-prone (no need to think about what to unhide, ex. should we unhide wdir p2? how about destinations?), and future proof (other code may change visibility in an unexpected way, ex. directaccess may make the destination only visible when it's in "--dest" revset tree). [1]: https://www.mercurial-scm.org/pipermail/mercurial-devel/2017-March/094277.html Differential Revision: https://phab.mercurial-scm.org/D644

rebase: use unfiltered repo when loading state Before this patch, `rebase --abort` may fail to do the cleanup: $ hg rebase --abort rebase aborted (no revision is removed, only broken state is cleared) The added test case makes sure `--abort` works in this case. Differential Revision: https://phab.mercurial-scm.org/D643

rebase: do not crash rebasing merge with a parent having hidden successor The added test will crash with previous code. Differential Revision: https://phab.mercurial-scm.org/D640

changegroup: fix to allow empty manifest parts The current chunk reading algorithm relied on counting the number of empty chunks and comparing it to the number of chunk lists it expected (1 list of files for cg1 and cg2, and 1 list of files + 1 list of trees for cg3). This implicitly assumed that both the changelog part and the manifestlog part were never empty (since them being empty would cause it to count it as one list being done, and screw up the count). In our treemanifest code, the manifest section could be empty, so we need to handle that case. This patches refactors that code to be more explicit about how it counts the expected parts. Differential Revision: https://phab.mercurial-scm.org/D646

mq: create non-lossy patches, also with custom global diff configuration Users with custom [diff] configuration most certainly didn't intend it to make mq lose changes. It could: * git is handled perfectly fine. * nobinary could make mq leave some files out from the patches. * noprefix could make mq itself (and probably also other tools) fail to apply patches without the usual a/b prefix. * ignorews, ignorewsamount, or ignoreblanklines could create patches with missing whitespace that could fail to apply correctly. Thus, when refreshing patches, use patch.difffeatureopts, optionally with git as before, but without the config options for whitespace and format changing that most likely will cause loss or problems. (patch.diffopts is just patch.difffeatureopts with all options enabled and can be replaced with that.)

mq: test coverage of how [diff] configuration influence can break mq patches

wrapcommand: use functools.partial Like the previous patch, this helps remove noises in traceback. Practically, this removes another 6 lines in `rebase -s . -d .` traceback in my setup: .... File "hg/mercurial/util.py", line 1118, in check return func(*args, **kwargs) -File "hg/mercurial/extensions.py", line 331, in closure - return func(*(args + a), **kw) File "hg/mercurial/util.py", line 1118, in check return func(*args, **kwargs) File "fb-hgext/hgext3rd/fbhistedit.py", line 283, in _rebase return orig(ui, repo, **opts) File "hg/mercurial/util.py", line 1118, in check return func(*args, **kwargs) -File "hg/mercurial/extensions.py", line 331, in closure - return func(*(args + a), **kw) File "hg/mercurial/util.py", line 1118, in check return func(*args, **kwargs) File "remotenames.py", line 633, in exrebasecmd ret = orig(ui, repo, **opts) File "hg/mercurial/util.py", line 1118, in check return func(*args, **kwargs) -File "hg/mercurial/extensions.py", line 331, in closure - return func(*(args + a), **kw) File "hg/mercurial/util.py", line 1118, in check return func(*args, **kwargs) File "fb-hgext/hgext3rd/fbamend/__init__.py", line 453, in wraprebase return orig(ui, repo, **opts) File "hg/mercurial/util.py", line 1118, in check return func(*args, **kwargs) .... Differential Revision: https://phab.mercurial-scm.org/D633

wrapfunction: use functools.partial if possible Every `extensions.bind` call inserts a frame in traceback: ... in closure return func(*(args + a), **kw) which makes traceback noisy. The Python stdlib has a `functools.partial` which is backed by C code and does not pollute traceback. However it does not support instancemethod and sets `args` attribute which could be problematic for alias handling. This patch makes `wrapfunction` use `functools.partial` if we are wrapping a function directly exported by a module (so it's impossible to be a class or instance method), and special handles `wrapfunction` results so alias handling code could handle `args` just fine. As an example, `hg rebase -s . -d . --traceback` got 6 lines removed in my setup: File "hg/mercurial/dispatch.py", line 898, in _dispatch cmdpats, cmdoptions) -File "hg/mercurial/extensions.py", line 333, in closure - return func(*(args + a), **kw) File "hg/hgext/journal.py", line 84, in runcommand return orig(lui, repo, cmd, fullargs, *args) -File "hg/mercurial/extensions.py", line 333, in closure - return func(*(args + a), **kw) File "fb-hgext/hgext3rd/fbamend/hiddenoverride.py", line 119, in runcommand result = orig(lui, repo, cmd, fullargs, *args) File "hg/mercurial/dispatch.py", line 660, in runcommand ret = _runcommand(ui, options, cmd, d) -File "hg/mercurial/extensions.py", line 333, in closure - return func(*(args + a), **kw) File "hg/hgext/pager.py", line 69, in pagecmd return orig(ui, options, cmd, cmdfunc) .... Differential Revision: https://phab.mercurial-scm.org/D632

cmdutil: remove redundant commitfunc parameter in amend (API) Since the redundant commit during the amend has been been removed, there is no need for commit callback function in amend now. Therefore, this commit removes the unused parameter "commmitfunc" which was being used for this purpose. Test Plan: Ensured that all the tests pass Differential Revision: https://phab.mercurial-scm.org/D635

cmdutil: remove the redundant commit during amend There was an extra commit made during the amend operation to track the changes to the working copy. However, this logic was written a long time back and newer API's make this extra commit redundant. Therefore, I am removing the extra commit. After this change, I noticed that - Execution time of the cmdutil.amend improved by over 40%. - Execution time of "hg commit --amend" improved by over 20%. Test Plan: I ensured that the all the hg tests passed after the change. I had to fix a few tests which were aware of the extra commit made during the amend. Differential Revision: https://phab.mercurial-scm.org/D636

checknlink: rename file object from 'fd' to 'fp' Make it clear that `fp` (`file` object) is different from `fd` (low-level file descriptor number). Differential Revision: https://phab.mercurial-scm.org/D642

cleanup: rename "matchfn" to "match" where obviously a matcher We usually call matchers either "match" or "m" and reserve "matchfn" for functions. Differential Revision: https://phab.mercurial-scm.org/D641

check-code: fix incorrect capitalization in camelcase regex This was found internally at Google as part of a monorepo-wide cleanup. Differential Revision: https://phab.mercurial-scm.org/D637

amend: use context manager for config override Differential Revision: https://phab.mercurial-scm.org/D639

amend: delete dead assignment to "newid" Differential Revision: https://phab.mercurial-scm.org/D638

checknlink: use a random temp file name for checking Previously, if `.hg/store/00manifest.d.hgtmp1` exists, hg will copy the entire `00manifest.d` every time when appending new manifest revisions. That could happen if Mercurial or the machine crashed when `.hgtmp1` was just created but not deleted yet. This patch changes the fixed name to a random generated name. To be consistent with D468, `~` suffix was used. Differential Revision: https://phab.mercurial-scm.org/D611

copytrace: move the default copytracing algorithm in a new function We are going to introduce a new fast heuristic based copytracing algorithm, so lets make mergecopies the function which decides which algorithm to go with and then calls the related function. While I was here, I add a line in test-copy-move-merge.t saying its a test related to the full copytracing algorithm. Differential Revision: https://phab.mercurial-scm.org/D622

copytrace: replace experimental.disablecopytrace config with copytrace (BC) This patch replaces experimental.disablecopytrace with experimental.copytrace. Since the words does not means the same, the default value is also changed. Now experimental.copytrace defaults to 'on'. The new value is not boolean value as we will be now having two different algorithms (current one and heuristics one to be imported from fbext) so we need this to be have more options than booleans. The old config option is not kept is completely replaced as that was under experimental and we don't gurantee BC to experimental things. .. bc:: The config option for copytrace `experimental.disablecopytrace` is now replaced with `experimental.copytrace` which defaults to `on`. If you need to turn off copytracing, add `[experimental] copytrace = off` to your config. Differential Revision: https://phab.mercurial-scm.org/D621

filemerge: use fctx.write() in the internal:dump tool, instead of copy This is slower but allows this tool to work with the "deferred writes" milestone of in-memory merge. The performance hit is not too noticiable since this only used for the :dump merge tool during a conflict. Differential Revision: https://phab.mercurial-scm.org/D617

largefiles: remove unused assignments from wrapfunction() The return values from wrapfunction() were never used here. Using the value is also a little tricky and wrappedfunction() should be preferred, so let's just delete the assignments. There's also a bunch of return values from wrapcommand() being assigned to a variable here, but at least that value can be (and is used after some of the assignments). Differential Revision: https://phab.mercurial-scm.org/D618

branches: correctly show inactive multiheaded branches Issue being fixed here: `hg branches` incorrectly renders inactive multiheaded branches as active if they have closed heads. Example: ``` $ hg log --template '{rev}:{node|short} "{desc}" ({branch}) [parents: {parents}]\n' 4:2e2fa7af8357 "merge" (default) [parents: 0:c94e548c8c7d 3:7be622ae5832 ] 3:7be622ae5832 "2" (somebranch) [parents: 1:81c1d9458987 ] 2:be82cf30409c "close" (somebranch) [parents: ] 1:81c1d9458987 "1" (somebranch) [parents: ] 0:c94e548c8c7d "initial" (default) [parents: ] $ hg branches default 4:2e2fa7af8357 somebranch 3:7be622ae5832 ``` Branch `somebranch` have two heads, the 1st one being closed (rev 2) and the other one being merged into default (rev 3). This branch should be shown as inactive one. This happens because we intersect branch heads with repo heads to check branch activity. In this case intersection in a set with one node (rev 2). This head is closed but the branch is marked as active nevertheless. Fix is to check branch activity by intersecting only open heads set. Fixed output: ``` $ hg branches default 4:2e2fa7af8357 somebranch 3:7be622ae5832 (inactive) ``` Relevant tests for multihead branches added to test-branches suite. Implentation note about adding `iteropen` method: At first I have tried to modify `iterbranches` is such a way that it would filter out closed heads itself. For example it could have `closed=False` parameter. But in this case we would have to filter closed tips as well. Reasoning in terms of `hg branches` we actually are not allowed to do this. Also, we need to do heads filtering only if tip is not closed itself. But if it is - we are ok to skip filtering, because branch is already known to be inactive. So we can't implement heads filtering in `iterbranches` in elegant way, because we will end up with something like `closed_heads=False` or even `closed_heads_is_tip_is_open`. Finally I decided to move this logic to the `branches` function, adding `iteropen` helper method. Differential Revision: https://phab.mercurial-scm.org/D583

parser: stabilize output of prettyformat() by using byte-safe repr() The format of leaf nodes is slightly changed so they look more similar to internal nodes.

py3: fix repr(util.url) to return system string This is required on Python 3.

py3: use bytes[n:n + 1] to get bytes in templater._parsetemplate()

py3: fix type of attribute name in smartset.py

py3: fix mixed bytes/unicode in revsetlang._aliassyminitletters

py3: fix type of regex literals in subrepo.py

py3: replace bytes[n] with bytes[n:n + 1] in patch.py where needed

py3: fix type of regex literals in patch.py

revset: optimize "draft() & ::x" pattern The `draft() & ::x` type query could be common for selecting one or more draft feature branches being worked on. Before this patch, `::x` may travel through the changelog DAG for a long distance until it gets a smaller revision number than `min(draft())`. It could be very slow on long changelog with distant (in terms of revision numbers) drafts. This patch adds a fast path for this situation, and will stop traveling the changelog DAG once `::x` hits a non-draft revision. The fast path also works for `secret()` and `not public()`. To measure the performance difference, I used drawdag to create a repo that emulates distant drafts: DRAFT4 | DRAFT3 # draft / PUBLIC9999 # public | PUBLIC9998 | . DRAFT2 . | . DRAFT1 # draft | / PUBLIC0001 # public And measured the performance using the repo: (BEFORE) $ hg perfrevset 'draft() & ::(DRAFT2+DRAFT4)' ! wall 0.017132 comb 0.010000 user 0.010000 sys 0.000000 (best of 156) $ hg perfrevset 'draft() & ::(all())' ! wall 0.024221 comb 0.030000 user 0.030000 sys 0.000000 (best of 113) (AFTER) $ hg perfrevset 'draft() & ::(DRAFT2+DRAFT4)' ! wall 0.000243 comb 0.000000 user 0.000000 sys 0.000000 (best of 9303) $ hg perfrevset 'draft() & ::(all())' ! wall 0.004319 comb 0.000000 user 0.000000 sys 0.000000 (best of 655) Differential Revision: https://phab.mercurial-scm.org/D441

phabricator: add a config to use curl for communication Not sure why, but I got `phabsend` hang on work network pretty frequently. The traceback indicates it hangs at `_sslobj.do_handshake()`: File "mercurial/sslutil.py", line 404, in wrapsocket sslsocket = sslcontext.wrap_socket(sock, server_hostname=serverhostname) File "/usr/lib/python2.7/ssl.py", line 363, in wrap_socket _context=self) File "/usr/lib/python2.7/ssl.py", line 611, in __init__ self.do_handshake() File "/usr/lib/python2.7/ssl.py", line 840, in do_handshake self._sslobj.do_handshake() I had tried adding `timeout` in various places but they seem not effective. It seems easier to just allow shelling out to `curl` with retry and timeout flags. This could also be helpful for people with an older Python installed without modern security (SNI). Differential Revision: https://phab.mercurial-scm.org/D605

phabricator: standardize colors Previously, the `--confirm` text could have colors but the main `phabsend` does not. This patch adjusts the main command so it also has colors. A default color table was added so the colors are visible by default. Differential Revision: https://phab.mercurial-scm.org/D515

wireproto: do not abort after successful lookup As far as I can tell, this interface originally used 'return' here, so the "fallthrough" to self._abort made sense. When it was switched to 'yield' this didn't make sense, but doesn't impact most uses because the 'plain' wrapper in peer.py's 'batchable' decorator only attempts to yield two items (args and value). When using iterbatch, however, it attempts to verify that the @batchable generators only emit 2 results, by expecting a StopIteration when attempting to access a third. Differential Revision: https://phab.mercurial-scm.org/D608

check-code: forbid "\S" in egrep regular expression BSD `egrep` does not like it. So let's forbid it. Differential Revision: https://phab.mercurial-scm.org/D610

check-code: forbid using bash in shebang Some platforms (ex. FreeBSD) do not have `bash` by default. Therefore it should not be used in test scripts. Differential Revision: https://phab.mercurial-scm.org/D609

amend: add tests for amending only some files from commit to be amended We do not have robust enough tests for scenarios where only some files in a changeset are amended. This presents an interesting scenario because the working copy could have modified versions of the remaining files in the pre-amend changeset. Therefore, I have added some tests to ensure that amend behaves as expected in these scenarios. Test Plan: Ensured that the test "test-commit-amend.t" passes. Differential Revision: https://phab.mercurial-scm.org/D596

test-editor-filename: fix portability of fake editor command - /bin/bash doesn't exist on FreeBSD - edit is executed by cmd.exe on Windows

amend: moving first assignment of newid closer to its use newid was needlessly further away from where its intended to be used leading to bad readability. This commit moves it to address the same. The end goal is to remove the redundant commit in the amend code path and this commit takes care of cleaning up some unrelated code before that change. Test Plan: ran the test suite Differential Revision: https://phab.mercurial-scm.org/D597

amend: rectify comment Comment was ambiguous as there can be two parents of a changeset in mercurial. This commit fixes the comment to clarify that the first parent is being considered. Test Plan: ran the test suite Differential Revision: https://phab.mercurial-scm.org/D595

amend: removing redundant if condition There is needless checking for the new commit hash not being equal to the old commit hash. This condition will always be true at this point in the code path and thus, can be removed safely. This commit removes the redundant condition. Test Plan: ran the test suite. Differential Revision: https://phab.mercurial-scm.org/D594

editor: file created for diff action should have .diff suffix This is a follow-up to https://phab.mercurial-scm.org/D464 (6e6452bc441d) that introduced the new file extension behavior. It erroneously changed `.diff` to `.diff.hg.txt`. Test Plan: Verified `make tests` passes, particularly `test-editor-filename.t`. Differential Revision: https://phab.mercurial-scm.org/D607

test-amend: match output using conditional test case name D466 (6cc8f848b4c3) allows output to be conditionally matched by test name. This patch changes test-amend.t to use that feature, instead of duplicating `hg amend` command or use `-q` to silence its output. Differential Revision: https://phab.mercurial-scm.org/D601

util: use set for reserved Windows filenames Previously, we were performing membership testing against a list. Change it to a set for a minor perf win. While we're at it, explode the assignment in place so less work is needed at module import time. Differential Revision: https://phab.mercurial-scm.org/D600

context: add arbitraryfilectx, which can represent files outside the workdir Move it from contrib/simplemerge so it can be re-used in the future. Differential Revision: https://phab.mercurial-scm.org/D604

simplemerge: remove unused `filtereddata` parameter Differential Revision: https://phab.mercurial-scm.org/D603

simplemerge: remove unused `repo` parameter This is now no longer used or needed thanks to the `decodeddata()` context function. Differential Revision: https://phab.mercurial-scm.org/D602

extensions: prohibit unicode defaults If the default value of an option is a unicode string (something than happen easily when using a 'from __future__ import unicode_literals'), any value passed on the command line will be ignored because the fancyopts module only checks for byte strings and not unicode strings. Changing fancyopts behavior is easy but would make assumptions on how the python3 port should be done, which is outside the scope of this patch. The chosen approach is to stop an extension from being loaded when a unicode default value is detected, with a hint for the developer.

revsetlang: remove unused functions Superseded by the _match() function.

revsetlang: match tree by helper function on optimize This should make optimize() more readable and less error-prone, but it doubles the parsing cost. (original) $ python -m timeit -n10000 -s 'from mercurial import revsetlang as L' \ 'L.optimize(L.analyze(L.parse("ancestors(x) and not ancestors(y)")))' 10000 loops, best of 3: 79.3 usec per loop (this patch) $ python -m timeit -n10000 -s 'from mercurial import revsetlang as L' \ 'L._treecache.clear(); \ L.optimize(L.analyze(L.parse("ancestors(x) and not ancestors(y)")))' 10000 loops, best of 3: 201 usec per loop

parser: add helper function to test if pattern matches parsed tree This function will be used as follows: match('ancestors(_) and not ancestors(_)', x) See the next patch for details.

revsetlang: build optimized tree by helper function This should make optimize() more readable, but it doubles the parsing cost. (original) $ python -m timeit -n10000 -s 'from mercurial import revsetlang as L' \ 'L.optimize(L.analyze(L.parse("::tip")))' 10000 loops, best of 3: 18.1 usec per loop (this patch) $ python -m timeit -n10000 -s 'from mercurial import revsetlang as L' \ 'L._treecache.clear(); L.optimize(L.analyze(L.parse("::tip")))' 10000 loops, best of 3: 48.4 usec per loop 30usec isn't dominant compared to the revset evaluation, but that is a cost. That's why a parsed tree is cached, which can benefit in hgweb or chg server.

parser: add helper function that constructs parsed tree from template This function will be used as follows: build('only(_, _)', x, y) See the next patch for details.

patch: take messages out of the function so that extensions can add entries Extensions will want to have interactive thing for more operations or particulary want to show more verbs. So this patch takes out the message thing from the function so that extensions can add verbs to this. The curses one is also not in any function so extensions can add more actions and verbs there. Differential Revision: https://phab.mercurial-scm.org/D567

run-tests: allow bisecting a different repo Add `--bisect-repo` flag which accepts a different repo to bisect. 3rd party extensions may reuse `run-tests.py` from core to run tests. Test failure could be caused by either a core hg change or the 3rd party extension code itself. Having a way to specify which repo to bisect is useful. Differential Revision: https://phab.mercurial-scm.org/D578

run-tests: extract prefix of bisect commands to a variable This does not change any logic. Differential Revision: https://phab.mercurial-scm.org/D577

run-tests: pass --with-hg to run-tests.py command used by bisect This makes `run-tests.py -l test-run-tests.t` 23 seconds faster on my laptop. Inside the test, `$ rt --known-good-rev=0 test-bisect.t` took 24.9 seconds before, and 1.2 seconds after. Differential Revision: https://phab.mercurial-scm.org/D576

import-checker: allow relative import a module being checked This would make the checker more friendly for 3rd-party code. For example, In remotefilelog/x.py, it may have: from . import shallowutils That could trigger "relative import of stdlib module" if "remotefilelog" was installed in the system. If the module being checked conflicts with the system module, it makes sense to not treat that module as system module. This patch makes it so. Differential Revision: https://phab.mercurial-scm.org/D552

merge: move some of the logic in batchget() to workingfilectx We will use this logic in two places with in-memory merge. Differential Revision: https://phab.mercurial-scm.org/D444

filemerge: add _restorebackup Differential Revision: https://phab.mercurial-scm.org/D404

filemerge: reduce creation of tempfiles until needed This restricts the creation of temporary files to just `_xmerge`, when we call an external tool. Differential Revision: https://phab.mercurial-scm.org/D403

filemerge: add `_workingpath` This reduces any reliance on `a`. Differential Revision: https://phab.mercurial-scm.org/D401

filemerge: move a util copy call to filectx.write This way a future in-memory-merge context can intercept them. Differential Revision: https://phab.mercurial-scm.org/D400

filemerge: eliminate most uses of tempfiles Emphasize that they're unused so we can more easily remove them later. Differential Revision: https://phab.mercurial-scm.org/D399

filemerge: extract _maketemp and _makebackup These functions will be modified by in-memory merge, so let's extract them first and add some comments. This also shortens `_filemerge` a bit. Differential Revision: https://phab.mercurial-scm.org/D388

encoding: check overflow while calculating size of JSON escape buffer The minimum input size to exploit is ~682MB (= INT_MAX / len('\\u0000') * 2) on 32bit system, which isn't easy to achieve using Python str in 2GB process address space, but probably doable.

editor: use an unambiguous path suffix for editor files Changes the API of `ui.edit()` to take an optional `action` argument, which is used when constructing the suffix of the temp file. Previously, it was possible to set the suffix by specifying a `suffix` to the optional `extra` dict that was passed to `ui.edit()`, but the goal is to drop support for `extra.suffix` and make `action` a required argument. To this end, `ui.edit()` now yields a `develwarn()` if `action` is not set or if `extra.suffix` is set. I updated all calls to `ui.edit()` I could find in `hg-crew` to specify the appropriate `action`. This means that when creating a commit, instead of the path to the editor file being something like: `/tmp/hg-editor-XXXXXX.txt` it is now something like: `/tmp/hg-editor-XXXXXX.commit.hg.txt` Some editors (such as Atom) make it possible to statically define a [TextMate] grammar for files with a particular suffix. For example, because Git reliably uses `.git/COMMIT_EDITMSG` and `.git/MERGE_MSG` as the paths for commit-type messages, it is trivial to define a grammar that is applied when files of either name are opened in Atom: https://github.com/atom/language-git/blob/v0.19.1/grammars/git%20commit%20message.cson#L4-L5 Because Hg historically used a generic `.txt` suffix, it was much harder to disambiguate whether a file was an arbitrary text file as opposed to one created for the specific purpose of authoring an Hg commit message. This also makes it easier to add special support for `histedit`, as it has its own suffix that is distinct from a commit: `/tmp/hg-histedit-XXXXXX.histedit.hg.txt` Test Plan: Added an integration test: `test-editor-filename.t`. Manually tested: ran `hg ci --amend` for this change and saw that it used `/tmp/hg-editor-ZZjcz0.commit.hg.txt` as the path instead of `/tmp/hg-editor-ZZjcz0.txt` as the path. Verified `make tests` passes. Differential Revision: https://phab.mercurial-scm.org/D464

revlog: move check for wdir from changelog to revlog Yuya said he preferred this (to keep them in one place, I think). Differential Revision: https://phab.mercurial-scm.org/D569

debugssl: allow a URL to be specified without a local repository This was the original intent, but I bungled the logic. Otherwise if there is a certificate chain issue, the repository can't be cloned in order for there to be a repo object. I think I missed this case because I was inside of a Mercurial clone as I was originally developing and testing this.

revlog: use pycompat.bytestr() to reliably have a %s-able value

debugcommands: stabilize output of debugbundle by having a custom repr We handle all dict-like things the same, and don't worry about it actually being a repr.

python3: whitelist another 5 passing tests found with the ratchet script

python3: replace sorted(<dict>.iterkeys()) with sorted(<dict>)

python3: wrap all uses of <exception>.strerror with strtolocal Our string literals are bytes, and we mostly want to %-format a strerror into a one of those literals, so this fixes a ton of issues.

pager: do not start pager if `ui` has been `pushbuffer`-ed The `pushbuffer`, `popbuffer` APIs are intended to capture internal output. They will prevent `ui.write` from writing to the actual `ui.fout`. So a pager won't receive the output and do the right thing. In general, it does not make sense to start a pager if ui is in the "pushbuffer" mode. Differential Revision: https://phab.mercurial-scm.org/D574

revset: do not flip "and" arguments when optimizing Rewrite `flipand(y, x)` to `andsmally(x, y)` so the AST order is unchanged, which could be more friendly to developers. Differential Revision: https://phab.mercurial-scm.org/D579

revset: make match function follow given subset if specified (API) This should be sensible default since mfunc(subset) is roughly equivalent to 'subset & mfunc'. The order argument is still there so we can specify 'anyorder' if the order doesn't really matter.

revset: move order argument to run-time match function We no longer need the order flag to build a parsed tree.

revset: fix example describing how ordering is determined It was 'X & !Y' before.

revset: move order constants from revsetlang Thanks to the recent refactor, the ordering rule is fully processed at runtime.

tag: use filtered repo when creating new tags (issue5539) When pruning a changeset that added a tag and then adding another tag, the "pruned" tag gets restored. This is because the tag creation step (tags._tag() call in tags.tag()) is currently done on the unfiltered repo. This behavior has been there from 7977d35df13b which backs out b08af8f0ac01 with no clear reason but caution on unthought situations at that time. In this changeset, we pass the filtered repo to tags._tag(), preventing "pruned" tags to reappear. This somehow restores b08af8f0ac01, though now we arguably have a valid use case for.

extensions: add wrappedfunction() context manager Several extensions exist that temporarily want to wrap a function (at least narrowhg, any many of the extensions in hg-experimental). That's why we have the unwrapfunction() that was introduced in 19578bb84731 (extensions: add unwrapfunction to undo wrapfunction, 2016-08-10). This patch adds a simple wrappedfunction() that returns a context manager. Differential Revision: https://phab.mercurial-scm.org/D472

mdiff: add a --ignore-space-at-eol option Add an option that only ignores whitespaces at EOL. The name of the option is the same as Git. .. feature:: Added `--ignore-space-at-eol` diff option to ignore whitespace differences at line endings. Differential Revision: https://phab.mercurial-scm.org/D422

revset: improve documentation about ordering handling The old documentation is a bit confusing. Namely, it's unclear whether `define` means "I should ALWAYS define a new order", or "I should SOMETIMES define a new order", and if it's the latter, what's the difference between `define` and `any`? This patch clarifies that and adds more examples. Differential Revision: https://phab.mercurial-scm.org/D523

revset: remove order information from tree (API) Keeping `order` in tree makes AST operation harder. And there could be invalid cases if trees could be generated and compounded freely, like: SetA(order=define) & SetB(order=define) ^^^^^^ couldn't be satisfied This patch changes the code to calculate order on the fly, during tree traversal. Optimization of reordering `and` arguments is preserved by introducing a new internal operation `flipand`. .. api:: revset.stringset() now takes 'order' as the last argument. Differential Revision: https://phab.mercurial-scm.org/D451

revset: drop optimization about reordering "or" set elements The reordering optimization is more important for "and" than "or", given the implementation details about "addset" and "filteredset" - reordering "or" may help "__contains__" test but not iteration, reordering "and" could help both. We are going to simplify the tree to remove ordering information. Removing "or" reordering optimization would make things simpler. This effectively reverts c63cb2d10d6d. It tracks back to the "orset" function added by the initial commit of revset (c9ce8ecd6). In the future, we might consider optimization at runtime (ex. do reordering and rewrites inside "orset"). Differential Revision: https://phab.mercurial-scm.org/D561

rebase: use _ctxdesc in one more place This simplifies the code. Differential Revision: https://phab.mercurial-scm.org/D566

rebase: move working parent and bookmark for obsoleted revs (BC) Previously, obsoleted revs with successors in destination are completely ignored. That caused some inconvenience when working copy is obsoleted. Most commands avoid working copy being obsoleted, but `hg pull` is an exception. This patch makes rebase able to move bookmarks or working parent for those obsoleted revs. It does so by keeping the obsoleted revs in `state` and marking them as "skipped, rebased to desired destination" during run-time. This reverts part of the behavior change of 3b7cb3d17137 and D24. Differential Revision: https://phab.mercurial-scm.org/D527

rebase: remove an unnecessary adjustdest in clearrebased `rev` being "skipped" could currently be caused by moving `rev` does not create a new commit. In this case, `state[rev]` is already changed to `p1`, and is a sane destination for bookmark or working parent movement. Therefore an additional destination adjustment is unnecessary. Differential Revision: https://phab.mercurial-scm.org/D565

rebase: sort destmap topologically Previously rebase source and destination could not overlap. But with the multi-destination support, source and destination could reasonably partially overlap. That requires another topological sort on `{sourcerev: destrev}` graph (destmap). This patch implements that. If a revision's destination is itself, the error message gets changed from "source is ancestor of destination" to "source and destination form a cycle". Not marking as BC since automation should depend on exit code, not error message. Differential Revision: https://phab.mercurial-scm.org/D470

rebase: initial support for multiple destinations This patch defines `SRC` (a single source revision) and `ALLSRC` (all source revisions) to be valid names in `--dest` revset if `--src` or `--rev` is used. So destination could be defined differently according to source revisions. The names are capitalized to make it clear they are "dynamically defined", distinguishable from normal revsets (Thanks Augie for the suggestion). This is useful, for example, `-r 'orphan()' -d 'calc-dest(SRC)'` to solve instability, which seems to be a highly wanted feature. The feature is not completed, namely if `-d` overlaps with `-r`, things could go wrong. A later patch will handle that case. The feature is also gated by `experimental.rebase.multidest` config option which is default off. Differential Revision: https://phab.mercurial-scm.org/D469

rebase: change internal format to support destination map A later patch will add multiple destination support. This patch changes internal state and the rebase state file format to support that. But the external interface still only supports single destination. A test was added to make sure rebase still supports legacy state file. The new state file is incompatible with old clients. We had done similar state file format change before: 5eac7ab, 92409f8, and 72412af. The state file is transient, so the impact of incompatibility is limited. Besides, the old client won't support multiple destinations anyway so it does not really make sense to make the file format compatible with them. Differential Revision: https://phab.mercurial-scm.org/D348

rebase: rewrite _computeobsoletenotrebased The old code stores successors of all related nodes together, which works fine if destination is unique. A future patch would make destination non-unique so let's change the implementation to test successors for rebaseset separately. Differential Revision: https://phab.mercurial-scm.org/D347

util: use ~ as a suffix for a temp file in the same directory as a source file Tools like Buck have patterns to ignore the creation of files (in the working copy) that match certain patterns: https://github.com/facebook/buck/blob/39278a4f0701c5239eae148968dc1ed4cc8661f7/src/com/facebook/buck/cli/Main.java#L259-L299 When Buck sees a new source file (as reported by Watchman), it has to invalidate a number of caches associated with the directory that contains the file. Using a standard suffix, such as `~`, would make it easier for Buck and others to filter out these types of file creation events. The other uses of `tempfile.mkstemp()` in Hg do not appear to be problematic because they (generally speaking) do not specify the `dir` parameter, so the new file is created in the system-appropriate temp directory, which is outside the working copy. Test Plan: `make tests` Differential Revision: https://phab.mercurial-scm.org/D468

morestatus: simplify check for unresolved merge conflicts Differential Revision: https://phab.mercurial-scm.org/D546

tests: rename test-terse-status.t to test-status-terse.t When looking for status tests, most people would probably look for "test-status*", so it would be nice if they could find it there. This also let's them run (most) status tests with "run-tests.py test-status*". Differential Revision: https://phab.mercurial-scm.org/D547

metadataonlyctx: don't crash when reusing the manifest with deletions This was originally fixed by Mateusz Kwapich for the `metaedit` command in fb-hgext with a test for the `metaedit` command. It didn't get upstreamed because `metaedit` was not in core. This patch fixes the crash and adds a test about `metadataonlyctx` to avoid future regressions. Differential Revision: https://phab.mercurial-scm.org/D550

context: make parents and text optional in metadataonlyctx The metadataonlyctx is to copy an existing context with some minor metadata changes. If the caller only wants to change "extra", or "user", ideally it does not have to read and pass "parents" and "text" information. This patch makes "parents" and "text" optionally to convenient callers. Differential Revision: https://phab.mercurial-scm.org/D548

test: add more obsmarker tests for pruning scenarios The obsfate output in cases of pruning is not ideal right now, add some tests so have these scenarios around.

template: better prune support in obsfate successorssets don't returns good results for pruned commit, add a workaround for simple cases. A proper fix would require a large rework of successorssets algorithm, I will send a separate series for this refactoring.

template: compute dates in obsfatedate Extract the dates from obsmarkers. Compute the min and max date from the obsmarker range list.

template: compute user in obsfateusers Extract, deduplicate users informations from obs markers in order to display them. Print all users for the moment, we might want to display users only in verbose mode later.

template: compute verb in obsfateverb Add a template function obsfateverb which use the markers information to compute a better obsfate verb. The current logic behind the obsfate verb is simple for the moment: - If the successorsets is empty, the changeset has been pruned, for example: Obsfate: pruned - If the successorsets length is 1, the changeset has been rewritten without divergence, for example: Obsfate: rewritten as 2:337fec4d2edc, 3:f257fde29c7a - If the successorsets length is more than 1, the changeset has diverged, for example: Obsfate: split as 2:337fec4d2edc, 3:f257fde29c7a As the divergence might occurs on a subset of successors, we might see some successors twice: Obsfate: split as 9:0b997eb7ceee, 5:dd800401bd8c, 10:eceed8f98ffc; split as 8:b18bc8331526, 5:dd800401bd8c, 10:eceed8f98ffc

contrib: add test-check-module-imports.t to the Python 3 whitelist This has the benefit of also catching most (if not all!) old-style print statements and except statements.

tests: update test-obsolete to pass our import checker

tests: update test-largefiles-cache to pass our import checker

tests: update test-inherit-mode to pass our import checker

tests: update test-relink to pass our import checker

tests: update test-strip to pass our import checker

tests: update test-share to pass our import checker

tests: update test-requires to pass our import checker

tests: update test-progress to pass our import checker

tests: update test-patchbomb to pass our import checker

merge with stable

dirstate: perform transactions with _copymap using single call, where possible This replaces patterns such as this: ``` if f in self._copymap: del self._copymap[f] ``` with this: ``` self._copymap.pop(f, None) ``` Although eliminating the extra lookup/call may be a negligible performance win in the standard dirstate, alternative implementations, such as [sqldirstate](https://bitbucket.org/facebook/hg-experimental/src/default/sqldirstate/) may see a bigger win where each of these calls results in an RPC, so the savings is greater. Test Plan: `make tests` Differential Revision: https://phab.mercurial-scm.org/D493

pull: do not prompt "hg update" if update.requiredest is set Previously, after pull, we show: (run 'hg update' to get a working copy) unconditionally. People might run `hg update` and get an exception if `update.requiredest` is set, and get a bit frustrated. This patch changes the code to not prompt `hg update` in that case. Differential Revision: https://phab.mercurial-scm.org/D516

changelog: abort on attempt to write wdir revision Similar to the previous patch which prevented writing the null revision to any revlog, but this is for the wdir revision. Thanks to Jun for pointing this out. Differential Revision: https://phab.mercurial-scm.org/D524

phabsend: show associated Differential Revisions with --confirm Often people running `phabsend --confirm` just want to check whether a commit will trigger a creation of new Differential Revision, or update an existing one. This patch implements that. The `--confirm` message was changed to use node instead of revision number to be consistent with what `phabsend` outputs. An example output looks like: D487 - a80f447973a0 test-extension: enable demandimport explicitly D494 - cf440ea6e47e test-casecollision-merge: fix the test NEW - 0a6b97147128 phabsend: polish the docstring a bit Send the above changes to https://phab.mercurial-scm.org/ (yn)? Differential Revision: https://phab.mercurial-scm.org/D514

phabsend: print the actual URL with --confirm Sometimes people have multiple Phabricator endpoints set in multiple repos. It seems better for `--confirm` to prompt about the Phabricator endpoint patches being sent to. Differential Revision: https://phab.mercurial-scm.org/D513

phabsend: detect patch change with larger context Previously phabsend has an optimization that will skip uploading a diff if the patch (with context line number = 1) remains unchanged. That could be confusing: Aug 24 15:52:28 <martinvonz> phillco: something is wrong with phabricator'your patches/ Aug 24 15:52:45 <martinvonz> ... with phabricator's view of your patches again Aug 24 15:53:38 <martinvonz> if i phabread D388 and then D399, i get a version of filemerge.py with "a, b, c" somewhere on line 344, which is not what phabricator shows for D399 Aug 24 15:53:51 <martinvonz> junw: maybe that's more for you ^ Fix that by checking context with 32767 lines, which is the same as what will be actually sent. Differential Revision: https://phab.mercurial-scm.org/D512

phabsend: make --amend the default The local tag feature was intended to make `phabsend` closer to `email` workflow. But its experience is not great in multiple ways: - after rebase, obsoleted changesets are still visible because of tags - without obsstore, the association information will get lost - even with obsstore, things could go wrong with graft, export+import - no easy way to tell which Differential Revision a commit is associated Therefore make `--amend` the default. People wanting the old behavior can use `--no-amend`. Differential Revision: https://phab.mercurial-scm.org/D511

phabsend: polish the docstring a bit Differential Revision: https://phab.mercurial-scm.org/D510

record: make the m key open an editor for the commit message (issue5667) With the former crecord extension, the user could edit the commit message while he was de-/selecting hunks. By pressing 'm', an editor showed up to edit the commit message. With record being part of mercurial, this feature is not available anymore. However, the help text still mentions it. As the infrastructure needed is still present, this feature is quite easily ported from the crecord extension to mercurial. It seems there is no test coverage for record ui, so I tested this patch manually on my local machine.

tests: update test-patch to pass our import checker

tests: update test-pager to pass our import checker

tests: update test-obsolete to pass our import checker

tests: update test-notify to pass our import checker

tests: update test-merge1 to pass our import checker

tests: update test-merge-symlinks to pass our import checker

tests: update test-logtoprocess to pass our import checker

tests: update test-log to pass our import checker

tests: update test-log-exthook to pass our import checker

tests: update test-largefiles-wireproto to pass our import checker

tests: update test-largefiles-small-disk to pass our import checker

tests: update test-keyword to pass our import checker

tests: update test-impexp-branch to pass our import checker

tests: update test-help to pass our import checker

tests: update test-hardlinks to pass our import checker

tests: update test-glog to pass our import checker

tests: update test-fncache to pass our import checker

tests: update test-eol to pass our import checker

tests: update test-dirstate to pass our import checker

tests: update test-debugcommands to pass our import checker

tests: update test-convert-clonebranches to pass our import checker

tests: update test-commit to pass our import checker

tests: update test-command-template to pass our import checker

tests: update test-chg to pass our import checker

tests: update test-bundle2-format to pass import checker

tests: update test-bundle2-pushback to pass the import checker

tests: update test-bookmarks to pass the import checker

tests: update test-bisect to pass our module import checker

tests: update test-archive to pass our module import checker

tests: update test-annotate to pass our module import checker

obsolete: fix old typo Clean an old typo in successorssets. Differential Revision: https://phab.mercurial-scm.org/D531

obsolete: move merge logic on the smaller object Refactor some logic in _succs in order to clean successorssets code. Differential Revision: https://phab.mercurial-scm.org/D530

releasenotes: view admonition titles using -l flag Since this extension is fairly new for almost all the contributors, remembering the admonition (with titles) is difficult. The list (-l) flag provides a list of all the active admonitions along with titles. For usage, hg releasenotes -l returns the list. Differential Revision: https://phab.mercurial-scm.org/D454

tests: move baduisetup test inside "#if demandimport" The test case depends on the failure happening not at import time, but at uisetup() time, so it doesn't make sense when demandimport is disabled. There was already a section for testing demandimport stuff, so I moved it inside that existing section. As part of the move, I enabled the extension using '--config' so subsequent tests don't get the bad extension enabled. Differential Revision: https://phab.mercurial-scm.org/D526

revlog: abort on attempt to write null revision My repo got corrupted yesterday by something that ended up writing the null revision to the revlog (nullid hash, not nullrev index, of course). We use many extensions internally (narrowhg, remotefilelog, evolve, internal extensions) and treemanifests are on. The null revision was written to the changelog, the root manifest log, and one subdirectory manifest log. I have no idea exactly why the null revision was written, but it seems cheap enough to check that we should fail instead of corrupting the repo. Differential Revision: https://phab.mercurial-scm.org/D522

context: remove unnecessary default values for matchers (API) ctx._dirstatestatus() is called only from workingctx._buildstatus() and that function, in turn, is called only from basectx.status(). basectx.status() will always pass a matcher to _buildstatus(), so there's no need to handle a None matcher there. Differential Revision: https://phab.mercurial-scm.org/D492

context: always pass a matcher into _matchstatus() (API) This just makes it a little easier to follow and removes the need to call the superclass's method in workingctx. Differential Revision: https://phab.mercurial-scm.org/D491

test-casecollision-merge: fix the test D30 (055fee3547df) makes the error message unpredictable, therefore the fix. Differential Revision: https://phab.mercurial-scm.org/D494

run-tests: make per-line condition support testcase names 7340465bd added multiple test cases support. The latter has a problem - output lines cannot be made conditional with `#if`: ``` # COUNTEREXAMPLE: DOES NOT WORK #testcases A B $ command-foo common ouput #if A A's ouput #else B's ouput #endif common ouput ``` That's not trivial to fix (even if it works in test, `run-tests.py -i` may be suboptimal because diff algorithm does not know how to skip the `#if` lines, even if it does, it may have trouble figuring out whether a changed line belongs to inside a `#if` block or outside). Matching output lines conditionally is useful. 4eec2f04a added per-line condition support for hghave. This patch extends that to also support test case names. Differential Revision: https://phab.mercurial-scm.org/D466

simplemerge: refactor _picklabels to be more compact Use @martinvonz's suggestion from D376. Differential Revision: https://phab.mercurial-scm.org/D521

simplemerge: remove check for null context Differential Revision: https://phab.mercurial-scm.org/D520

run-tests: pass unicode to Pygments This is required on Python 3, and is more correct on Python 2 because Pygments is a unicode library.

run-tests: factor out highlight functions

run-tests: include "\n" in formatted message instead of calling writeln() So we don't have to strip "\n" from pygments output.

encoding: add fast path of from/toutf8b() for ASCII strings See the previous patch for why. The added test seems not making much sense because ASCII strings should never contain "\xed" and be valid UTF-8. (with mercurial repo) $ export HGRCPATH=/dev/null HGPLAIN= $ hg log --time --config experimental.stabilization=all -Tjson > /dev/null (original) time: real 6.830 secs (user 6.740+0.000 sys 0.080+0.000) time: real 6.690 secs (user 6.650+0.000 sys 0.040+0.000) time: real 6.700 secs (user 6.640+0.000 sys 0.060+0.000) (fast jsonescape) time: real 5.630 secs (user 5.550+0.000 sys 0.070+0.000) time: real 5.700 secs (user 5.650+0.000 sys 0.050+0.000) time: real 5.690 secs (user 5.640+0.000 sys 0.050+0.000) (this patch) time: real 5.190 secs (user 5.120+0.000 sys 0.070+0.000) time: real 5.230 secs (user 5.170+0.000 sys 0.050+0.000) time: real 5.220 secs (user 5.150+0.000 sys 0.070+0.000)

encoding: add fast path of from/tolocal() for ASCII strings This is micro optimization, but seems not bad since to/fromlocal() is called lots of times and isasciistr() is cheap and simple. We boldly assume that any non-ASCII characters have at least one 8-bit byte. This isn't true for some email character sets (e.g. ISO-2022-JP and UTF-7), but I believe no such encodings are used as a platform default. Shift_JIS, a major crap, is okay as it should have a leading byte in 0x80-0xff range. (with mercurial repo) $ export HGRCPATH=/dev/null HGPLAIN= $ hg log --time --config experimental.stabilization=all > /dev/null (original) time: real 7.460 secs (user 7.420+0.000 sys 0.030+0.000) time: real 7.670 secs (user 7.590+0.000 sys 0.080+0.000) time: real 7.560 secs (user 7.510+0.000 sys 0.040+0.000) (this patch) time: real 7.340 secs (user 7.260+0.000 sys 0.060+0.000) time: real 7.260 secs (user 7.210+0.000 sys 0.030+0.000) time: real 7.310 secs (user 7.260+0.000 sys 0.060+0.000)

encoding: add function to test if a str consists of ASCII characters Most strings are ASCII. Let's optimize for it. Using uint64_t is slightly faster than uint32_t on 64bit system, but there isn't huge difference.

encoding: add fast path of jsonescape() (issue5533) This isn't highly optimized as it copies characters one by one, but seems reasonably simple and not slow. (with mercurial repo) $ export HGRCPATH=/dev/null HGPLAIN= $ hg log --time --config experimental.stabilization=all -Tjson > /dev/null (original) time: real 6.830 secs (user 6.740+0.000 sys 0.080+0.000) time: real 6.690 secs (user 6.650+0.000 sys 0.040+0.000) time: real 6.700 secs (user 6.640+0.000 sys 0.060+0.000) (this patch) time: real 5.630 secs (user 5.550+0.000 sys 0.070+0.000) time: real 5.700 secs (user 5.650+0.000 sys 0.050+0.000) time: real 5.690 secs (user 5.640+0.000 sys 0.050+0.000)