convert: stringify `shlex` class argument

The documentation is handwavy, but typeshed says this should be `str`[1].  I'm
not sure if this is the correct encoding (vs `fsencode` or "latin1" like the
tokens returned by the proxy class).

While we're here, we can add a few more type hints that would have caused pytype
to flag the problem.

[1] https://github.com/python/typeshed/blob/6a9b53e719a139c2d6b41cf265ed0990cf438192/stdlib/shlex.pyi#L51

hgext/convert/common.py

@@ -1,612 +1,615
 # common.py - common code for the convert extension
 #
 #  Copyright 2005-2009 Olivia Mackall <[e-mail]> and others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 import base64
 import os
 import pickle
 import re
 import shlex
 import subprocess
 import typing
 
 from typing import (
     Any,
     AnyStr,
     Optional,
 )
 
 from mercurial.i18n import _
 from mercurial.pycompat import open
 from mercurial import (
     encoding,
     error,
     phases,
     pycompat,
     util,
 )
 from mercurial.utils import (
     dateutil,
     procutil,
 )
 
 if typing.TYPE_CHECKING:
     from typing import (
         overload,
     )
     from mercurial import (
         ui as uimod,
     )
 
 propertycache = util.propertycache
 
 
 if typing.TYPE_CHECKING:
 
     @overload
     def _encodeornone(d: str) -> bytes:
         pass
 
     @overload
     def _encodeornone(d: None) -> None:
         pass
 
 
 def _encodeornone(d):
     if d is None:
         return
     return d.encode('latin1')
 
 
 class _shlexpy3proxy:
     def __init__(self, l: shlex.shlex) -> None:
         self._l = l
 
     def __iter__(self):
         return (_encodeornone(v) for v in self._l)
 
     def get_token(self):
         return _encodeornone(self._l.get_token())
 
     @property
-    def infile(self):
-        return self._l.infile or b'<unknown>'
+    def infile(self) -> bytes:
+        if self._l.infile is not None:
+            return encoding.strtolocal(self._l.infile)
+        return b'<unknown>'
 
     @property
     def lineno(self) -> int:
         return self._l.lineno
 
 
 def shlexer(
     data=None,
-    filepath: Optional[str] = None,
+    filepath: Optional[bytes] = None,
     wordchars: Optional[bytes] = None,
     whitespace: Optional[bytes] = None,
 ):
     if data is None:
         data = open(filepath, b'r', encoding='latin1')
     else:
         if filepath is not None:
             raise error.ProgrammingError(
                 b'shlexer only accepts data or filepath, not both'
             )
         data = data.decode('latin1')
