copies: remove msrc and mdst parameters This function already has lots of parameters. And we can get manifests from contexts. So let's get msrc and mdst parameters from srcctx and dstctx.

copies: add dstctx parameter Add parameter with destination context

copies: rename ctx to srcctx In the next diff we'll pass new dstctx parameter. Let's rename ctx to srcctx in this patch.

copies: rename m2 to mdst Small refactoring to rename m2 to more clearer mdst.

copies: rename m1 to msrc Small refactoring that renames `m1` parameter name to a more clearer name `msrc`.

transaction: delete callbacks after use Before this change, localrepository instances that performed multiple transactions would leak transaction objects. This could occur when running `hg convert`. When running `hg convert`, the leak would be ~90 MB per 10,000 changesets as measured with the Mercurial repo itself. The leak I tracked down involved the "validate" closure from localrepository.transaction(). It appeared to be keeping a reference to the original transaction via __closure__. __del__ semantics and a circular reference involving the repo object may have also come into play. Attempting to refactor the "validate" closure proved to be difficult because the "tr" reference in that closure may reference an object that isn't created until transaction.__init__ is called. And the "validate" closure is passed as an argument to transaction.__init__. Plus there is a giant warning comment in "validate" about how hacky it is. I did not want to venture into the dragon den. Anyway, we've had problems with transactions causing leaks before. The solution then (14e683d6b273) is the same as the solution in this patch: drop references to callbacks after they are called. This not only breaks cycles in core Mercurial but can help break cycles in extensions that accidentally introduce them. While I only tracked down a leak due to self.validator, since this is the 2nd time I've tracked down leaks due to transaction callbacks I figure enough is enough and we should prevent the class of leak from occurring regardless of the variable. That's why all callback variables are now nuked.

match: remove special-casing of always-matching patterns in patternmatcher This moves the optimization for patterns that match everything to the caller, so we can remove it from patternmatcher. Note that we need to teach alwaysmatcher to use relative paths now in cases like "hg files .." from inside mercurial/, because while it still matches everything, paths should be printed relative to the working directory.

match: move normalize() call out of matcher constructors By passing in the result of the normalize() call, we prepare for moving the special handling of patterns that always match out of the patternmatcher. It also lets us remove many of the arguments from the matcher, because they were passed only the the normalize function (we could have removed the arguments by binding them to the function instead of moving the normalize() call out).

match: drop support for empty pattern list in patternmatcher Since the caller now deals with empty pattern lists, we can drop that support in the patternmatcher. It now gets the more logical behavior of matching nothing when no patterns are given (although there is no in-core caller that will pass no patterns).

match: optimize visitdir() for when no explicit files are listed In patternmatcher, we used to say that all directories should be visited if no explicit files were listed, because the case of empty _files usually implied that no patterns were given (which in turns meant that everything should match). However, this made e.g. "hg files -r . rootfilesin:." slower than necessary, because that also ended up with an empty list in _files. Now that patternmatcher does not handle includes, the only remaining case where its _files/_fileset fields will be empty is when it's matching everything. We can therefore treat the always-case specially and stop treating the empty _files case specially. This makes the case mentioned above faster on treemanifest repos.

match: handle everything-matching using new alwaysmatcher Having a special matcher that always matches seems to make more sense than making one of the other matchers handle the case. For now, we just use this new matcher when no patterns were provided.

match: add __repr__ for subdirmatcher Should at least be useful for debugging. Would matter for correctness too if fsmonitor or Facebook's sparse extension worked with subrepos (which I don't know if they do).

tests: make test-manifest.py portable to Python 3 Lots of b prefixes here, and https://bugs.python.org/issue29714 means that this test is still very broken on Python 3.6 and 3.6.1, but 3.6.2 should things (based on testing using tip of the 3.6 branch from git). #cleanup-only

cleanup: rename all iteritems methods to items and add iteritems alias Due to a quirk of our module importer setup on Python 3, all calls and definitions of methods named iteritems() get rewritten at import time. Unfortunately, this means there's not a good portable way to access these methods from non-module-loader'ed code like our unit tests. This change fixes that, which also unblocks test-manifest.py from passing under Python 3. We don't presently define any itervalues methods, or we'd need to give those similar treatment.

help: work around textwrap.dedent() only working on strings

server: write out pid using bytes IO instead of str IO

help: convert dict to strkwargs

util: use sysstr.join instead of bytes.join in textwrap wrapper

tests: port test extension in test-help.t to python 3 The changes required herein suggest to me that we should probably accept ascii-safe unicode strings for command name, flag name, etc.

doc: port check-seclevel.py to be Python 2/3 portable

match: define exactmatcher.matchfn statically This should eliminate the reference cycle, self.matchfn -> self.exact -> self.

match: remove override of prefix() from differencematcher It's exactly the same as basematcher.prefix().

cat: do not start pager if output will be written to file

cat: pass filename template as explicit argument I'll move the handling of the '-' filename to commands.cat().

cmdutil: extract function checking if pattern should be taken as stdin/out This will be used in commands.cat().

cmdutil: drop deprecated hack to pass file object to makefileobj() (API) All callers pass a string 'pat' or None.

encoding: make sure "wide" variable never be referenced from other modules Better to not expose (maybe-) unicode objects.

manifest: use itertools.chain() instead of + for Python 3 compat This is all pure-Python code, so I'm not too worried about perf here, but we can come back and fix it should it be a problem. With this change, the manifest code passes most unit tests on Python 3 (once the tests are corrected with many b prefixes. I've got a little more to sort out there and then I'll mail that change too.

