py3: source-transform only call-sites of iteritems(), not definitions

branchmap.branchcache, among other classes, defines a
iteritems(). That currently gets replaced by items() by the source
transformer. That makes it harder for extensions to work with both py2
and py3, since they have to call either items() or iteritems() on
branchcache. Let's not replace definitions of iteritems() (and
itervalues()) and only replace the call-sites. We need to also add an
items() alias to branchcache (etc) so our transformer call-sites will
find it.

Differential Revision: https://phab.mercurial-scm.org/D6641

hgext/remotenames.py

@@ -1,403 +1,405 b''
 # remotenames.py - extension to display remotenames
 #
 # Copyright 2017 Augie Fackler <[e-mail]>
 # Copyright 2017 Sean Farley <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 """ showing remotebookmarks and remotebranches in UI (EXPERIMENTAL)
 
 By default both remotebookmarks and remotebranches are turned on. Config knob to
 control the individually are as follows.
 
 Config options to tweak the default behaviour:
 
 remotenames.bookmarks
   Boolean value to enable or disable showing of remotebookmarks (default: True)
 
 remotenames.branches
   Boolean value to enable or disable showing of remotebranches (default: True)
 
 remotenames.hoistedpeer
   Name of the peer whose remotebookmarks should be hoisted into the top-level
   namespace (default: 'default')
 """
 
 from __future__ import absolute_import
 
 from mercurial.i18n import _
 
 from mercurial.node import (
     bin,
 )
 from mercurial import (
     bookmarks,
     error,
     extensions,
     logexchange,
     namespaces,
     pycompat,
     registrar,
     revsetlang,
     smartset,
     templateutil,
     util,
 )
 
 from mercurial.utils import (
     stringutil,
 )
 
 if pycompat.ispy3:
     import collections.abc
     mutablemapping = collections.abc.MutableMapping
 else:
     import collections
     mutablemapping = collections.MutableMapping
 
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
 testedwith = 'ships-with-hg-core'
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 templatekeyword = registrar.templatekeyword()
 revsetpredicate = registrar.revsetpredicate()
 
 configitem('remotenames', 'bookmarks',
     default=True,
 )
 configitem('remotenames', 'branches',
     default=True,
 )
 configitem('remotenames', 'hoistedpeer',
     default='default',
 )
 
 class lazyremotenamedict(mutablemapping):
     """
     Read-only dict-like Class to lazily resolve remotename entries
 
     We are doing that because remotenames startup was slow.
     We lazily read the remotenames file once to figure out the potential entries
     and store them in self.potentialentries. Then when asked to resolve an
     entry, if it is not in self.potentialentries, then it isn't there, if it
     is in self.potentialentries we resolve it and store the result in
     self.cache. We cannot be lazy is when asked all the entries (keys).
     """
     def __init__(self, kind, repo):
         self.cache = {}
         self.potentialentries = {}
         self._kind = kind # bookmarks or branches
         self._repo = repo
         self.loaded = False
 
     def _load(self):
         """ Read the remotenames file, store entries matching selected kind """
         self.loaded = True
         repo = self._repo
         for node, rpath, rname in logexchange.readremotenamefile(repo,
                                                                 self._kind):
             name = rpath + '/' + rname
             self.potentialentries[name] = (node, rpath, name)
 
     def _resolvedata(self, potentialentry):
         """ Check that the node for potentialentry exists and return it """
         if not potentialentry in self.potentialentries:
             return None
         node, remote, name = self.potentialentries[potentialentry]
         repo = self._repo
         binnode = bin(node)
         # if the node doesn't exist, skip it
         try:
             repo.changelog.rev(binnode)
         except LookupError:
             return None
         # Skip closed branches
         if (self._kind == 'branches' and repo[binnode].closesbranch()):
             return None
         return [binnode]
 
     def __getitem__(self, key):
         if not self.loaded:
             self._load()
         val = self._fetchandcache(key)
         if val is not None:
             return val
         else:
             raise KeyError()
 
     def __iter__(self):
         return iter(self.potentialentries)
 
     def __len__(self):
         return len(self.potentialentries)
 
     def __setitem__(self):
         raise NotImplementedError
 
     def __delitem__(self):
         raise NotImplementedError
 
     def _fetchandcache(self, key):
         if key in self.cache:
             return self.cache[key]
         val = self._resolvedata(key)
         if val is not None:
             self.cache[key] = val
             return val
         else:
             return None
 
     def keys(self):
         """ Get a list of bookmark or branch names """
         if not self.loaded:
             self._load()
         return self.potentialentries.keys()
 
     def iteritems(self):
         """ Iterate over (name, node) tuples """
 
         if not self.loaded:
             self._load()
 
         for k, vtup in self.potentialentries.iteritems():
             yield (k, [bin(vtup[0])])
 
+    items = iteritems
+
 class remotenames(object):
     """
     This class encapsulates all the remotenames state. It also contains
     methods to access that state in convenient ways. Remotenames are lazy
     loaded. Whenever client code needs to ensure the freshest copy of
     remotenames, use the `clearnames` method to force an eventual load.
     """
 
     def __init__(self, repo, *args):
         self._repo = repo
         self.clearnames()
 
     def clearnames(self):
         """ Clear all remote names state """
         self.bookmarks = lazyremotenamedict("bookmarks", self._repo)
         self.branches = lazyremotenamedict("branches", self._repo)
         self._invalidatecache()
 
     def _invalidatecache(self):
         self._nodetobmarks = None
         self._nodetobranch = None
         self._hoisttonodes = None
         self._nodetohoists = None
 
     def bmarktonodes(self):
         return self.bookmarks
 
     def nodetobmarks(self):
         if not self._nodetobmarks:
             bmarktonodes = self.bmarktonodes()
             self._nodetobmarks = {}
             for name, node in bmarktonodes.iteritems():
                 self._nodetobmarks.setdefault(node[0], []).append(name)
         return self._nodetobmarks
 
     def branchtonodes(self):
         return self.branches
 
     def nodetobranch(self):
         if not self._nodetobranch:
             branchtonodes = self.branchtonodes()
             self._nodetobranch = {}
             for name, nodes in branchtonodes.iteritems():
                 for node in nodes:
                     self._nodetobranch.setdefault(node, []).append(name)
         return self._nodetobranch
 
     def hoisttonodes(self, hoist):
         if not self._hoisttonodes:
             marktonodes = self.bmarktonodes()
             self._hoisttonodes = {}
             hoist += '/'
             for name, node in marktonodes.iteritems():
                 if name.startswith(hoist):
                     name = name[len(hoist):]
                     self._hoisttonodes[name] = node
         return self._hoisttonodes
 
     def nodetohoists(self, hoist):
         if not self._nodetohoists:
             marktonodes = self.bmarktonodes()
             self._nodetohoists = {}
             hoist += '/'
             for name, node in marktonodes.iteritems():
                 if name.startswith(hoist):
                     name = name[len(hoist):]
                     self._nodetohoists.setdefault(node[0], []).append(name)
         return self._nodetohoists
 
 def wrapprintbookmarks(orig, ui, repo, fm, bmarks):
     if 'remotebookmarks' not in repo.names:
         return
     ns = repo.names['remotebookmarks']
 
     for name in ns.listnames(repo):
         nodes = ns.nodes(repo, name)
         if not nodes:
             continue
         node = nodes[0]
 
         bmarks[name] = (node, ' ', '')
 
     return orig(ui, repo, fm, bmarks)
 
 def extsetup(ui):
     extensions.wrapfunction(bookmarks, '_printbookmarks', wrapprintbookmarks)
 
 def reposetup(ui, repo):
 
     # set the config option to store remotenames
     repo.ui.setconfig('experimental', 'remotenames', True, 'remotenames-ext')
 
     if not repo.local():
         return
 
     repo._remotenames = remotenames(repo)
     ns = namespaces.namespace
 
     if ui.configbool('remotenames', 'bookmarks'):
         remotebookmarkns = ns(
             'remotebookmarks',
             templatename='remotebookmarks',
             colorname='remotebookmark',
             logfmt='remote bookmark:  %s\n',
             listnames=lambda repo: repo._remotenames.bmarktonodes().keys(),
             namemap=lambda repo, name:
                 repo._remotenames.bmarktonodes().get(name, []),
             nodemap=lambda repo, node:
                 repo._remotenames.nodetobmarks().get(node, []))
         repo.names.addnamespace(remotebookmarkns)
 
         # hoisting only works if there are remote bookmarks
         hoist = ui.config('remotenames', 'hoistedpeer')
         if hoist:
             hoistednamens = ns(
                 'hoistednames',
                 templatename='hoistednames',
                 colorname='hoistedname',
                 logfmt='hoisted name:  %s\n',
                 listnames = lambda repo:
                     repo._remotenames.hoisttonodes(hoist).keys(),
                 namemap = lambda repo, name:
                     repo._remotenames.hoisttonodes(hoist).get(name, []),
                 nodemap = lambda repo, node:
                     repo._remotenames.nodetohoists(hoist).get(node, []))
             repo.names.addnamespace(hoistednamens)
 
     if ui.configbool('remotenames', 'branches'):
         remotebranchns = ns(
             'remotebranches',
             templatename='remotebranches',
             colorname='remotebranch',
             logfmt='remote branch:  %s\n',
             listnames = lambda repo: repo._remotenames.branchtonodes().keys(),
             namemap = lambda repo, name:
                 repo._remotenames.branchtonodes().get(name, []),
             nodemap = lambda repo, node:
                 repo._remotenames.nodetobranch().get(node, []))
         repo.names.addnamespace(remotebranchns)
 
 @templatekeyword('remotenames', requires={'repo', 'ctx'})
 def remotenameskw(context, mapping):
     """List of strings. Remote names associated with the changeset."""
     repo = context.resource(mapping, 'repo')
     ctx = context.resource(mapping, 'ctx')
 
     remotenames = []
     if 'remotebookmarks' in repo.names:
         remotenames = repo.names['remotebookmarks'].names(repo, ctx.node())
 
     if 'remotebranches' in repo.names:
         remotenames += repo.names['remotebranches'].names(repo, ctx.node())
 
     return templateutil.compatlist(context, mapping, 'remotename', remotenames,
                                    plural='remotenames')
 
 @templatekeyword('remotebookmarks', requires={'repo', 'ctx'})
 def remotebookmarkskw(context, mapping):
     """List of strings. Remote bookmarks associated with the changeset."""
     repo = context.resource(mapping, 'repo')
     ctx = context.resource(mapping, 'ctx')
 
     remotebmarks = []
     if 'remotebookmarks' in repo.names:
         remotebmarks = repo.names['remotebookmarks'].names(repo, ctx.node())
 
     return templateutil.compatlist(context, mapping, 'remotebookmark',
                                    remotebmarks, plural='remotebookmarks')
 
 @templatekeyword('remotebranches', requires={'repo', 'ctx'})
 def remotebrancheskw(context, mapping):
     """List of strings. Remote branches associated with the changeset."""
     repo = context.resource(mapping, 'repo')
     ctx = context.resource(mapping, 'ctx')
 
     remotebranches = []
     if 'remotebranches' in repo.names:
         remotebranches = repo.names['remotebranches'].names(repo, ctx.node())
 
     return templateutil.compatlist(context, mapping, 'remotebranch',
                                    remotebranches, plural='remotebranches')
 
 def _revsetutil(repo, subset, x, rtypes):
     """utility function to return a set of revs based on the rtypes"""
     args = revsetlang.getargs(x, 0, 1, _('only one argument accepted'))
     if args:
         kind, pattern, matcher = stringutil.stringmatcher(
             revsetlang.getstring(args[0], _('argument must be a string')))
     else:
         kind = pattern = None
         matcher = util.always
 
     nodes = set()
     cl = repo.changelog
     for rtype in rtypes:
         if rtype in repo.names:
             ns = repo.names[rtype]
             for name in ns.listnames(repo):
                 if not matcher(name):
                     continue
                 nodes.update(ns.nodes(repo, name))
     if kind == 'literal' and not nodes:
         raise error.RepoLookupError(_("remote name '%s' does not exist")
                                     % pattern)
 
     revs = (cl.rev(n) for n in nodes if cl.hasnode(n))
     return subset & smartset.baseset(revs)
 
 @revsetpredicate('remotenames([name])')
 def remotenamesrevset(repo, subset, x):
     """All changesets which have a remotename on them. If `name` is
     specified, only remotenames of matching remote paths are considered.
 
     Pattern matching is supported for `name`. See :hg:`help revisions.patterns`.
     """
     return _revsetutil(repo, subset, x, ('remotebookmarks', 'remotebranches'))
 
 @revsetpredicate('remotebranches([name])')
 def remotebranchesrevset(repo, subset, x):
     """All changesets which are branch heads on remotes. If `name` is
     specified, only remotenames of matching remote paths are considered.
 
     Pattern matching is supported for `name`. See :hg:`help revisions.patterns`.
     """
     return _revsetutil(repo, subset, x, ('remotebranches',))
 
 @revsetpredicate('remotebookmarks([name])')
 def remotebmarksrevset(repo, subset, x):
     """All changesets which have bookmarks on remotes. If `name` is
     specified, only remotenames of matching remote paths are considered.
 
     Pattern matching is supported for `name`. See :hg:`help revisions.patterns`.
     """
     return _revsetutil(repo, subset, x, ('remotebookmarks',))

mercurial/__init__.py

@@ -1,312 +1,314 b''
 # __init__.py - Startup and module loading logic for Mercurial.
 #
 # Copyright 2015 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import sys
 
 # Allow 'from mercurial import demandimport' to keep working.
 import hgdemandimport
 demandimport = hgdemandimport
 
 __all__ = []
 
 # Python 3 uses a custom module loader that transforms source code between
 # source file reading and compilation. This is done by registering a custom
 # finder that changes the spec for Mercurial modules to use a custom loader.
 if sys.version_info[0] >= 3:
     import importlib
     import importlib.abc
     import io
     import token
     import tokenize
 
     class hgpathentryfinder(importlib.abc.MetaPathFinder):
         """A sys.meta_path finder that uses a custom module loader."""
         def find_spec(self, fullname, path, target=None):
             # Only handle Mercurial-related modules.
             if not fullname.startswith(('mercurial.', 'hgext.')):
                 return None
             # don't try to parse binary
             if fullname.startswith('mercurial.cext.'):
                 return None
             # third-party packages are expected to be dual-version clean
             if fullname.startswith('mercurial.thirdparty'):
                 return None
             # zstd is already dual-version clean, don't try and mangle it
             if fullname.startswith('mercurial.zstd'):
                 return None
             # rustext is built for the right python version,
             # don't try and mangle it
             if fullname.startswith('mercurial.rustext'):
                 return None
             # pywatchman is already dual-version clean, don't try and mangle it
             if fullname.startswith('hgext.fsmonitor.pywatchman'):
                 return None
 
             # Try to find the module using other registered finders.
             spec = None
             for finder in sys.meta_path:
                 if finder == self:
                     continue
 
                 # Originally the API was a `find_module` method, but it was
                 # renamed to `find_spec` in python 3.4, with a new `target`
                 # argument.
                 find_spec_method = getattr(finder, 'find_spec', None)
                 if find_spec_method:
                     spec = find_spec_method(fullname, path, target=target)
                 else:
                     spec = finder.find_module(fullname)
                     if spec is not None:
                         spec = importlib.util.spec_from_loader(fullname, spec)
                 if spec:
                     break
 
             # This is a Mercurial-related module but we couldn't find it
             # using the previously-registered finders. This likely means
             # the module doesn't exist.
             if not spec:
                 return None
 
             # TODO need to support loaders from alternate specs, like zip
             # loaders.
             loader = hgloader(spec.name, spec.origin)
             # Can't use util.safehasattr here because that would require
             # importing util, and we're in import code.
             if hasattr(spec.loader, 'loader'): # hasattr-py3-only
                 # This is a nested loader (maybe a lazy loader?)
                 spec.loader.loader = loader
             else:
                 spec.loader = loader
             return spec
 
     def replacetokens(tokens, fullname):
         """Transform a stream of tokens from raw to Python 3.
 
         It is called by the custom module loading machinery to rewrite
         source/tokens between source decoding and compilation.
 
         Returns a generator of possibly rewritten tokens.
 
         The input token list may be mutated as part of processing. However,
         its changes do not necessarily match the output token stream.
 
         REMEMBER TO CHANGE ``BYTECODEHEADER`` WHEN CHANGING THIS FUNCTION
         OR CACHED FILES WON'T GET INVALIDATED PROPERLY.
         """
         futureimpline = False
 
         # The following utility functions access the tokens list and i index of
         # the for i, t enumerate(tokens) loop below
         def _isop(j, *o):
             """Assert that tokens[j] is an OP with one of the given values"""
             try:
                 return tokens[j].type == token.OP and tokens[j].string in o
             except IndexError:
                 return False
 
         def _findargnofcall(n):
             """Find arg n of a call expression (start at 0)
 
             Returns index of the first token of that argument, or None if
             there is not that many arguments.
 
             Assumes that token[i + 1] is '('.
 
             """
             nested = 0
             for j in range(i + 2, len(tokens)):
                 if _isop(j, ')', ']', '}'):
                     # end of call, tuple, subscription or dict / set
                     nested -= 1
                     if nested < 0:
                         return None
                 elif n == 0:
                     # this is the starting position of arg
                     return j
                 elif _isop(j, '(', '[', '{'):
                     nested += 1
                 elif _isop(j, ',') and nested == 0:
                     n -= 1
 
             return None
 
         def _ensureunicode(j):
             """Make sure the token at j is a unicode string
 
             This rewrites a string token to include the unicode literal prefix
             so the string transformer won't add the byte prefix.
 
             Ignores tokens that are not strings. Assumes bounds checking has
             already been done.
 
             """
             st = tokens[j]
             if st.type == token.STRING and st.string.startswith(("'", '"')):
                 tokens[j] = st._replace(string='u%s' % st.string)
 
         for i, t in enumerate(tokens):
             # Convert most string literals to byte literals. String literals
             # in Python 2 are bytes. String literals in Python 3 are unicode.
             # Most strings in Mercurial are bytes and unicode strings are rare.
             # Rather than rewrite all string literals to use ``b''`` to indicate
             # byte strings, we apply this token transformer to insert the ``b``
             # prefix nearly everywhere.
             if t.type == token.STRING:
                 s = t.string
 
                 # Preserve docstrings as string literals. This is inconsistent
                 # with regular unprefixed strings. However, the
                 # "from __future__" parsing (which allows a module docstring to
                 # exist before it) doesn't properly handle the docstring if it
                 # is b''' prefixed, leading to a SyntaxError. We leave all
                 # docstrings as unprefixed to avoid this. This means Mercurial
                 # components touching docstrings need to handle unicode,
                 # unfortunately.
                 if s[0:3] in ("'''", '"""'):
                     yield t
                     continue
 
                 # If the first character isn't a quote, it is likely a string
                 # prefixing character (such as 'b', 'u', or 'r'. Ignore.
                 if s[0] not in ("'", '"'):
                     yield t
                     continue
 
                 # String literal. Prefix to make a b'' string.
                 yield t._replace(string='b%s' % t.string)
                 continue
 
             # Insert compatibility imports at "from __future__ import" line.
             # No '\n' should be added to preserve line numbers.
             if (t.type == token.NAME and t.string == 'import' and
                 all(u.type == token.NAME for u in tokens[i - 2:i]) and
                 [u.string for u in tokens[i - 2:i]] == ['from', '__future__']):
                 futureimpline = True
             if t.type == token.NEWLINE and futureimpline:
                 futureimpline = False
                 if fullname == 'mercurial.pycompat':
                     yield t
                     continue
                 r, c = t.start
                 l = (b'; from mercurial.pycompat import '
                      b'delattr, getattr, hasattr, setattr, '
                      b'open, unicode\n')
                 for u in tokenize.tokenize(io.BytesIO(l).readline):
                     if u.type in (tokenize.ENCODING, token.ENDMARKER):
                         continue
                     yield u._replace(
                         start=(r, c + u.start[1]), end=(r, c + u.end[1]))
                 continue
 
             # This looks like a function call.
             if t.type == token.NAME and _isop(i + 1, '('):
                 fn = t.string
 
                 # *attr() builtins don't accept byte strings to 2nd argument.
                 if (fn in ('getattr', 'setattr', 'hasattr', 'safehasattr') and
                         not _isop(i - 1, '.')):
                     arg1idx = _findargnofcall(1)
                     if arg1idx is not None:
                         _ensureunicode(arg1idx)
 
                 # .encode() and .decode() on str/bytes/unicode don't accept
                 # byte strings on Python 3.
                 elif fn in ('encode', 'decode') and _isop(i - 1, '.'):
                     for argn in range(2):
                         argidx = _findargnofcall(argn)
                         if argidx is not None:
                             _ensureunicode(argidx)
 
                 # It changes iteritems/values to items/values as they are not
                 # present in Python 3 world.