-    l = shlex.shlex(data, infile=filepath, posix=True)
+    infile = encoding.strfromlocal(filepath) if filepath is not None else None
+    l = shlex.shlex(data, infile=infile, posix=True)
     if whitespace is not None:
         l.whitespace_split = True
         l.whitespace += whitespace.decode('latin1')
     if wordchars is not None:
         l.wordchars += wordchars.decode('latin1')
     return _shlexpy3proxy(l)
 
 
 def encodeargs(args: Any) -> bytes:
     def encodearg(s: bytes) -> bytes:
         lines = base64.encodebytes(s)
         lines = [l.splitlines()[0] for l in pycompat.iterbytestr(lines)]
         return b''.join(lines)
 
     s = pickle.dumps(args)
     return encodearg(s)
 
 
 def decodeargs(s: bytes) -> Any:
     s = base64.decodebytes(s)
     return pickle.loads(s)
 
 
 class MissingTool(Exception):
     pass
 
 
 def checktool(
     exe: bytes, name: Optional[bytes] = None, abort: bool = True
 ) -> None:
     name = name or exe
     if not procutil.findexe(exe):
         if abort:
             exc = error.Abort
         else:
             exc = MissingTool
         raise exc(_(b'cannot find required "%s" tool') % name)
 
 
 class NoRepo(Exception):
     pass
 
 
 SKIPREV: bytes = b'SKIP'
 
 
 class commit:
     def __init__(
         self,
         author: bytes,
         date: bytes,
         desc: bytes,
         parents,
         branch: Optional[bytes] = None,
         rev=None,
         extra=None,
         sortkey=None,
         saverev=True,
         phase: int = phases.draft,
         optparents=None,
         ctx=None,
     ) -> None:
         self.author = author or b'unknown'
         self.date = date or b'0 0'
         self.desc = desc
         self.parents = parents  # will be converted and used as parents
         self.optparents = optparents or []  # will be used if already converted
         self.branch = branch
         self.rev = rev
         self.extra = extra or {}
         self.sortkey = sortkey
         self.saverev = saverev
         self.phase = phase
         self.ctx = ctx  # for hg to hg conversions
 
 
 class converter_source:
     """Conversion source interface"""
 
     def __init__(
         self,
         ui: "uimod.ui",
         repotype: bytes,
         path: Optional[bytes] = None,
         revs=None,
     ) -> None:
         """Initialize conversion source (or raise NoRepo("message")
         exception if path is not a valid repository)"""
         self.ui = ui
         self.path = path
         self.revs = revs
         self.repotype = repotype
 
         self.encoding = b'utf-8'
 
     def checkhexformat(
         self, revstr: bytes, mapname: bytes = b'splicemap'
     ) -> None:
         """fails if revstr is not a 40 byte hex. mercurial and git both uses
         such format for their revision numbering
         """
         if not re.match(br'[0-9a-fA-F]{40,40}$', revstr):
             raise error.Abort(
                 _(b'%s entry %s is not a valid revision identifier')
                 % (mapname, revstr)
             )
 
     def before(self) -> None:
         pass
 
     def after(self) -> None:
         pass
 
     def targetfilebelongstosource(self, targetfilename):
         """Returns true if the given targetfile belongs to the source repo. This
         is useful when only a subdirectory of the target belongs to the source
         repo."""
         # For normal full repo converts, this is always True.
         return True
 
     def setrevmap(self, revmap):
         """set the map of already-converted revisions"""
 
     def getheads(self):
         """Return a list of this repository's heads"""
         raise NotImplementedError
 
     def getfile(self, name, rev):
         """Return a pair (data, mode) where data is the file content
         as a string and mode one of '', 'x' or 'l'. rev is the
         identifier returned by a previous call to getchanges().
         Data is None if file is missing/deleted in rev.
         """
         raise NotImplementedError
 
     def getchanges(self, version, full):
         """Returns a tuple of (files, copies, cleanp2).
 
         files is a sorted list of (filename, id) tuples for all files
         changed between version and its first parent returned by
         getcommit(). If full, all files in that revision is returned.
         id is the source revision id of the file.
 
         copies is a dictionary of dest: source
 
         cleanp2 is the set of files filenames that are clean against p2.
         (Files that are clean against p1 are already not in files (unless
         full). This makes it possible to handle p2 clean files similarly.)
         """
         raise NotImplementedError
 
     def getcommit(self, version):
         """Return the commit object for version"""
         raise NotImplementedError
 
     def numcommits(self):
         """Return the number of commits in this source.
 
         If unknown, return None.
         """
         return None
 
     def gettags(self):
         """Return the tags as a dictionary of name: revision
 
         Tag names must be UTF-8 strings.
         """
         raise NotImplementedError
 
     def recode(self, s: AnyStr, encoding: Optional[bytes] = None) -> bytes:
         if not encoding:
             encoding = self.encoding or b'utf-8'
 
         if isinstance(s, str):
             return s.encode("utf-8")
         try:
             return s.decode(pycompat.sysstr(encoding)).encode("utf-8")
         except UnicodeError:
             try:
                 return s.decode("latin-1").encode("utf-8")
             except UnicodeError:
                 return s.decode(pycompat.sysstr(encoding), "replace").encode(
                     "utf-8"
                 )
 
     def getchangedfiles(self, rev, i):
         """Return the files changed by rev compared to parent[i].
 
         i is an index selecting one of the parents of rev.  The return
         value should be the list of files that are different in rev and
         this parent.
 
         If rev has no parents, i is None.
 
         This function is only needed to support --filemap
         """
         raise NotImplementedError
 
     def converted(self, rev, sinkrev) -> None:
         '''Notify the source that a revision has been converted.'''
 
     def hasnativeorder(self) -> bool:
         """Return true if this source has a meaningful, native revision
         order. For instance, Mercurial revisions are store sequentially
         while there is no such global ordering with Darcs.
         """
         return False
 
     def hasnativeclose(self) -> bool:
         """Return true if this source has ability to close branch."""
         return False
 
     def lookuprev(self, rev):
         """If rev is a meaningful revision reference in source, return
         the referenced identifier in the same format used by getcommit().
         return None otherwise.
         """
         return None
 
     def getbookmarks(self):
         """Return the bookmarks as a dictionary of name: revision
 
         Bookmark names are to be UTF-8 strings.
         """
         return {}
 
     def checkrevformat(self, revstr, mapname: bytes = b'splicemap') -> bool:
         """revstr is a string that describes a revision in the given
         source control system.  Return true if revstr has correct
         format.
         """
         return True
 
 
 class converter_sink:
     """Conversion sink (target) interface"""
 
     def __init__(self, ui: "uimod.ui", repotype: bytes, path: bytes) -> None:
         """Initialize conversion sink (or raise NoRepo("message")
         exception if path is not a valid repository)
 
         created is a list of paths to remove if a fatal error occurs
         later"""
         self.ui = ui
         self.path = path
         self.created = []
         self.repotype = repotype
 
     def revmapfile(self):
         """Path to a file that will contain lines
         source_rev_id sink_rev_id
         mapping equivalent revision identifiers for each system."""
         raise NotImplementedError
 
     def authorfile(self):
         """Path to a file that will contain lines
         srcauthor=dstauthor
         mapping equivalent authors identifiers for each system."""
         return None
 
     def putcommit(
         self, files, copies, parents, commit, source, revmap, full, cleanp2
     ):
         """Create a revision with all changed files listed in 'files'
         and having listed parents. 'commit' is a commit object
         containing at a minimum the author, date, and message for this
         changeset.  'files' is a list of (path, version) tuples,
         'copies' is a dictionary mapping destinations to sources,
         'source' is the source repository, and 'revmap' is a mapfile
         of source revisions to converted revisions. Only getfile() and
         lookuprev() should be called on 'source'. 'full' means that 'files'
         is complete and all other files should be removed.
         'cleanp2' is a set of the filenames that are unchanged from p2
         (only in the common merge case where there two parents).
 
         Note that the sink repository is not told to update itself to
         a particular revision (or even what that revision would be)
         before it receives the file data.
         """
         raise NotImplementedError
 
     def puttags(self, tags):
         """Put tags into sink.
 
         tags: {tagname: sink_rev_id, ...} where tagname is an UTF-8 string.
         Return a pair (tag_revision, tag_parent_revision), or (None, None)
         if nothing was changed.
         """
         raise NotImplementedError
 
     def setbranch(self, branch, pbranches):
         """Set the current branch name. Called before the first putcommit
         on the branch.
         branch: branch name for subsequent commits
         pbranches: (converted parent revision, parent branch) tuples"""
 
     def setfilemapmode(self, active):
         """Tell the destination that we're using a filemap
 
         Some converter_sources (svn in particular) can claim that a file
         was changed in a revision, even if there was no change.  This method
         tells the destination that we're using a filemap and that it should
         filter empty revisions.
         """
 
     def before(self) -> None:
         pass
 
     def after(self) -> None:
         pass
 
     def putbookmarks(self, bookmarks):
         """Put bookmarks into sink.
 
         bookmarks: {bookmarkname: sink_rev_id, ...}
         where bookmarkname is an UTF-8 string.
         """
 
     def hascommitfrommap(self, rev):
         """Return False if a rev mentioned in a filemap is known to not be
         present."""
         raise NotImplementedError
 
     def hascommitforsplicemap(self, rev):
         """This method is for the special needs for splicemap handling and not
         for general use. Returns True if the sink contains rev, aborts on some
         special cases."""
         raise NotImplementedError
 
 
 class commandline:
     def __init__(self, ui: "uimod.ui", command: bytes) -> None:
         self.ui = ui
         self.command = command
 
     def prerun(self) -> None:
         pass
 
     def postrun(self) -> None:
         pass
 
     def _cmdline(self, cmd: bytes, *args: bytes, **kwargs) -> bytes:
         kwargs = pycompat.byteskwargs(kwargs)
         cmdline = [self.command, cmd] + list(args)
         for k, v in kwargs.items():
             if len(k) == 1:
                 cmdline.append(b'-' + k)
             else:
                 cmdline.append(b'--' + k.replace(b'_', b'-'))
             try:
                 if len(k) == 1:
                     cmdline.append(b'' + v)
                 else:
                     cmdline[-1] += b'=' + v
             except TypeError:
                 pass
         cmdline = [procutil.shellquote(arg) for arg in cmdline]
         if not self.ui.debugflag:
             cmdline += [b'2>', pycompat.bytestr(os.devnull)]
         cmdline = b' '.join(cmdline)
         return cmdline
 
     def _run(self, cmd: bytes, *args: bytes, **kwargs):
         def popen(cmdline):
             p = subprocess.Popen(
                 procutil.tonativestr(cmdline),
                 shell=True,
                 bufsize=-1,
                 close_fds=procutil.closefds,
                 stdout=subprocess.PIPE,
             )
             return p
 
         return self._dorun(popen, cmd, *args, **kwargs)
 
     def _run2(self, cmd: bytes, *args: bytes, **kwargs):
         return self._dorun(procutil.popen2, cmd, *args, **kwargs)
 
     def _run3(self, cmd: bytes, *args: bytes, **kwargs):
         return self._dorun(procutil.popen3, cmd, *args, **kwargs)
 
     def _dorun(self, openfunc, cmd: bytes, *args: bytes, **kwargs):
         cmdline = self._cmdline(cmd, *args, **kwargs)
         self.ui.debug(b'running: %s\n' % (cmdline,))
         self.prerun()
         try:
             return openfunc(cmdline)
         finally:
             self.postrun()
 
     def run(self, cmd: bytes, *args: bytes, **kwargs):
         p = self._run(cmd, *args, **kwargs)
         output = p.communicate()[0]
         self.ui.debug(output)
         return output, p.returncode
 
     def runlines(self, cmd: bytes, *args: bytes, **kwargs):
         p = self._run(cmd, *args, **kwargs)
         output = p.stdout.readlines()
         p.wait()
         self.ui.debug(b''.join(output))
         return output, p.returncode
 
     def checkexit(self, status, output: bytes = b'') -> None:
         if status:
             if output:
                 self.ui.warn(_(b'%s error:\n') % self.command)
                 self.ui.warn(output)
             msg = procutil.explainexit(status)
             raise error.Abort(b'%s %s' % (self.command, msg))
 
     def run0(self, cmd: bytes, *args: bytes, **kwargs):
         output, status = self.run(cmd, *args, **kwargs)
         self.checkexit(status, output)
         return output
 
     def runlines0(self, cmd: bytes, *args: bytes, **kwargs):
         output, status = self.runlines(cmd, *args, **kwargs)
         self.checkexit(status, b''.join(output))
         return output
 
     @propertycache
     def argmax(self):
         # POSIX requires at least 4096 bytes for ARG_MAX
         argmax = 4096
         try:
             argmax = os.sysconf("SC_ARG_MAX")
         except (AttributeError, ValueError):
             pass
 
         # Windows shells impose their own limits on command line length,
         # down to 2047 bytes for cmd.exe under Windows NT/2k and 2500 bytes
         # for older 4nt.exe. See http://support.microsoft.com/kb/830473 for
         # details about cmd.exe limitations.
 
         # Since ARG_MAX is for command line _and_ environment, lower our limit
         # (and make happy Windows shells while doing this).
         return argmax // 2 - 1
 
     def _limit_arglist(self, arglist, cmd: bytes, *args: bytes, **kwargs):
         cmdlen = len(self._cmdline(cmd, *args, **kwargs))
         limit = self.argmax - cmdlen
         numbytes = 0
         fl = []
         for fn in arglist:
             b = len(fn) + 3
             if numbytes + b < limit or len(fl) == 0:
                 fl.append(fn)
                 numbytes += b
             else:
                 yield fl
                 fl = [fn]
                 numbytes = b
         if fl:
             yield fl
 
     def xargs(self, arglist, cmd: bytes, *args: bytes, **kwargs):
         for l in self._limit_arglist(arglist, cmd, *args, **kwargs):
             self.run0(cmd, *(list(args) + l), **kwargs)
 
 
 class mapfile(dict):
     def __init__(self, ui: "uimod.ui", path: bytes) -> None:
         super(mapfile, self).__init__()
         self.ui = ui
         self.path = path
         self.fp = None
         self.order = []
         self._read()
 
     def _read(self) -> None:
         if not self.path:
             return
         try:
             fp = open(self.path, b'rb')
         except FileNotFoundError:
             return
         for i, line in enumerate(fp):
             line = line.splitlines()[0].rstrip()
             if not line:
                 # Ignore blank lines
                 continue
             try:
                 key, value = line.rsplit(b' ', 1)
             except ValueError:
                 raise error.Abort(
                     _(b'syntax error in %s(%d): key/value pair expected')
                     % (self.path, i + 1)
                 )
             if key not in self:
                 self.order.append(key)
             super(mapfile, self).__setitem__(key, value)
         fp.close()
 
     def __setitem__(self, key, value) -> None:
         if self.fp is None:
             try:
                 self.fp = open(self.path, b'ab')
             except IOError as err:
                 raise error.Abort(
                     _(b'could not open map file %r: %s')
                     % (self.path, encoding.strtolocal(err.strerror))
                 )
         self.fp.write(util.tonativeeol(b'%s %s\n' % (key, value)))
         self.fp.flush()
         super(mapfile, self).__setitem__(key, value)
 
     def close(self) -> None:
         if self.fp:
             self.fp.close()
             self.fp = None
 
 
 def makedatetimestamp(t: float) -> dateutil.hgdate:
     return dateutil.makedate(t)