manifest: fix some pure-Python parser bits to work on Python 3

tests: make test-manifest finish importing in Python 3 The test is still broken, but now it executes.

tests: drop assertIn polyfill now that we're 2.7-only

perf: benchmark command for revlog indexes We didn't have explicit microbenchmark coverage for loading revlog indexes. That seems like a useful thing to have, so let's add it. We currently measure the low-level nodemap APIs. There is room to hook in at the actual revlog layer. This could be done as a follow-up. The hackiest thing about this patch is specifying revlog paths. Other commands have arguments that allow resolution of changelog, manifest, and filelog. I needed to hook in at a lower level of the revlog API than what the existing helper functions to resolve revlogs allowed. I was too lazy to write some new APIs. This could be done as a follow-up easily enough. Example output for `hg perfrevlogindex 00changelog.i` on my Firefox repo (404418 revisions): ! revlog constructor ! wall 0.003106 comb 0.000000 user 0.000000 sys 0.000000 (best of 912) ! read ! wall 0.003077 comb 0.000000 user 0.000000 sys 0.000000 (best of 924) ! create index object ! wall 0.000000 comb 0.000000 user 0.000000 sys 0.000000 (best of 1803994) ! retrieve index entry for rev 0 ! wall 0.000193 comb 0.000000 user 0.000000 sys 0.000000 (best of 14037) ! look up missing node ! wall 0.003313 comb 0.000000 user 0.000000 sys 0.000000 (best of 865) ! look up node at rev 0 ! wall 0.003295 comb 0.010000 user 0.010000 sys 0.000000 (best of 858) ! look up node at 1/4 len ! wall 0.002598 comb 0.010000 user 0.010000 sys 0.000000 (best of 1103) ! look up node at 1/2 len ! wall 0.001909 comb 0.000000 user 0.000000 sys 0.000000 (best of 1507) ! look up node at 3/4 len ! wall 0.001213 comb 0.000000 user 0.000000 sys 0.000000 (best of 2275) ! look up node at tip ! wall 0.000453 comb 0.000000 user 0.000000 sys 0.000000 (best of 5697) ! look up all nodes (forward) ! wall 0.094615 comb 0.100000 user 0.100000 sys 0.000000 (best of 100) ! look up all nodes (reverse) ! wall 0.045889 comb 0.050000 user 0.050000 sys 0.000000 (best of 100) ! retrieve all index entries (forward) ! wall 0.078398 comb 0.080000 user 0.060000 sys 0.020000 (best of 100) ! retrieve all index entries (reverse) ! wall 0.079376 comb 0.080000 user 0.070000 sys 0.010000 (best of 100)

perf: rename perfrevlog to perfrevlogrevisions We have a couple of commands beginning with "perfrevlog." The actual "perfrevlog" command actually measures resolving the fulltext of multiple revisions. So let's rename it to reflect what it actually does.

server: use pycompat to get argv

encoding: make wide character class list a sysstr That's what east_asian_width returns, so just match it.

cmdutil: use sorted(dict) instead of x = dict.keys(); x.sort() The former both does less work and has the virtue of working on Python 3.

util: look for empty-sysstr instead of empty-bytesstr in textwrap code Fixes behavior on Python 3.

minirst: look for column delimiters using slices instead of indicies This works on both Python 2 and 3.

minirst: grab a byte, not an int, for the underline style

minirst: use bytes.strip instead of str.strip

py3: use pycompat.bytestr so that we don't get ascii values This fixes `hg files 'set:(**.py)'` which makes test-check-py3-compat.t able to run on Python 3. So if you now do `python3 ./run-tests.py test-check-py3-compat`, the test will actually run.

py3: update test-check-py3-compat.t

loader: pywatchman appears to already be py3 compatible Our loader was doing some confusing things in pywatchman, but it looks like we shouldn't be using it there anyway.

py3: update test expectations for py3-commands test

context: do not cache manifestctx This will make sure when ctx.repo.manifestlog changes, a correct new manifestctx is returned. repo.manifestlog takes care of caching so the manifestctx won't be reconstructed every time.

test-context: add a case demonstrating manifest caching problem This issue was discovered when testing absorb on Windows. What happens are: 1. ctx.p1().manifestctx gets cached. let's call ctx.p1().manifestctx._revlog() "mrevlog1" 2. repo.manifestlog gets invalidated. let's call repo.manifestlog._revlog "mrevlog2" 3. repo.commitctx(ctx) commitctx uses ctx.p1().manifestctx and writes to "mrevlog1" 4. repo[n].manifest() cannot find the manifest node in "mrevlog2" This patch adds a test case to reproduce the issue.

debugbundle: display the content of obsmarkers parts We parse and display the markers in the part when possible.

bundle: add an experimental knob to include obsmarkers in bundle The "hg bundle" command is a good place to test if the inclusion of obsmarkers within a bundle is working well (part exists, content is correct etc). So we add a way to have them included. Ideally, this would be controlled by a change around bundlespec (bundlespec "v3" + arguments). However, my main goal is to have obsmarkers included in bundle created by the 'hg strip' command, not the 'hg bundle' so for now I'm avoiding the detour through bundlespec rework territory. Better debug output for obsmarkers in 'debugbundle' will be added in later changesets. The 'test-obsolete-bundle-strip.t' test will also get updated in a later changeset to keep the current changeset smaller.