-                elif fn in ('iteritems', 'itervalues'):
+                elif (fn in ('iteritems', 'itervalues') and
+                      not (tokens[i - 1].type == token.NAME and
+                           tokens[i - 1].string == 'def')):
                     yield t._replace(string=fn[4:])
                     continue
 
             # Emit unmodified token.
             yield t
 
     # Header to add to bytecode files. This MUST be changed when
     # ``replacetoken`` or any mechanism that changes semantics of module
     # loading is changed. Otherwise cached bytecode may get loaded without
     # the new transformation mechanisms applied.
-    BYTECODEHEADER = b'HG\x00\x0b'
+    BYTECODEHEADER = b'HG\x00\x0c'
 
     class hgloader(importlib.machinery.SourceFileLoader):
         """Custom module loader that transforms source code.
 
         When the source code is converted to a code object, we transform
         certain patterns to be Python 3 compatible. This allows us to write code
         that is natively Python 2 and compatible with Python 3 without
         making the code excessively ugly.
 
         We do this by transforming the token stream between parse and compile.
 
         Implementing transformations invalidates caching assumptions made
         by the built-in importer. The built-in importer stores a header on
         saved bytecode files indicating the Python/bytecode version. If the
         version changes, the cached bytecode is ignored. The Mercurial
         transformations could change at any time. This means we need to check
         that cached bytecode was generated with the current transformation
         code or there could be a mismatch between cached bytecode and what
         would be generated from this class.
 
         We supplement the bytecode caching layer by wrapping ``get_data``
         and ``set_data``. These functions are called when the
         ``SourceFileLoader`` retrieves and saves bytecode cache files,
         respectively. We simply add an additional header on the file. As
         long as the version in this file is changed when semantics change,
         cached bytecode should be invalidated when transformations change.
 
         The added header has the form ``HG<VERSION>``. That is a literal
         ``HG`` with 2 binary bytes indicating the transformation version.
         """
         def get_data(self, path):
             data = super(hgloader, self).get_data(path)
 
             if not path.endswith(tuple(importlib.machinery.BYTECODE_SUFFIXES)):
                 return data
 
             # There should be a header indicating the Mercurial transformation
             # version. If it doesn't exist or doesn't match the current version,
             # we raise an OSError because that is what
             # ``SourceFileLoader.get_code()`` expects when loading bytecode
             # paths to indicate the cached file is "bad."
             if data[0:2] != b'HG':
                 raise OSError('no hg header')
             if data[0:4] != BYTECODEHEADER:
                 raise OSError('hg header version mismatch')
 
             return data[4:]
 
         def set_data(self, path, data, *args, **kwargs):
             if path.endswith(tuple(importlib.machinery.BYTECODE_SUFFIXES)):
                 data = BYTECODEHEADER + data
 
             return super(hgloader, self).set_data(path, data, *args, **kwargs)
 
         def source_to_code(self, data, path):
             """Perform token transformation before compilation."""
             buf = io.BytesIO(data)
             tokens = tokenize.tokenize(buf.readline)
             data = tokenize.untokenize(replacetokens(list(tokens), self.name))
             # Python's built-in importer strips frames from exceptions raised
             # for this code. Unfortunately, that mechanism isn't extensible
             # and our frame will be blamed for the import failure. There
             # are extremely hacky ways to do frame stripping. We haven't
             # implemented them because they are very ugly.
             return super(hgloader, self).source_to_code(data, path)
 
     # We automagically register our custom importer as a side-effect of
     # loading. This is necessary to ensure that any entry points are able
     # to import mercurial.* modules without having to perform this
     # registration themselves.
     if not any(isinstance(x, hgpathentryfinder) for x in sys.meta_path):
         # meta_path is used before any implicit finders and before sys.path.
         sys.meta_path.insert(0, hgpathentryfinder())