hgext/convert/filemap.py

@@ -1,530 +1,531
 # Copyright 2007 Bryan O'Sullivan <[e-mail]>
 # Copyright 2007 Alexis S. L. Carvalho <[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.
 
 
 import posixpath
 import typing
 
 from typing import (
     Iterator,
     Mapping,
     MutableMapping,
     Optional,
     Set,
     Tuple,
     overload,
 )
 
 from mercurial.i18n import _
 from mercurial import (
     error,
     pycompat,
 )
 from . import common
 
 if typing.TYPE_CHECKING:
     from mercurial import (
         ui as uimod,
     )
 
 SKIPREV = common.SKIPREV
 
 
 def rpairs(path: bytes) -> Iterator[Tuple[bytes, bytes]]:
     """Yield tuples with path split at '/', starting with the full path.
     No leading, trailing or double '/', please.
     >>> for x in rpairs(b'foo/bar/baz'): print(x)
     ('foo/bar/baz', '')
     ('foo/bar', 'baz')
     ('foo', 'bar/baz')
     ('.', 'foo/bar/baz')
     """
     i = len(path)
     while i != -1:
         yield path[:i], path[i + 1 :]
         i = path.rfind(b'/', 0, i)
     yield b'.', path
 
 
 if typing.TYPE_CHECKING:
 
     @overload
     def normalize(path: bytes) -> bytes:
         pass
 
     @overload
     def normalize(path: None) -> None:
         pass
 
 
 def normalize(path):
     """We use posixpath.normpath to support cross-platform path format.
     However, it doesn't handle None input. So we wrap it up."""
     if path is None:
         return None
     return posixpath.normpath(path)
 
 
 class filemapper:
     """Map and filter filenames when importing.
     A name can be mapped to itself, a new name, or None (omit from new
     repository)."""
 
     rename: MutableMapping[bytes, bytes]
     targetprefixes: Optional[Set[bytes]]
 