mercurial/branchmap.py

@@ -1,676 +1,678 b''
 # branchmap.py - logic to computes, maintain and stores branchmap for local repo
 #
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import struct
 
 from .node import (
     bin,
     hex,
     nullid,
     nullrev,
 )
 from . import (
     encoding,
     error,
     pycompat,
     scmutil,
     util,
 )
 from .utils import (
     repoviewutil,
     stringutil,
 )
 
 subsettable = repoviewutil. subsettable
 
 calcsize = struct.calcsize
 pack_into = struct.pack_into
 unpack_from = struct.unpack_from
 
 
 class BranchMapCache(object):
     """mapping of filtered views of repo with their branchcache"""
     def __init__(self):
         self._per_filter = {}
 
     def __getitem__(self, repo):
         self.updatecache(repo)
         return self._per_filter[repo.filtername]
 
     def updatecache(self, repo):
         """Update the cache for the given filtered view on a repository"""
         # This can trigger updates for the caches for subsets of the filtered
         # view, e.g. when there is no cache for this filtered view or the cache
         # is stale.
 
         cl = repo.changelog
         filtername = repo.filtername
         bcache = self._per_filter.get(filtername)
         if bcache is None or not bcache.validfor(repo):
             # cache object missing or cache object stale? Read from disk
             bcache = branchcache.fromfile(repo)
 
         revs = []
         if bcache is None:
             # no (fresh) cache available anymore, perhaps we can re-use
             # the cache for a subset, then extend that to add info on missing
             # revisions.
             subsetname = subsettable.get(filtername)
             if subsetname is not None:
                 subset = repo.filtered(subsetname)
                 bcache = self[subset].copy()
                 extrarevs = subset.changelog.filteredrevs - cl.filteredrevs
                 revs.extend(r for r in extrarevs if r <= bcache.tiprev)
             else:
                 # nothing to fall back on, start empty.
                 bcache = branchcache()
 
         revs.extend(cl.revs(start=bcache.tiprev + 1))
         if revs:
             bcache.update(repo, revs)
 
         assert bcache.validfor(repo), filtername
         self._per_filter[repo.filtername] = bcache
 
     def replace(self, repo, remotebranchmap):
         """Replace the branchmap cache for a repo with a branch mapping.
 
         This is likely only called during clone with a branch map from a
         remote.
 
         """
         cl = repo.changelog
         clrev = cl.rev
         clbranchinfo = cl.branchinfo
         rbheads = []
         closed = []
         for bheads in remotebranchmap.itervalues():
             rbheads += bheads
             for h in bheads:
                 r = clrev(h)
                 b, c = clbranchinfo(r)
                 if c:
                     closed.append(h)
 
         if rbheads:
             rtiprev = max((int(clrev(node)) for node in rbheads))
             cache = branchcache(
                 remotebranchmap, repo[rtiprev].node(), rtiprev,
                 closednodes=closed)
 
             # Try to stick it as low as possible
             # filter above served are unlikely to be fetch from a clone
             for candidate in ('base', 'immutable', 'served'):
                 rview = repo.filtered(candidate)
                 if cache.validfor(rview):
                     self._per_filter[candidate] = cache
                     cache.write(rview)
                     return
 
     def clear(self):
         self._per_filter.clear()
 
 def _unknownnode(node):
     """ raises ValueError when branchcache found a node which does not exists
     """
     raise ValueError(r'node %s does not exist' % pycompat.sysstr(hex(node)))
 
 def _branchcachedesc(repo):
     if repo.filtername is not None:
         return 'branch cache (%s)' % repo.filtername
     else:
         return 'branch cache'
 
 class branchcache(object):
     """A dict like object that hold branches heads cache.
 
     This cache is used to avoid costly computations to determine all the
     branch heads of a repo.
 
     The cache is serialized on disk in the following format:
 
     <tip hex node> <tip rev number> [optional filtered repo hex hash]
     <branch head hex node> <open/closed state> <branch name>
     <branch head hex node> <open/closed state> <branch name>
     ...
 
     The first line is used to check if the cache is still valid. If the
     branch cache is for a filtered repo view, an optional third hash is
     included that hashes the hashes of all filtered revisions.
 
     The open/closed state is represented by a single letter 'o' or 'c'.
     This field can be used to avoid changelog reads when determining if a
     branch head closes a branch or not.
     """
 
     def __init__(self, entries=(), tipnode=nullid, tiprev=nullrev,
                  filteredhash=None, closednodes=None, hasnode=None):
         """ hasnode is a function which can be used to verify whether changelog
         has a given node or not. If it's not provided, we assume that every node
         we have exists in changelog """
         self.tipnode = tipnode
         self.tiprev = tiprev
         self.filteredhash = filteredhash
         # closednodes is a set of nodes that close their branch. If the branch
         # cache has been updated, it may contain nodes that are no longer
         # heads.
         if closednodes is None:
             self._closednodes = set()
         else:
             self._closednodes = closednodes
         self._entries = dict(entries)
         # whether closed nodes are verified or not
         self._closedverified = False
         # branches for which nodes are verified
         self._verifiedbranches = set()
         self._hasnode = hasnode
         if self._hasnode is None:
             self._hasnode = lambda x: True
 
     def _verifyclosed(self):
         """ verify the closed nodes we have """
         if self._closedverified:
             return
         for node in self._closednodes:
             if not self._hasnode(node):
                 _unknownnode(node)
 
         self._closedverified = True
 
     def _verifybranch(self, branch):
         """ verify head nodes for the given branch. """
         if branch not in self._entries or branch in self._verifiedbranches:
             return
         for n in self._entries[branch]:
             if not self._hasnode(n):
                 _unknownnode(n)
 
         self._verifiedbranches.add(branch)
 
     def _verifyall(self):
         """ verifies nodes of all the branches """
         needverification = set(self._entries.keys()) - self._verifiedbranches
         for b in needverification:
             self._verifybranch(b)
 
     def __iter__(self):
         return iter(self._entries)
 
     def __setitem__(self, key, value):
         self._entries[key] = value
 
     def __getitem__(self, key):
         self._verifybranch(key)
         return self._entries[key]
 
     def __contains__(self, key):
         self._verifybranch(key)
         return key in self._entries
 
     def iteritems(self):
         for k, v in self._entries.iteritems():
             self._verifybranch(k)
             yield k, v
 
+    items = iteritems
+
     def hasbranch(self, label):
         """ checks whether a branch of this name exists or not """
         self._verifybranch(label)
         return label in self._entries
 
     @classmethod
     def fromfile(cls, repo):
         f = None
         try:
             f = repo.cachevfs(cls._filename(repo))
             lineiter = iter(f)
             cachekey = next(lineiter).rstrip('\n').split(" ", 2)
             last, lrev = cachekey[:2]
             last, lrev = bin(last), int(lrev)
             filteredhash = None
             hasnode = repo.changelog.hasnode
             if len(cachekey) > 2:
                 filteredhash = bin(cachekey[2])
             bcache = cls(tipnode=last, tiprev=lrev, filteredhash=filteredhash,
                          hasnode=hasnode)
             if not bcache.validfor(repo):
                 # invalidate the cache
                 raise ValueError(r'tip differs')
             bcache.load(repo, lineiter)
         except (IOError, OSError):
             return None
 
         except Exception as inst:
             if repo.ui.debugflag:
                 msg = 'invalid %s: %s\n'
                 repo.ui.debug(msg % (_branchcachedesc(repo),
                                      pycompat.bytestr(inst)))
             bcache = None
 
         finally:
             if f:
                 f.close()
 
         return bcache
 
     def load(self, repo, lineiter):
         """ fully loads the branchcache by reading from the file using the line
         iterator passed"""
         for line in lineiter:
             line = line.rstrip('\n')
             if not line:
                 continue
             node, state, label = line.split(" ", 2)
             if state not in 'oc':
                 raise ValueError(r'invalid branch state')
             label = encoding.tolocal(label.strip())
             node = bin(node)
             self._entries.setdefault(label, []).append(node)
             if state == 'c':
                 self._closednodes.add(node)
 
     @staticmethod
     def _filename(repo):
         """name of a branchcache file for a given repo or repoview"""
         filename = "branch2"
         if repo.filtername:
             filename = '%s-%s' % (filename, repo.filtername)
         return filename
 
     def validfor(self, repo):
         """Is the cache content valid regarding a repo
 
         - False when cached tipnode is unknown or if we detect a strip.
         - True when cache is up to date or a subset of current repo."""
         try:
             return ((self.tipnode == repo.changelog.node(self.tiprev))
                     and (self.filteredhash ==
                          scmutil.filteredhash(repo, self.tiprev)))
         except IndexError:
             return False
 
     def _branchtip(self, heads):
         '''Return tuple with last open head in heads and false,
         otherwise return last closed head and true.'''
         tip = heads[-1]
         closed = True
         for h in reversed(heads):
             if h not in self._closednodes:
                 tip = h
                 closed = False
                 break
         return tip, closed
 
     def branchtip(self, branch):
         '''Return the tipmost open head on branch head, otherwise return the
         tipmost closed head on branch.
         Raise KeyError for unknown branch.'''
         return self._branchtip(self[branch])[0]
 
     def iteropen(self, nodes):
         return (n for n in nodes if n not in self._closednodes)
 
     def branchheads(self, branch, closed=False):
         self._verifybranch(branch)
         heads = self._entries[branch]
         if not closed:
             heads = list(self.iteropen(heads))
         return heads
 
     def iterbranches(self):
         for bn, heads in self.iteritems():
             yield (bn, heads) + self._branchtip(heads)
 
     def iterheads(self):
         """ returns all the heads """
         self._verifyall()
         return self._entries.itervalues()
 
     def copy(self):
         """return an deep copy of the branchcache object"""
         return type(self)(
             self._entries, self.tipnode, self.tiprev, self.filteredhash,
             self._closednodes)
 
     def write(self, repo):
         try:
             f = repo.cachevfs(self._filename(repo), "w", atomictemp=True)
             cachekey = [hex(self.tipnode), '%d' % self.tiprev]
             if self.filteredhash is not None:
                 cachekey.append(hex(self.filteredhash))
             f.write(" ".join(cachekey) + '\n')
             nodecount = 0
             for label, nodes in sorted(self._entries.iteritems()):
                 label = encoding.fromlocal(label)
                 for node in nodes:
                     nodecount += 1
                     if node in self._closednodes:
                         state = 'c'
                     else:
                         state = 'o'
                     f.write("%s %s %s\n" % (hex(node), state, label))
             f.close()
             repo.ui.log('branchcache', 'wrote %s with %d labels and %d nodes\n',
                         _branchcachedesc(repo), len(self._entries), nodecount)
         except (IOError, OSError, error.Abort) as inst:
             # Abort may be raised by read only opener, so log and continue
             repo.ui.debug("couldn't write branch cache: %s\n" %
                           stringutil.forcebytestr(inst))
 
     def update(self, repo, revgen):
         """Given a branchhead cache, self, that may have extra nodes or be
         missing heads, and a generator of nodes that are strictly a superset of
         heads missing, this function updates self to be correct.
         """
         starttime = util.timer()
         cl = repo.changelog
         # collect new branch entries
         newbranches = {}
         getbranchinfo = repo.revbranchcache().branchinfo
         for r in revgen:
             branch, closesbranch = getbranchinfo(r)
             newbranches.setdefault(branch, []).append(r)
             if closesbranch:
                 self._closednodes.add(cl.node(r))
 
         # fetch current topological heads to speed up filtering
         topoheads = set(cl.headrevs())
 
         # new tip revision which we found after iterating items from new
         # branches
         ntiprev = self.tiprev
 
         # if older branchheads are reachable from new ones, they aren't
         # really branchheads. Note checking parents is insufficient:
         # 1 (branch a) -> 2 (branch b) -> 3 (branch a)
         for branch, newheadrevs in newbranches.iteritems():
             bheads = self._entries.setdefault(branch, [])
             bheadset = set(cl.rev(node) for node in bheads)
 
             # This have been tested True on all internal usage of this function.
             # run it again in case of doubt
             # assert not (set(bheadrevs) & set(newheadrevs))
             bheadset.update(newheadrevs)
 
             # This prunes out two kinds of heads - heads that are superseded by
             # a head in newheadrevs, and newheadrevs that are not heads because
             # an existing head is their descendant.
             uncertain = bheadset - topoheads
             if uncertain:
                 floorrev = min(uncertain)
                 ancestors = set(cl.ancestors(newheadrevs, floorrev))
                 bheadset -= ancestors
             bheadrevs = sorted(bheadset)
             self[branch] = [cl.node(rev) for rev in bheadrevs]
             tiprev = bheadrevs[-1]
             if tiprev > ntiprev:
                 ntiprev = tiprev
 
         if ntiprev > self.tiprev:
             self.tiprev = ntiprev
             self.tipnode = cl.node(ntiprev)
 
         if not self.validfor(repo):
             # cache key are not valid anymore
             self.tipnode = nullid
             self.tiprev = nullrev
             for heads in self.iterheads():
                 tiprev = max(cl.rev(node) for node in heads)
                 if tiprev > self.tiprev:
                     self.tipnode = cl.node(tiprev)
                     self.tiprev = tiprev
         self.filteredhash = scmutil.filteredhash(repo, self.tiprev)
 
         duration = util.timer() - starttime
         repo.ui.log('branchcache', 'updated %s in %.4f seconds\n',
                     _branchcachedesc(repo), duration)
 
         self.write(repo)
 
 
 class remotebranchcache(branchcache):
     """Branchmap info for a remote connection, should not write locally"""
     def write(self, repo):
         pass
 
 
 # Revision branch info cache
 
 _rbcversion = '-v1'
 _rbcnames = 'rbc-names' + _rbcversion
 _rbcrevs = 'rbc-revs' + _rbcversion
 # [4 byte hash prefix][4 byte branch name number with sign bit indicating open]
 _rbcrecfmt = '>4sI'
 _rbcrecsize = calcsize(_rbcrecfmt)
 _rbcnodelen = 4
 _rbcbranchidxmask = 0x7fffffff
 _rbccloseflag = 0x80000000
 
 class revbranchcache(object):
     """Persistent cache, mapping from revision number to branch name and close.
     This is a low level cache, independent of filtering.
 
     Branch names are stored in rbc-names in internal encoding separated by 0.
     rbc-names is append-only, and each branch name is only stored once and will
     thus have a unique index.
 
     The branch info for each revision is stored in rbc-revs as constant size
     records. The whole file is read into memory, but it is only 'parsed' on
     demand. The file is usually append-only but will be truncated if repo
     modification is detected.
     The record for each revision contains the first 4 bytes of the
     corresponding node hash, and the record is only used if it still matches.
     Even a completely trashed rbc-revs fill thus still give the right result
     while converging towards full recovery ... assuming no incorrectly matching
     node hashes.
     The record also contains 4 bytes where 31 bits contains the index of the
     branch and the last bit indicate that it is a branch close commit.
     The usage pattern for rbc-revs is thus somewhat similar to 00changelog.i
     and will grow with it but be 1/8th of its size.
     """
 
     def __init__(self, repo, readonly=True):
         assert repo.filtername is None
         self._repo = repo
         self._names = [] # branch names in local encoding with static index
         self._rbcrevs = bytearray()
         self._rbcsnameslen = 0 # length of names read at _rbcsnameslen
         try:
             bndata = repo.cachevfs.read(_rbcnames)
             self._rbcsnameslen = len(bndata) # for verification before writing
             if bndata:
                 self._names = [encoding.tolocal(bn)
                                for bn in bndata.split('\0')]
         except (IOError, OSError):
             if readonly:
                 # don't try to use cache - fall back to the slow path
                 self.branchinfo = self._branchinfo
 
         if self._names:
             try:
                 data = repo.cachevfs.read(_rbcrevs)
                 self._rbcrevs[:] = data
             except (IOError, OSError) as inst:
                 repo.ui.debug("couldn't read revision branch cache: %s\n" %
                               stringutil.forcebytestr(inst))
         # remember number of good records on disk
         self._rbcrevslen = min(len(self._rbcrevs) // _rbcrecsize,
                                len(repo.changelog))
         if self._rbcrevslen == 0:
             self._names = []
         self._rbcnamescount = len(self._names) # number of names read at
                                                # _rbcsnameslen
 
     def _clear(self):
         self._rbcsnameslen = 0
         del self._names[:]
         self._rbcnamescount = 0
         self._rbcrevslen = len(self._repo.changelog)
         self._rbcrevs = bytearray(self._rbcrevslen * _rbcrecsize)
         util.clearcachedproperty(self, '_namesreverse')
 
     @util.propertycache
     def _namesreverse(self):
         return dict((b, r) for r, b in enumerate(self._names))
 
     def branchinfo(self, rev):
         """Return branch name and close flag for rev, using and updating
         persistent cache."""
         changelog = self._repo.changelog
         rbcrevidx = rev * _rbcrecsize
 
         # avoid negative index, changelog.read(nullrev) is fast without cache
         if rev == nullrev:
             return changelog.branchinfo(rev)
 
         # if requested rev isn't allocated, grow and cache the rev info
         if len(self._rbcrevs) < rbcrevidx + _rbcrecsize:
             return self._branchinfo(rev)
 
         # fast path: extract data from cache, use it if node is matching
         reponode = changelog.node(rev)[:_rbcnodelen]
         cachenode, branchidx = unpack_from(
             _rbcrecfmt, util.buffer(self._rbcrevs), rbcrevidx)
         close = bool(branchidx & _rbccloseflag)
         if close:
             branchidx &= _rbcbranchidxmask
         if cachenode == '\0\0\0\0':
             pass
         elif cachenode == reponode:
             try:
                 return self._names[branchidx], close
             except IndexError:
                 # recover from invalid reference to unknown branch
                 self._repo.ui.debug("referenced branch names not found"
                     " - rebuilding revision branch cache from scratch\n")
                 self._clear()
         else:
             # rev/node map has changed, invalidate the cache from here up
             self._repo.ui.debug("history modification detected - truncating "
                 "revision branch cache to revision %d\n" % rev)
             truncate = rbcrevidx + _rbcrecsize
             del self._rbcrevs[truncate:]
             self._rbcrevslen = min(self._rbcrevslen, truncate)
 
         # fall back to slow path and make sure it will be written to disk
         return self._branchinfo(rev)
 
     def _branchinfo(self, rev):
         """Retrieve branch info from changelog and update _rbcrevs"""
         changelog = self._repo.changelog
         b, close = changelog.branchinfo(rev)
         if b in self._namesreverse:
             branchidx = self._namesreverse[b]
         else:
             branchidx = len(self._names)
             self._names.append(b)
             self._namesreverse[b] = branchidx
         reponode = changelog.node(rev)
         if close:
             branchidx |= _rbccloseflag
         self._setcachedata(rev, reponode, branchidx)
         return b, close
 
     def setdata(self, branch, rev, node, close):
         """add new data information to the cache"""
         if branch in self._namesreverse:
             branchidx = self._namesreverse[branch]
         else:
             branchidx = len(self._names)
             self._names.append(branch)
             self._namesreverse[branch] = branchidx
         if close:
             branchidx |= _rbccloseflag
         self._setcachedata(rev, node, branchidx)
         # If no cache data were readable (non exists, bad permission, etc)
         # the cache was bypassing itself by setting:
         #
         #   self.branchinfo = self._branchinfo
         #
         # Since we now have data in the cache, we need to drop this bypassing.
         if r'branchinfo' in vars(self):
             del self.branchinfo
 
     def _setcachedata(self, rev, node, branchidx):
         """Writes the node's branch data to the in-memory cache data."""
         if rev == nullrev:
             return
         rbcrevidx = rev * _rbcrecsize
         if len(self._rbcrevs) < rbcrevidx + _rbcrecsize:
             self._rbcrevs.extend('\0' *
                                  (len(self._repo.changelog) * _rbcrecsize -
                                   len(self._rbcrevs)))
         pack_into(_rbcrecfmt, self._rbcrevs, rbcrevidx, node, branchidx)
         self._rbcrevslen = min(self._rbcrevslen, rev)
 
         tr = self._repo.currenttransaction()
         if tr:
             tr.addfinalize('write-revbranchcache', self.write)
 
     def write(self, tr=None):
         """Save branch cache if it is dirty."""
         repo = self._repo
         wlock = None
         step = ''
         try:
             # write the new names
             if self._rbcnamescount < len(self._names):
                 wlock = repo.wlock(wait=False)
                 step = ' names'
                 self._writenames(repo)
 
             # write the new revs
             start = self._rbcrevslen * _rbcrecsize
             if start != len(self._rbcrevs):
                 step = ''
                 if wlock is None:
                     wlock = repo.wlock(wait=False)
                 self._writerevs(repo, start)
 
         except (IOError, OSError, error.Abort, error.LockError) as inst:
             repo.ui.debug("couldn't write revision branch cache%s: %s\n"
                           % (step, stringutil.forcebytestr(inst)))
         finally:
             if wlock is not None:
                 wlock.release()
 
     def _writenames(self, repo):
         """ write the new branch names to revbranchcache """
         if self._rbcnamescount != 0:
             f = repo.cachevfs.open(_rbcnames, 'ab')
             if f.tell() == self._rbcsnameslen:
                 f.write('\0')
             else:
                 f.close()
                 repo.ui.debug("%s changed - rewriting it\n" % _rbcnames)
                 self._rbcnamescount = 0
                 self._rbcrevslen = 0
         if self._rbcnamescount == 0:
             # before rewriting names, make sure references are removed
             repo.cachevfs.unlinkpath(_rbcrevs, ignoremissing=True)
             f = repo.cachevfs.open(_rbcnames, 'wb')
         f.write('\0'.join(encoding.fromlocal(b)
                           for b in self._names[self._rbcnamescount:]))
         self._rbcsnameslen = f.tell()
         f.close()
         self._rbcnamescount = len(self._names)
 
     def _writerevs(self, repo, start):
         """ write the new revs to revbranchcache """
         revs = min(len(repo.changelog), len(self._rbcrevs) // _rbcrecsize)
         with repo.cachevfs.open(_rbcrevs, 'ab') as f:
             if f.tell() != start:
                 repo.ui.debug("truncating cache/%s to %d\n" % (_rbcrevs, start))
                 f.seek(start)
                 if f.tell() != start:
                     start = 0
                     f.seek(start)
                 f.truncate()
             end = revs * _rbcrecsize
             f.write(self._rbcrevs[start:end])
         self._rbcrevslen = revs