-    def __init__(self, ui: "uimod.ui", path=None) -> None:
+    def __init__(self, ui: "uimod.ui", path: Optional[bytes] = None) -> None:
         self.ui = ui
         self.include = {}
         self.exclude = {}
         self.rename = {}
         self.targetprefixes = None
         if path:
             if self.parse(path):
                 raise error.Abort(_(b'errors in filemap'))
 
-    # TODO: cmd==b'source' case breaks if ``path``is str
-    def parse(self, path) -> int:
+    def parse(self, path: Optional[bytes]) -> int:
         errs = 0
 
         def check(name: bytes, mapping, listname: bytes):
             if not name:
                 self.ui.warn(
                     _(b'%s:%d: path to %s is missing\n')
                     % (lex.infile, lex.lineno, listname)
                 )
                 return 1
             if name in mapping:
                 self.ui.warn(
                     _(b'%s:%d: %r already in %s list\n')
                     % (lex.infile, lex.lineno, name, listname)
                 )
                 return 1
             if name.startswith(b'/') or name.endswith(b'/') or b'//' in name:
                 self.ui.warn(
                     _(b'%s:%d: superfluous / in %s %r\n')
                     % (lex.infile, lex.lineno, listname, pycompat.bytestr(name))
                 )
                 return 1
             return 0
 
         lex = common.shlexer(
             filepath=path, wordchars=b'!@#$%^&*()-=+[]{}|;:,./<>?'
         )
         cmd = lex.get_token()
         while cmd:
             if cmd == b'include':
                 name = normalize(lex.get_token())
                 errs += check(name, self.exclude, b'exclude')
                 self.include[name] = name
             elif cmd == b'exclude':
                 name = normalize(lex.get_token())
                 errs += check(name, self.include, b'include')
                 errs += check(name, self.rename, b'rename')
                 self.exclude[name] = name
             elif cmd == b'rename':
                 src = normalize(lex.get_token())
                 dest = normalize(lex.get_token())
                 errs += check(src, self.exclude, b'exclude')
                 self.rename[src] = dest
             elif cmd == b'source':
                 errs += self.parse(normalize(lex.get_token()))
             else:
                 self.ui.warn(
                     _(b'%s:%d: unknown directive %r\n')
                     % (lex.infile, lex.lineno, pycompat.bytestr(cmd))
                 )
                 errs += 1
             cmd = lex.get_token()
         return errs
 
     def lookup(
         self, name: bytes, mapping: Mapping[bytes, bytes]
     ) -> Tuple[bytes, bytes, bytes]:
         name = normalize(name)
         for pre, suf in rpairs(name):
             try:
                 return mapping[pre], pre, suf
             except KeyError:
                 pass
         return b'', name, b''
 
     def istargetfile(self, filename: bytes) -> bool:
         """Return true if the given target filename is covered as a destination
         of the filemap. This is useful for identifying what parts of the target
         repo belong to the source repo and what parts don't."""
         if self.targetprefixes is None:
             self.targetprefixes = set()
             for before, after in self.rename.items():
                 self.targetprefixes.add(after)
 
         # If "." is a target, then all target files are considered from the
         # source.
         if not self.targetprefixes or b'.' in self.targetprefixes:
             return True
 
         filename = normalize(filename)
         for pre, suf in rpairs(filename):
             # This check is imperfect since it doesn't account for the
             # include/exclude list, but it should work in filemaps that don't
             # apply include/exclude to the same source directories they are
             # renaming.
             if pre in self.targetprefixes:
                 return True
         return False
 
     def __call__(self, name: bytes) -> Optional[bytes]:
         if self.include:
             inc = self.lookup(name, self.include)[0]
         else:
             inc = name
         if self.exclude:
             exc = self.lookup(name, self.exclude)[0]
         else:
             exc = b''
         if (not self.include and exc) or (len(inc) <= len(exc)):
             return None
         newpre, pre, suf = self.lookup(name, self.rename)
         if newpre:
             if newpre == b'.':
                 return suf
             if suf:
                 if newpre.endswith(b'/'):
                     return newpre + suf
                 return newpre + b'/' + suf
             return newpre
         return name
 
     def active(self) -> bool:
         return bool(self.include or self.exclude or self.rename)
 
 
 # This class does two additional things compared to a regular source:
 #
 # - Filter and rename files.  This is mostly wrapped by the filemapper
 #   class above. We hide the original filename in the revision that is
 #   returned by getchanges to be able to find things later in getfile.
 #
 # - Return only revisions that matter for the files we're interested in.
 #   This involves rewriting the parents of the original revision to
 #   create a graph that is restricted to those revisions.
 #
 #   This set of revisions includes not only revisions that directly
 #   touch files we're interested in, but also merges that merge two
 #   or more interesting revisions.
 
 
 class filemap_source(common.converter_source):
-    def __init__(self, ui: "uimod.ui", baseconverter, filemap) -> None:
+    def __init__(
+        self, ui: "uimod.ui", baseconverter, filemap: Optional[bytes]
+    ) -> None:
         super(filemap_source, self).__init__(ui, baseconverter.repotype)
         self.base = baseconverter
         self.filemapper = filemapper(ui, filemap)
         self.commits = {}
         # if a revision rev has parent p in the original revision graph, then
         # rev will have parent self.parentmap[p] in the restricted graph.
         self.parentmap = {}
         # self.wantedancestors[rev] is the set of all ancestors of rev that
         # are in the restricted graph.
         self.wantedancestors = {}
         self.convertedorder = None
         self._rebuilt = False
         self.origparents = {}
         self.children = {}
         self.seenchildren = {}
         # experimental config: convert.ignoreancestorcheck
         self.ignoreancestorcheck = self.ui.configbool(
             b'convert', b'ignoreancestorcheck'
         )
 
     def before(self) -> None:
         self.base.before()
 
     def after(self) -> None:
         self.base.after()
 
     def setrevmap(self, revmap):
         # rebuild our state to make things restartable
         #
         # To avoid calling getcommit for every revision that has already
         # been converted, we rebuild only the parentmap, delaying the
         # rebuild of wantedancestors until we need it (i.e. until a
         # merge).
         #
         # We assume the order argument lists the revisions in
         # topological order, so that we can infer which revisions were
         # wanted by previous runs.
         self._rebuilt = not revmap
         seen = {SKIPREV: SKIPREV}
         dummyset = set()
         converted = []
         for rev in revmap.order:
             mapped = revmap[rev]
             wanted = mapped not in seen
             if wanted:
                 seen[mapped] = rev
                 self.parentmap[rev] = rev
             else:
                 self.parentmap[rev] = seen[mapped]
             self.wantedancestors[rev] = dummyset
             arg = seen[mapped]
             if arg == SKIPREV:
                 arg = None
             converted.append((rev, wanted, arg))
         self.convertedorder = converted
         return self.base.setrevmap(revmap)
 
     def rebuild(self) -> bool:
         if self._rebuilt:
             return True
         self._rebuilt = True
         self.parentmap.clear()
         self.wantedancestors.clear()
         self.seenchildren.clear()
         for rev, wanted, arg in self.convertedorder:
             if rev not in self.origparents:
                 try:
                     self.origparents[rev] = self.getcommit(rev).parents
                 except error.RepoLookupError:
                     self.ui.debug(b"unknown revmap source: %s\n" % rev)
                     continue
             if arg is not None:
                 self.children[arg] = self.children.get(arg, 0) + 1
 
         for rev, wanted, arg in self.convertedorder:
             try:
                 parents = self.origparents[rev]
             except KeyError:
                 continue  # unknown revmap source
             if wanted:
                 self.mark_wanted(rev, parents)
             else:
                 self.mark_not_wanted(rev, arg)
             self._discard(arg, *parents)
 
         return True
 
     def getheads(self):
         return self.base.getheads()
 
     def getcommit(self, rev: bytes):
         # We want to save a reference to the commit objects to be able
         # to rewrite their parents later on.
         c = self.commits[rev] = self.base.getcommit(rev)
         for p in c.parents:
             self.children[p] = self.children.get(p, 0) + 1
         return c
 
     def numcommits(self):
         return self.base.numcommits()
 
     def _cachedcommit(self, rev):
         if rev in self.commits:
             return self.commits[rev]
         return self.base.getcommit(rev)
 
     def _discard(self, *revs) -> None:
         for r in revs:
             if r is None:
                 continue
             self.seenchildren[r] = self.seenchildren.get(r, 0) + 1
             if self.seenchildren[r] == self.children[r]:
                 self.wantedancestors.pop(r, None)
                 self.parentmap.pop(r, None)
                 del self.seenchildren[r]
                 if self._rebuilt:
                     del self.children[r]
 
     def wanted(self, rev, i) -> bool:
         # Return True if we're directly interested in rev.
         #
         # i is an index selecting one of the parents of rev (if rev
         # has no parents, i is None).  getchangedfiles will give us
         # the list of files that are different in rev and in the parent
         # indicated by i.  If we're interested in any of these files,
         # we're interested in rev.
         try:
             files = self.base.getchangedfiles(rev, i)
         except NotImplementedError:
             raise error.Abort(_(b"source repository doesn't support --filemap"))
         for f in files:
             if self.filemapper(f):
                 return True
 
         # The include directive is documented to include nothing else (though
         # valid branch closes are included).
         if self.filemapper.include:
             return False
 
         # Allow empty commits in the source revision through.  The getchanges()
         # method doesn't even bother calling this if it determines that the
         # close marker is significant (i.e. all of the branch ancestors weren't
         # eliminated).  Therefore if there *is* a close marker, getchanges()
         # doesn't consider it significant, and this revision should be dropped.
         return not files and b'close' not in self.commits[rev].extra
 
     def mark_not_wanted(self, rev, p) -> None:
         # Mark rev as not interesting and update data structures.
 
         if p is None:
             # A root revision. Use SKIPREV to indicate that it doesn't
             # map to any revision in the restricted graph.  Put SKIPREV
             # in the set of wanted ancestors to simplify code elsewhere
             self.parentmap[rev] = SKIPREV
             self.wantedancestors[rev] = {SKIPREV}
             return
 
         # Reuse the data from our parent.
         self.parentmap[rev] = self.parentmap[p]
         self.wantedancestors[rev] = self.wantedancestors[p]
 
     def mark_wanted(self, rev, parents) -> None:
         # Mark rev ss wanted and update data structures.
 
         # rev will be in the restricted graph, so children of rev in
         # the original graph should still have rev as a parent in the
         # restricted graph.
         self.parentmap[rev] = rev
 
         # The set of wanted ancestors of rev is the union of the sets
         # of wanted ancestors of its parents. Plus rev itself.
         wrev = set()
         for p in parents:
             if p in self.wantedancestors:
                 wrev.update(self.wantedancestors[p])
             else:
                 self.ui.warn(
                     _(b'warning: %s parent %s is missing\n') % (rev, p)
                 )
         wrev.add(rev)
         self.wantedancestors[rev] = wrev
 
     def getchanges(self, rev, full):
         parents = self.commits[rev].parents
         if len(parents) > 1 and not self.ignoreancestorcheck:
             self.rebuild()
 
         # To decide whether we're interested in rev we:
         #
         # - calculate what parents rev will have if it turns out we're
         #   interested in it.  If it's going to have more than 1 parent,
         #   we're interested in it.
         #
         # - otherwise, we'll compare it with the single parent we found.
         #   If any of the files we're interested in is different in the
         #   the two revisions, we're interested in rev.
 
         # A parent p is interesting if its mapped version (self.parentmap[p]):
         # - is not SKIPREV
         # - is still not in the list of parents (we don't want duplicates)
         # - is not an ancestor of the mapped versions of the other parents or
         #   there is no parent in the same branch than the current revision.
         mparents = []
         knownparents = set()
         branch = self.commits[rev].branch
         hasbranchparent = False
         for i, p1 in enumerate(parents):
             mp1 = self.parentmap[p1]
             if mp1 == SKIPREV or mp1 in knownparents:
                 continue
 
             isancestor = not self.ignoreancestorcheck and any(
                 p2
                 for p2 in parents
                 if p1 != p2
                 and mp1 != self.parentmap[p2]
                 and mp1 in self.wantedancestors[p2]
             )
             if not isancestor and not hasbranchparent and len(parents) > 1:
                 # This could be expensive, avoid unnecessary calls.
                 if self._cachedcommit(p1).branch == branch:
                     hasbranchparent = True
             mparents.append((p1, mp1, i, isancestor))
             knownparents.add(mp1)
         # Discard parents ancestors of other parents if there is a
         # non-ancestor one on the same branch than current revision.
         if hasbranchparent:
             mparents = [p for p in mparents if not p[3]]
         wp = None
         if mparents:
             wp = max(p[2] for p in mparents)
             mparents = [p[1] for p in mparents]
         elif parents:
             wp = 0
 
         self.origparents[rev] = parents
 
         closed = False
         if b'close' in self.commits[rev].extra:
             # A branch closing revision is only useful if one of its
             # parents belong to the branch being closed
             pbranches = [self._cachedcommit(p).branch for p in mparents]
             if branch in pbranches:
                 closed = True
 
         if len(mparents) < 2 and not closed and not self.wanted(rev, wp):
             # We don't want this revision.
             # Update our state and tell the convert process to map this
             # revision to the same revision its parent as mapped to.
             p = None
             if parents:
                 p = parents[wp]
             self.mark_not_wanted(rev, p)
             self.convertedorder.append((rev, False, p))
             self._discard(*parents)
             return self.parentmap[rev]
 
         # We want this revision.
         # Rewrite the parents of the commit object
         self.commits[rev].parents = mparents
         self.mark_wanted(rev, parents)
         self.convertedorder.append((rev, True, None))
         self._discard(*parents)
 
         # Get the real changes and do the filtering/mapping. To be
         # able to get the files later on in getfile, we hide the
         # original filename in the rev part of the return value.
         changes, copies, cleanp2 = self.base.getchanges(rev, full)
         files = {}
         ncleanp2 = set(cleanp2)
         for f, r in changes:
             newf = self.filemapper(f)
             if newf and (newf != f or newf not in files):
                 files[newf] = (f, r)
                 if newf != f:
                     ncleanp2.discard(f)
         files = sorted(files.items())
 
         ncopies = {}
         for c in copies:
             newc = self.filemapper(c)
             if newc:
                 newsource = self.filemapper(copies[c])
                 if newsource:
                     ncopies[newc] = newsource
 
         return files, ncopies, ncleanp2
 
     def targetfilebelongstosource(self, targetfilename: bytes) -> bool:
         return self.filemapper.istargetfile(targetfilename)
 
     def getfile(self, name, rev):
         realname, realrev = rev
         return self.base.getfile(realname, realrev)
 
     def gettags(self):
         return self.base.gettags()
 
     def hasnativeorder(self) -> bool:
         return self.base.hasnativeorder()
 
     def lookuprev(self, rev):
         return self.base.lookuprev(rev)
 
     def getbookmarks(self):
         return self.base.getbookmarks()
 
     def converted(self, rev, sinkrev):
         self.base.converted(rev, sinkrev)