typing: (mostly) align the signatures of `imanifestrevisionstored` overrides

When we change the implementations to subclass this explicitly, pytype complains
that the signatures mismatch for various methods.  It seems hung up on ones in
`mercurial.manifest` that have type hints on the return value, but lacked it in
the Protocol class (which it thinks returns `None` if there's no annotation).
The tricky part is that a lot of the return types in the `mercurial.manifest`
module are custom types specific to that module (e.g. `'manifestctx' | 'treemanifestctx'`).
Those should probably be replaced with Protocol classes.

I was going to avoid making a long series longer by disabling that check for now
by putting `Any` as the return type on the Protocol class methods, and then
realized the problem is the class isn't marked as a Protocol (that property isn't
inherited).  For now, lock in the synchronized signatures.

hgext/git/manifest.py

@@ -1,370 +1,370
 from __future__ import annotations
 
 from mercurial import (
     match as matchmod,
     pathutil,
     pycompat,
     util,
 )
 from mercurial.interfaces import (
     repository,
     util as interfaceutil,
 )
 from . import gitutil
 
 
 pygit2 = gitutil.get_pygit2()
 
 
 @interfaceutil.implementer(repository.imanifestdict)
 class gittreemanifest:
     """Expose git trees (and optionally a builder's overlay) as a manifestdict.
 
     Very similar to mercurial.manifest.treemanifest.
     """
 
     def __init__(self, git_repo, root_tree, pending_changes):
         """Initializer.
 
         Args:
           git_repo: The git_repo we're walking (required to look up child
               trees).
           root_tree: The root Git tree object for this manifest.
           pending_changes: A dict in which pending changes will be
               tracked. The enclosing memgittreemanifestctx will use this to
               construct any required Tree objects in Git during it's
               `write()` method.
         """
         self._git_repo = git_repo
         self._tree = root_tree
         if pending_changes is None:
             pending_changes = {}
         # dict of path: Optional[Tuple(node, flags)]
         self._pending_changes = pending_changes
 
     def _resolve_entry(self, path):
         """Given a path, load its node and flags, or raise KeyError if missing.
 
         This takes into account any pending writes in the builder.
         """
         upath = pycompat.fsdecode(path)
         ent = None
         if path in self._pending_changes:
             val = self._pending_changes[path]
             if val is None:
                 raise KeyError
             return val
         t = self._tree
         comps = upath.split('/')
         te = self._tree
         for comp in comps[:-1]:
             te = te[comp]
             t = self._git_repo[te.id]
         ent = t[comps[-1]]
         if ent.filemode == pygit2.GIT_FILEMODE_BLOB:
             flags = b''
         elif ent.filemode == pygit2.GIT_FILEMODE_BLOB_EXECUTABLE:
             flags = b'x'
         elif ent.filemode == pygit2.GIT_FILEMODE_LINK:
             flags = b'l'
         else:
             raise ValueError('unsupported mode %s' % oct(ent.filemode))
         return ent.id.raw, flags
 
     def __getitem__(self, path):
         return self._resolve_entry(path)[0]
 
     def find(self, path):
         return self._resolve_entry(path)
 
     def __len__(self):
         return len(list(self.walk(matchmod.always())))
 
     def __nonzero__(self):
         try:
             next(iter(self))
             return True
         except StopIteration:
             return False
 
     __bool__ = __nonzero__
 
     def __contains__(self, path):
         try:
             self._resolve_entry(path)
             return True
         except KeyError:
             return False
 
     def iterkeys(self):
         return self.walk(matchmod.always())
 
     def keys(self):
         return list(self.iterkeys())
 
     def __iter__(self):
         return self.iterkeys()
 
     def __setitem__(self, path, node):
         self._pending_changes[path] = node, self.flags(path)
 
     def __delitem__(self, path):
         # TODO: should probably KeyError for already-deleted  files?
         self._pending_changes[path] = None
 
     def filesnotin(self, other, match=None):
         if match is not None:
             match = matchmod.badmatch(match, lambda path, msg: None)
             sm2 = set(other.walk(match))
             return {f for f in self.walk(match) if f not in sm2}
         return {f for f in self if f not in other}
 
     @util.propertycache
     def _dirs(self):
         return pathutil.dirs(self)
 
     def hasdir(self, dir):
         return dir in self._dirs
 
     def diff(self, other, match=lambda x: True, clean=False):
         """Finds changes between the current manifest and m2.
 
         The result is returned as a dict with filename as key and
         values of the form ((n1,fl1),(n2,fl2)), where n1/n2 is the
         nodeid in the current/other manifest and fl1/fl2 is the flag
         in the current/other manifest. Where the file does not exist,
         the nodeid will be None and the flags will be the empty
         string.
         """
         result = {}
 
         def _iterativediff(t1, t2, subdir):
             """compares two trees and appends new tree nodes to examine to
             the stack"""
             if t1 is None:
                 t1 = {}
             if t2 is None:
                 t2 = {}
 
             for e1 in t1:
                 realname = subdir + pycompat.fsencode(e1.name)
 
                 if e1.type == pygit2.GIT_OBJ_TREE:
                     try:
                         e2 = t2[e1.name]
                         if e2.type != pygit2.GIT_OBJ_TREE:
                             e2 = None
                     except KeyError:
                         e2 = None
 
                     stack.append((realname + b'/', e1, e2))
                 else:
                     n1, fl1 = self.find(realname)
 
                     try:
                         e2 = t2[e1.name]
                         n2, fl2 = other.find(realname)
                     except KeyError:
                         e2 = None
                         n2, fl2 = (None, b'')
 
                     if e2 is not None and e2.type == pygit2.GIT_OBJ_TREE:
                         stack.append((realname + b'/', None, e2))
 
                     if not match(realname):
                         continue
 
                     if n1 != n2 or fl1 != fl2:
                         result[realname] = ((n1, fl1), (n2, fl2))
                     elif clean:
                         result[realname] = None
 
             for e2 in t2:
                 if e2.name in t1:
                     continue
 
                 realname = subdir + pycompat.fsencode(e2.name)
 
                 if e2.type == pygit2.GIT_OBJ_TREE:
                     stack.append((realname + b'/', None, e2))
                 elif match(realname):
                     n2, fl2 = other.find(realname)
                     result[realname] = ((None, b''), (n2, fl2))
 
         stack = []
         _iterativediff(self._tree, other._tree, b'')
         while stack:
             subdir, t1, t2 = stack.pop()
             # stack is populated in the function call
             _iterativediff(t1, t2, subdir)
 
         return result
 
     def setflag(self, path, flag):
         node, unused_flag = self._resolve_entry(path)
         self._pending_changes[path] = node, flag
 
     def get(self, path, default=None):
         try:
             return self._resolve_entry(path)[0]
         except KeyError:
             return default
 
     def flags(self, path):
         try:
             return self._resolve_entry(path)[1]
         except KeyError:
             return b''
 
     def copy(self):
         return gittreemanifest(
             self._git_repo, self._tree, dict(self._pending_changes)
         )
 
     def items(self):
         for f in self:
             # TODO: build a proper iterator version of this
             yield self[f]
 
     def iteritems(self):
         return self.items()
 
     def iterentries(self):
         for f in self:
             # TODO: build a proper iterator version of this
             yield self._resolve_entry(f)
 
     def text(self):
         assert False  # TODO can this method move out of the manifest iface?
 
     def _walkonetree(self, tree, match, subdir):
         for te in tree:
             # TODO: can we prune dir walks with the matcher?
             realname = subdir + pycompat.fsencode(te.name)
             if te.type == pygit2.GIT_OBJ_TREE:
                 for inner in self._walkonetree(
                     self._git_repo[te.id], match, realname + b'/'
                 ):
                     yield inner
             elif match(realname):
                 yield pycompat.fsencode(realname)
 
     def walk(self, match):
         # TODO: this is a very lazy way to merge in the pending
         # changes. There is absolutely room for optimization here by
         # being clever about walking over the sets...
         baseline = set(self._walkonetree(self._tree, match, b''))
         deleted = {p for p, v in self._pending_changes.items() if v is None}
         pend = {p for p in self._pending_changes if match(p)}
         return iter(sorted((baseline | pend) - deleted))
 
 
 @interfaceutil.implementer(repository.imanifestrevisionstored)
 class gittreemanifestctx:
     def __init__(self, repo, gittree):
         self._repo = repo
         self._tree = gittree
 
     def read(self):
         return gittreemanifest(self._repo, self._tree, None)
 
-    def readfast(self, shallow=False):
+    def readfast(self, shallow: bool = False):
         return self.read()
 
     def copy(self):
         # NB: it's important that we return a memgittreemanifestctx
         # because the caller expects a mutable manifest.
         return memgittreemanifestctx(self._repo, self._tree)
 
-    def find(self, path):
+    def find(self, path: bytes) -> tuple[bytes, bytes]:
         return self.read()[path]
 
 
 @interfaceutil.implementer(repository.imanifestrevisionwritable)
 class memgittreemanifestctx:
     def __init__(self, repo, tree):
         self._repo = repo
         self._tree = tree
         # dict of path: Optional[Tuple(node, flags)]
         self._pending_changes = {}
 
     def read(self):
         return gittreemanifest(self._repo, self._tree, self._pending_changes)
 
     def copy(self):
         # TODO: if we have a builder in play, what should happen here?
         # Maybe we can shuffle copy() into the immutable interface.
         return memgittreemanifestctx(self._repo, self._tree)
 
     def write(self, transaction, link, p1, p2, added, removed, match=None):
         # We're not (for now, anyway) going to audit filenames, so we
         # can ignore added and removed.
 
         # TODO what does this match argument get used for? hopefully
         # just narrow?
         assert not match or isinstance(match, matchmod.alwaysmatcher)
 
         touched_dirs = pathutil.dirs(list(self._pending_changes))
         trees = {
             b'': self._tree,
         }
         # path: treebuilder
         builders = {
             b'': self._repo.TreeBuilder(self._tree),
         }
         # get a TreeBuilder for every tree in the touched_dirs set
         for d in sorted(touched_dirs, key=lambda x: (len(x), x)):
             if d == b'':
                 # loaded root tree above
                 continue
             comps = d.split(b'/')
             full = b''
             for part in comps:
                 parent = trees[full]
                 try:
                     parent_tree_id = parent[pycompat.fsdecode(part)].id
                     new = self._repo[parent_tree_id]
                 except KeyError:
                     # new directory
                     new = None
                 full += b'/' + part
                 if new is not None:
                     # existing directory
                     trees[full] = new
                     builders[full] = self._repo.TreeBuilder(new)
                 else:
                     # new directory, use an empty dict to easily
                     # generate KeyError as any nested new dirs get
                     # created.
                     trees[full] = {}
                     builders[full] = self._repo.TreeBuilder()
         for f, info in self._pending_changes.items():
             if b'/' not in f:
                 dirname = b''
                 basename = f
             else:
                 dirname, basename = f.rsplit(b'/', 1)
                 dirname = b'/' + dirname
             if info is None:
                 builders[dirname].remove(pycompat.fsdecode(basename))
             else:
                 n, fl = info
                 mode = {
                     b'': pygit2.GIT_FILEMODE_BLOB,
                     b'x': pygit2.GIT_FILEMODE_BLOB_EXECUTABLE,
                     b'l': pygit2.GIT_FILEMODE_LINK,
                 }[fl]
                 builders[dirname].insert(
                     pycompat.fsdecode(basename), gitutil.togitnode(n), mode
                 )
         # This visits the buffered TreeBuilders in deepest-first
         # order, bubbling up the edits.
         for b in sorted(builders, key=len, reverse=True):
             if b == b'':
                 break
             cb = builders[b]
             dn, bn = b.rsplit(b'/', 1)
             builders[dn].insert(
                 pycompat.fsdecode(bn), cb.write(), pygit2.GIT_FILEMODE_TREE
             )
         return builders[b''].write().raw

mercurial/interfaces/repository.py

@@ -1,2166 +1,2172
 # repository.py - Interfaces and base classes for repositories and peers.
 # coding: utf-8
 #
 # Copyright 2017 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 annotations
 
 import typing
 
 from typing import (
     Any,
+    Collection,
     Protocol,
 )
 
 from ..i18n import _
 from .. import error
 from . import util as interfaceutil
 
 if typing.TYPE_CHECKING:
     # Almost all mercurial modules are only imported in the type checking phase
     # to avoid circular imports
     from ..utils import (
         urlutil,
     )
 
     # TODO: create a Protocol class, since importing uimod here causes a cycle
     #  that confuses pytype.
     Ui = Any
 
 # Local repository feature string.
 
 # Revlogs are being used for file storage.
 REPO_FEATURE_REVLOG_FILE_STORAGE = b'revlogfilestorage'
 # The storage part of the repository is shared from an external source.
 REPO_FEATURE_SHARED_STORAGE = b'sharedstore'
 # LFS supported for backing file storage.
 REPO_FEATURE_LFS = b'lfs'
 # Repository supports being stream cloned.
 REPO_FEATURE_STREAM_CLONE = b'streamclone'
 # Repository supports (at least) some sidedata to be stored
 REPO_FEATURE_SIDE_DATA = b'side-data'
 # Files storage may lack data for all ancestors.
 REPO_FEATURE_SHALLOW_FILE_STORAGE = b'shallowfilestorage'
 
 REVISION_FLAG_CENSORED = 1 << 15
 REVISION_FLAG_ELLIPSIS = 1 << 14
 REVISION_FLAG_EXTSTORED = 1 << 13
 REVISION_FLAG_HASCOPIESINFO = 1 << 12
 
 REVISION_FLAGS_KNOWN = (
     REVISION_FLAG_CENSORED
     | REVISION_FLAG_ELLIPSIS
     | REVISION_FLAG_EXTSTORED
     | REVISION_FLAG_HASCOPIESINFO
 )
 
 CG_DELTAMODE_STD = b'default'
 CG_DELTAMODE_PREV = b'previous'
 CG_DELTAMODE_FULL = b'fulltext'
 CG_DELTAMODE_P1 = b'p1'
 
 
 ## Cache related constants:
 #
 # Used to control which cache should be warmed in a repo.updatecaches(…) call.
 
 # Warm branchmaps of all known repoview's filter-level
 CACHE_BRANCHMAP_ALL = b"branchmap-all"
 # Warm branchmaps of repoview's filter-level used by server
 CACHE_BRANCHMAP_SERVED = b"branchmap-served"
 # Warm internal changelog cache (eg: persistent nodemap)
 CACHE_CHANGELOG_CACHE = b"changelog-cache"
 # check of a branchmap can use the "pure topo" mode
 CACHE_BRANCHMAP_DETECT_PURE_TOPO = b"branchmap-detect-pure-topo"
 # Warm full manifest cache
 CACHE_FULL_MANIFEST = b"full-manifest"
 # Warm file-node-tags cache
 CACHE_FILE_NODE_TAGS = b"file-node-tags"
 # Warm internal manifestlog cache (eg: persistent nodemap)
 CACHE_MANIFESTLOG_CACHE = b"manifestlog-cache"
 # Warn rev branch cache
 CACHE_REV_BRANCH = b"rev-branch-cache"
 # Warm tags' cache for default repoview'
 CACHE_TAGS_DEFAULT = b"tags-default"
 # Warm tags' cache for  repoview's filter-level used by server
 CACHE_TAGS_SERVED = b"tags-served"
 
 # the cache to warm by default after a simple transaction
 # (this is a mutable set to let extension update it)
 CACHES_DEFAULT = {
     CACHE_BRANCHMAP_SERVED,
 }
 
 # the caches to warm when warming all of them
 # (this is a mutable set to let extension update it)
 CACHES_ALL = {
     CACHE_BRANCHMAP_SERVED,
     CACHE_BRANCHMAP_ALL,
     CACHE_BRANCHMAP_DETECT_PURE_TOPO,
     CACHE_REV_BRANCH,
     CACHE_CHANGELOG_CACHE,
     CACHE_FILE_NODE_TAGS,
     CACHE_FULL_MANIFEST,
     CACHE_MANIFESTLOG_CACHE,
     CACHE_TAGS_DEFAULT,
     CACHE_TAGS_SERVED,
 }
 
 # the cache to warm by default on simple call
 # (this is a mutable set to let extension update it)
 CACHES_POST_CLONE = CACHES_ALL.copy()
 CACHES_POST_CLONE.discard(CACHE_FILE_NODE_TAGS)
 CACHES_POST_CLONE.discard(CACHE_REV_BRANCH)
 
 
 class _ipeerconnection(Protocol):
     """Represents a "connection" to a repository.
 
     This is the base interface for representing a connection to a repository.
     It holds basic properties and methods applicable to all peer types.
 
     This is not a complete interface definition and should not be used
     outside of this module.
     """
 
     ui: Ui
     """ui.ui instance"""
 
     path: urlutil.path | None
     """a urlutil.path instance or None"""
 
     def url(self):
         """Returns a URL string representing this peer.
 
         Currently, implementations expose the raw URL used to construct the
         instance. It may contain credentials as part of the URL. The
         expectations of the value aren't well-defined and this could lead to
         data leakage.
 
         TODO audit/clean consumers and more clearly define the contents of this
         value.
         """
 
     def local(self):
         """Returns a local repository instance.
 
         If the peer represents a local repository, returns an object that
         can be used to interface with it. Otherwise returns ``None``.
         """
 
     def canpush(self):
         """Returns a boolean indicating if this peer can be pushed to."""
 
     def close(self):
         """Close the connection to this peer.
 
         This is called when the peer will no longer be used. Resources
         associated with the peer should be cleaned up.
         """
 
 
 class ipeercapabilities(Protocol):
     """Peer sub-interface related to capabilities."""
 
     def capable(self, name):
         """Determine support for a named capability.
 
         Returns ``False`` if capability not supported.
 
         Returns ``True`` if boolean capability is supported. Returns a string
         if capability support is non-boolean.
 
         Capability strings may or may not map to wire protocol capabilities.
         """
 
     def requirecap(self, name, purpose):
         """Require a capability to be present.
 
         Raises a ``CapabilityError`` if the capability isn't present.
         """
 
 
 class ipeercommands(Protocol):
     """Client-side interface for communicating over the wire protocol.
 
     This interface is used as a gateway to the Mercurial wire protocol.
     methods commonly call wire protocol commands of the same name.
     """
 
     def branchmap(self):
         """Obtain heads in named branches.
 
         Returns a dict mapping branch name to an iterable of nodes that are
         heads on that branch.
         """
 
     def capabilities(self):
         """Obtain capabilities of the peer.
 
         Returns a set of string capabilities.
         """
 
     def get_cached_bundle_inline(self, path):
         """Retrieve a clonebundle across the wire.
 
         Returns a chunkbuffer
         """
 
     def clonebundles(self):
         """Obtains the clone bundles manifest for the repo.
 
         Returns the manifest as unparsed bytes.
         """
 
     def debugwireargs(self, one, two, three=None, four=None, five=None):
         """Used to facilitate debugging of arguments passed over the wire."""
 
     def getbundle(self, source, **kwargs):
         """Obtain remote repository data as a bundle.
 
         This command is how the bulk of repository data is transferred from
         the peer to the local repository
 
         Returns a generator of bundle data.
         """
 
     def heads(self):
         """Determine all known head revisions in the peer.
 
         Returns an iterable of binary nodes.
         """
 
     def known(self, nodes):
         """Determine whether multiple nodes are known.
 
         Accepts an iterable of nodes whose presence to check for.
 
         Returns an iterable of booleans indicating of the corresponding node
         at that index is known to the peer.
         """
 
     def listkeys(self, namespace):
         """Obtain all keys in a pushkey namespace.
 
         Returns an iterable of key names.
         """
 
     def lookup(self, key):
         """Resolve a value to a known revision.
 
         Returns a binary node of the resolved revision on success.
         """
 
     def pushkey(self, namespace, key, old, new):
         """Set a value using the ``pushkey`` protocol.
 
         Arguments correspond to the pushkey namespace and key to operate on and
         the old and new values for that key.
 
         Returns a string with the peer result. The value inside varies by the
         namespace.
         """
 
     def stream_out(self):
         """Obtain streaming clone data.
 
         Successful result should be a generator of data chunks.
         """
 
     def unbundle(self, bundle, heads, url):
         """Transfer repository data to the peer.
 
         This is how the bulk of data during a push is transferred.
 
         Returns the integer number of heads added to the peer.
         """
 
 
 class ipeerlegacycommands(Protocol):
     """Interface for implementing support for legacy wire protocol commands.
 
     Wire protocol commands transition to legacy status when they are no longer
     used by modern clients. To facilitate identifying which commands are
     legacy, the interfaces are split.
     """
 
     def between(self, pairs):
         """Obtain nodes between pairs of nodes.
 
         ``pairs`` is an iterable of node pairs.
 
         Returns an iterable of iterables of nodes corresponding to each
         requested pair.
         """
 
     def branches(self, nodes):
         """Obtain ancestor changesets of specific nodes back to a branch point.
 
         For each requested node, the peer finds the first ancestor node that is
         a DAG root or is a merge.
 
         Returns an iterable of iterables with the resolved values for each node.
         """
 
     def changegroup(self, nodes, source):
         """Obtain a changegroup with data for descendants of specified nodes."""
 
     def changegroupsubset(self, bases, heads, source):
         pass
 
 
 class ipeercommandexecutor(Protocol):
     """Represents a mechanism to execute remote commands.
 
     This is the primary interface for requesting that wire protocol commands
     be executed. Instances of this interface are active in a context manager
     and have a well-defined lifetime. When the context manager exits, all
     outstanding requests are waited on.
     """
 
     def callcommand(self, name, args):
         """Request that a named command be executed.
 
         Receives the command name and a dictionary of command arguments.
 
         Returns a ``concurrent.futures.Future`` that will resolve to the
         result of that command request. That exact value is left up to
         the implementation and possibly varies by command.
 
         Not all commands can coexist with other commands in an executor
         instance: it depends on the underlying wire protocol transport being
         used and the command itself.
 
         Implementations MAY call ``sendcommands()`` automatically if the
         requested command can not coexist with other commands in this executor.
 
         Implementations MAY call ``sendcommands()`` automatically when the
         future's ``result()`` is called. So, consumers using multiple
         commands with an executor MUST ensure that ``result()`` is not called
         until all command requests have been issued.
         """
 
     def sendcommands(self):
         """Trigger submission of queued command requests.
 
         Not all transports submit commands as soon as they are requested to
         run. When called, this method forces queued command requests to be
         issued. It will no-op if all commands have already been sent.
 
         When called, no more new commands may be issued with this executor.
         """
 
     def close(self):
         """Signal that this command request is finished.
 
         When called, no more new commands may be issued. All outstanding
         commands that have previously been issued are waited on before
         returning. This not only includes waiting for the futures to resolve,
         but also waiting for all response data to arrive. In other words,
         calling this waits for all on-wire state for issued command requests
         to finish.
 
         When used as a context manager, this method is called when exiting the
         context manager.
 
         This method may call ``sendcommands()`` if there are buffered commands.
         """
 
 
 class ipeerrequests(Protocol):
     """Interface for executing commands on a peer."""
 
     limitedarguments: bool
     """True if the peer cannot receive large argument value for commands."""
 
     def commandexecutor(self):
         """A context manager that resolves to an ipeercommandexecutor.
 
         The object this resolves to can be used to issue command requests
         to the peer.
 
         Callers should call its ``callcommand`` method to issue command
         requests.
 
         A new executor should be obtained for each distinct set of commands
         (possibly just a single command) that the consumer wants to execute
         as part of a single operation or round trip. This is because some
         peers are half-duplex and/or don't support persistent connections.
         e.g. in the case of HTTP peers, commands sent to an executor represent
         a single HTTP request. While some peers may support multiple command
         sends over the wire per executor, consumers need to code to the least
         capable peer. So it should be assumed that command executors buffer
         called commands until they are told to send them and that each
         command executor could result in a new connection or wire-level request
         being issued.
         """
 
 
 class peer(_ipeerconnection, ipeercapabilities, ipeerrequests, Protocol):
     """Unified interface for peer repositories.
 
     All peer instances must conform to this interface.
     """
 
     limitedarguments: bool = False
 
     def __init__(self, ui, path=None, remotehidden=False):
         self.ui = ui
         self.path = path
 
     def capable(self, name):
         # TODO: this class should maybe subclass ipeercommands too, otherwise it
         #  is assuming whatever uses this as a mixin also has this interface.
         caps = self.capabilities()  # pytype: disable=attribute-error
         if name in caps:
             return True
 
         name = b'%s=' % name
         for cap in caps:
             if cap.startswith(name):
                 return cap[len(name) :]
 
         return False
 
     def requirecap(self, name, purpose):
         if self.capable(name):
             return
 
         raise error.CapabilityError(
             _(
                 b'cannot %s; remote repository does not support the '
                 b'\'%s\' capability'
             )
             % (purpose, name)
         )
 
 
 class iverifyproblem(Protocol):
     """Represents a problem with the integrity of the repository.
 
     Instances of this interface are emitted to describe an integrity issue
     with a repository (e.g. corrupt storage, missing data, etc).
 
     Instances are essentially messages associated with severity.
     """
 
     warning: bytes | None
     """Message indicating a non-fatal problem."""
 
     error: bytes | None
     """Message indicating a fatal problem."""
 
     node: bytes | None
     """Revision encountering the problem.
 
     ``None`` means the problem doesn't apply to a single revision.
     """
 
 
 class irevisiondelta(Protocol):
     """Represents a delta between one revision and another.
 
     Instances convey enough information to allow a revision to be exchanged
     with another repository.
 
     Instances represent the fulltext revision data or a delta against
     another revision. Therefore the ``revision`` and ``delta`` attributes
     are mutually exclusive.
 
     Typically used for changegroup generation.
     """
 
     node: bytes
     """20 byte node of this revision."""
 
     p1node: bytes
     """20 byte node of 1st parent of this revision."""
 
     p2node: bytes
     """20 byte node of 2nd parent of this revision."""
 
     # TODO: is this really optional? revlog.revlogrevisiondelta defaults to None
     linknode: bytes | None
     """20 byte node of the changelog revision this node is linked to."""
 
     flags: int
     """2 bytes of integer flags that apply to this revision.
 
     This is a bitwise composition of the ``REVISION_FLAG_*`` constants.
     """
 
     basenode: bytes
     """20 byte node of the revision this data is a delta against.
 
     ``nullid`` indicates that the revision is a full revision and not
     a delta.
     """
 
     baserevisionsize: int | None
     """Size of base revision this delta is against.
 
     May be ``None`` if ``basenode`` is ``nullid``.
     """
 
     # TODO: is this really optional? (Seems possible in
     #  storageutil.emitrevisions()).
     revision: bytes | None
     """Raw fulltext of revision data for this node."""
 
     delta: bytes | None
     """Delta between ``basenode`` and ``node``.
 
     Stored in the bdiff delta format.
     """
 
     sidedata: bytes | None
     """Raw sidedata bytes for the given revision."""
 
     protocol_flags: int
     """Single byte of integer flags that can influence the protocol.
 
     This is a bitwise composition of the ``storageutil.CG_FLAG*`` constants.
     """
 
 
 class ifilerevisionssequence(Protocol):
     """Contains index data for all revisions of a file.
 
     Types implementing this behave like lists of tuples. The index
     in the list corresponds to the revision number. The values contain
     index metadata.
 
     The *null* revision (revision number -1) is always the last item
     in the index.
     """
 
     def __len__(self):
         """The total number of revisions."""
 
     def __getitem__(self, rev):
         """Returns the object having a specific revision number.
 
         Returns an 8-tuple with the following fields:
 
         offset+flags
            Contains the offset and flags for the revision. 64-bit unsigned
            integer where first 6 bytes are the offset and the next 2 bytes
            are flags. The offset can be 0 if it is not used by the store.
         compressed size
             Size of the revision data in the store. It can be 0 if it isn't
             needed by the store.
         uncompressed size
             Fulltext size. It can be 0 if it isn't needed by the store.
         base revision
             Revision number of revision the delta for storage is encoded
             against. -1 indicates not encoded against a base revision.
         link revision
             Revision number of changelog revision this entry is related to.
         p1 revision
             Revision number of 1st parent. -1 if no 1st parent.
         p2 revision
             Revision number of 2nd parent. -1 if no 1st parent.
         node
             Binary node value for this revision number.
 
         Negative values should index off the end of the sequence. ``-1``
         should return the null revision. ``-2`` should return the most
         recent revision.
         """
 
     def __contains__(self, rev):
         """Whether a revision number exists."""
 
     def insert(self, i, entry):
         """Add an item to the index at specific revision."""
 
 
 class ifileindex(Protocol):
     """Storage interface for index data of a single file.
 
     File storage data is divided into index metadata and data storage.
     This interface defines the index portion of the interface.
 
     The index logically consists of:
 
     * A mapping between revision numbers and nodes.
     * DAG data (storing and querying the relationship between nodes).
     * Metadata to facilitate storage.
     """
 
     nullid: bytes
     """node for the null revision for use as delta base."""
 
     def __len__(self):
         """Obtain the number of revisions stored for this file."""
 
     def __iter__(self):
         """Iterate over revision numbers for this file."""
 
     def hasnode(self, node):
         """Returns a bool indicating if a node is known to this store.
 
         Implementations must only return True for full, binary node values:
         hex nodes, revision numbers, and partial node matches must be
         rejected.
 
         The null node is never present.
         """
 
     def revs(self, start=0, stop=None):
         """Iterate over revision numbers for this file, with control."""
 
     def parents(self, node):
         """Returns a 2-tuple of parent nodes for a revision.
 
         Values will be ``nullid`` if the parent is empty.
         """
 
     def parentrevs(self, rev):
         """Like parents() but operates on revision numbers."""
 
     def rev(self, node):
         """Obtain the revision number given a node.
 
         Raises ``error.LookupError`` if the node is not known.
         """
 
     def node(self, rev):
         """Obtain the node value given a revision number.
 
         Raises ``IndexError`` if the node is not known.
         """
 
     def lookup(self, node):
         """Attempt to resolve a value to a node.
 
         Value can be a binary node, hex node, revision number, or a string
         that can be converted to an integer.
 
         Raises ``error.LookupError`` if a node could not be resolved.
         """
 
     def linkrev(self, rev):
         """Obtain the changeset revision number a revision is linked to."""
 
     def iscensored(self, rev):
         """Return whether a revision's content has been censored."""
 
     def commonancestorsheads(self, node1, node2):
         """Obtain an iterable of nodes containing heads of common ancestors.
 
         See ``ancestor.commonancestorsheads()``.
         """
 
     def descendants(self, revs):
         """Obtain descendant revision numbers for a set of revision numbers.
 
         If ``nullrev`` is in the set, this is equivalent to ``revs()``.
         """
 
     def heads(self, start=None, stop=None):
         """Obtain a list of nodes that are DAG heads, with control.
 
         The set of revisions examined can be limited by specifying
         ``start`` and ``stop``. ``start`` is a node. ``stop`` is an
         iterable of nodes. DAG traversal starts at earlier revision
         ``start`` and iterates forward until any node in ``stop`` is
         encountered.
         """
 
     def children(self, node):
         """Obtain nodes that are children of a node.
 
         Returns a list of nodes.
         """
 
 
 class ifiledata(Protocol):
     """Storage interface for data storage of a specific file.
 
     This complements ``ifileindex`` and provides an interface for accessing
     data for a tracked file.
     """
 
     def size(self, rev):
         """Obtain the fulltext size of file data.
 
         Any metadata is excluded from size measurements.
         """
 
     def revision(self, node):
         """Obtain fulltext data for a node.
 
         By default, any storage transformations are applied before the data
         is returned. If ``raw`` is True, non-raw storage transformations
         are not applied.
 
         The fulltext data may contain a header containing metadata. Most
         consumers should use ``read()`` to obtain the actual file data.
         """
 
     def rawdata(self, node):
         """Obtain raw data for a node."""
 
     def read(self, node):
         """Resolve file fulltext data.
 
         This is similar to ``revision()`` except any metadata in the data
         headers is stripped.
         """
 
     def renamed(self, node):
         """Obtain copy metadata for a node.
 
         Returns ``False`` if no copy metadata is stored or a 2-tuple of
         (path, node) from which this revision was copied.
         """
 
     def cmp(self, node, fulltext):
         """Compare fulltext to another revision.
 
         Returns True if the fulltext is different from what is stored.
 
         This takes copy metadata into account.
 
         TODO better document the copy metadata and censoring logic.
         """
 
     def emitrevisions(
         self,
         nodes,
         nodesorder=None,
         revisiondata=False,
         assumehaveparentrevisions=False,
         deltamode=CG_DELTAMODE_STD,
     ):
         """Produce ``irevisiondelta`` for revisions.
 
         Given an iterable of nodes, emits objects conforming to the
         ``irevisiondelta`` interface that describe revisions in storage.
 
         This method is a generator.
 
         The input nodes may be unordered. Implementations must ensure that a
         node's parents are emitted before the node itself. Transitively, this
         means that a node may only be emitted once all its ancestors in
         ``nodes`` have also been emitted.
 
         By default, emits "index" data (the ``node``, ``p1node``, and
         ``p2node`` attributes). If ``revisiondata`` is set, revision data
         will also be present on the emitted objects.
 
         With default argument values, implementations can choose to emit
         either fulltext revision data or a delta. When emitting deltas,
         implementations must consider whether the delta's base revision
         fulltext is available to the receiver.
 
         The base revision fulltext is guaranteed to be available if any of
         the following are met:
 
         * Its fulltext revision was emitted by this method call.
         * A delta for that revision was emitted by this method call.
         * ``assumehaveparentrevisions`` is True and the base revision is a
           parent of the node.
 
         ``nodesorder`` can be used to control the order that revisions are
         emitted. By default, revisions can be reordered as long as they are
         in DAG topological order (see above). If the value is ``nodes``,
         the iteration order from ``nodes`` should be used. If the value is
         ``storage``, then the native order from the backing storage layer
         is used. (Not all storage layers will have strong ordering and behavior
         of this mode is storage-dependent.) ``nodes`` ordering can force
         revisions to be emitted before their ancestors, so consumers should
         use it with care.
 
         The ``linknode`` attribute on the returned ``irevisiondelta`` may not
         be set and it is the caller's responsibility to resolve it, if needed.
 
         If ``deltamode`` is CG_DELTAMODE_PREV and revision data is requested,
         all revision data should be emitted as deltas against the revision
         emitted just prior. The initial revision should be a delta against its
         1st parent.
         """
 
 
 class ifilemutation(Protocol):
     """Storage interface for mutation events of a tracked file."""
 
     def add(self, filedata, meta, transaction, linkrev, p1, p2):
         """Add a new revision to the store.
 
         Takes file data, dictionary of metadata, a transaction, linkrev,
         and parent nodes.
 
         Returns the node that was added.
 
         May no-op if a revision matching the supplied data is already stored.
         """
 
     def addrevision(
         self,
         revisiondata,
         transaction,
         linkrev,
         p1,
         p2,
         node=None,
         flags=0,
         cachedelta=None,
     ):
         """Add a new revision to the store and return its number.
 
         This is similar to ``add()`` except it operates at a lower level.
 
         The data passed in already contains a metadata header, if any.
 
         ``node`` and ``flags`` can be used to define the expected node and
         the flags to use with storage. ``flags`` is a bitwise value composed
         of the various ``REVISION_FLAG_*`` constants.
 
         ``add()`` is usually called when adding files from e.g. the working
         directory. ``addrevision()`` is often called by ``add()`` and for
         scenarios where revision data has already been computed, such as when
         applying raw data from a peer repo.
         """
 
     def addgroup(
         self,
         deltas,
         linkmapper,
         transaction,
         addrevisioncb=None,
         duplicaterevisioncb=None,
         maybemissingparents=False,
     ):
         """Process a series of deltas for storage.
 
         ``deltas`` is an iterable of 7-tuples of
         (node, p1, p2, linknode, deltabase, delta, flags) defining revisions
         to add.
 
         The ``delta`` field contains ``mpatch`` data to apply to a base
         revision, identified by ``deltabase``. The base node can be
         ``nullid``, in which case the header from the delta can be ignored
         and the delta used as the fulltext.
 
         ``alwayscache`` instructs the lower layers to cache the content of the
         newly added revision, even if it needs to be explicitly computed.
         This used to be the default when ``addrevisioncb`` was provided up to
         Mercurial 5.8.
 
         ``addrevisioncb`` should be called for each new rev as it is committed.
         ``duplicaterevisioncb`` should be called for all revs with a
         pre-existing node.
 
         ``maybemissingparents`` is a bool indicating whether the incoming
         data may reference parents/ancestor revisions that aren't present.
         This flag is set when receiving data into a "shallow" store that
         doesn't hold all history.
 
         Returns a list of nodes that were processed. A node will be in the list
         even if it existed in the store previously.
         """
 
     def censorrevision(self, tr, node, tombstone=b''):
         """Remove the content of a single revision.
 
         The specified ``node`` will have its content purged from storage.
         Future attempts to access the revision data for this node will
         result in failure.
 
         A ``tombstone`` message can optionally be stored. This message may be
         displayed to users when they attempt to access the missing revision
         data.
 
         Storage backends may have stored deltas against the previous content
         in this revision. As part of censoring a revision, these storage
         backends are expected to rewrite any internally stored deltas such
         that they no longer reference the deleted content.
         """
 
     def getstrippoint(self, minlink):
         """Find the minimum revision that must be stripped to strip a linkrev.
 
         Returns a 2-tuple containing the minimum revision number and a set
         of all revisions numbers that would be broken by this strip.
 
         TODO this is highly revlog centric and should be abstracted into
         a higher-level deletion API. ``repair.strip()`` relies on this.
         """
 
     def strip(self, minlink, transaction):
         """Remove storage of items starting at a linkrev.
 
         This uses ``getstrippoint()`` to determine the first node to remove.
         Then it effectively truncates storage for all revisions after that.
 
         TODO this is highly revlog centric and should be abstracted into a
         higher-level deletion API.
         """
 
 
 class ifilestorage(ifileindex, ifiledata, ifilemutation):
     """Complete storage interface for a single tracked file."""
 
     def files(self):
         """Obtain paths that are backing storage for this file.
 
         TODO this is used heavily by verify code and there should probably
         be a better API for that.
         """
 
     def storageinfo(
         self,
         exclusivefiles=False,
         sharedfiles=False,
         revisionscount=False,
         trackedsize=False,
         storedsize=False,
     ):
         """Obtain information about storage for this file's data.
 
         Returns a dict describing storage for this tracked path. The keys
         in the dict map to arguments of the same. The arguments are bools
         indicating whether to calculate and obtain that data.
 
         exclusivefiles
            Iterable of (vfs, path) describing files that are exclusively
            used to back storage for this tracked path.
 
         sharedfiles
            Iterable of (vfs, path) describing files that are used to back
            storage for this tracked path. Those files may also provide storage
            for other stored entities.
 
         revisionscount
            Number of revisions available for retrieval.
 
         trackedsize
            Total size in bytes of all tracked revisions. This is a sum of the
            length of the fulltext of all revisions.
 
         storedsize
            Total size in bytes used to store data for all tracked revisions.
            This is commonly less than ``trackedsize`` due to internal usage
            of deltas rather than fulltext revisions.
 
         Not all storage backends may support all queries are have a reasonable
         value to use. In that case, the value should be set to ``None`` and
         callers are expected to handle this special value.
         """
 
     def verifyintegrity(self, state):
         """Verifies the integrity of file storage.
 
         ``state`` is a dict holding state of the verifier process. It can be
         used to communicate data between invocations of multiple storage
         primitives.
 
         If individual revisions cannot have their revision content resolved,
         the method is expected to set the ``skipread`` key to a set of nodes
         that encountered problems.  If set, the method can also add the node(s)
         to ``safe_renamed`` in order to indicate nodes that may perform the
         rename checks with currently accessible data.
 
         The method yields objects conforming to the ``iverifyproblem``
         interface.
         """
 
 
 class idirs(Protocol):
     """Interface representing a collection of directories from paths.
 
     This interface is essentially a derived data structure representing
     directories from a collection of paths.
     """
 
     def addpath(self, path):
         """Add a path to the collection.
 
         All directories in the path will be added to the collection.
         """
 
     def delpath(self, path):
         """Remove a path from the collection.
 
         If the removal was the last path in a particular directory, the
         directory is removed from the collection.
         """
 
     def __iter__(self):
         """Iterate over the directories in this collection of paths."""
 
     def __contains__(self, path):
         """Whether a specific directory is in this collection."""
 
 
 class imanifestdict(Protocol):
     """Interface representing a manifest data structure.
 
     A manifest is effectively a dict mapping paths to entries. Each entry
     consists of a binary node and extra flags affecting that entry.
     """
 
     def __getitem__(self, path):
         """Returns the binary node value for a path in the manifest.
 
         Raises ``KeyError`` if the path does not exist in the manifest.
 
         Equivalent to ``self.find(path)[0]``.
         """
 
     def find(self, path):
         """Returns the entry for a path in the manifest.
 
         Returns a 2-tuple of (node, flags).
 
         Raises ``KeyError`` if the path does not exist in the manifest.
         """
 
     def __len__(self):
         """Return the number of entries in the manifest."""
 
     def __nonzero__(self):
         """Returns True if the manifest has entries, False otherwise."""
 
     __bool__ = __nonzero__
 
     def set(self, path, node, flags):
         """Define the node value and flags for a path in the manifest.
 
         Equivalent to __setitem__ followed by setflag, but can be more efficient.
         """
 
     def __setitem__(self, path, node):
         """Define the node value for a path in the manifest.
 
         If the path is already in the manifest, its flags will be copied to
         the new entry.
         """
 
     def __contains__(self, path):
         """Whether a path exists in the manifest."""
 
     def __delitem__(self, path):
         """Remove a path from the manifest.
 
         Raises ``KeyError`` if the path is not in the manifest.
         """
 
     def __iter__(self):
         """Iterate over paths in the manifest."""
 
     def iterkeys(self):
         """Iterate over paths in the manifest."""
 
     def keys(self):
         """Obtain a list of paths in the manifest."""
 
     def filesnotin(self, other, match=None):
         """Obtain the set of paths in this manifest but not in another.
 
         ``match`` is an optional matcher function to be applied to both
         manifests.
 
         Returns a set of paths.
         """
 
     def dirs(self):
         """Returns an object implementing the ``idirs`` interface."""
 
     def hasdir(self, dir):
         """Returns a bool indicating if a directory is in this manifest."""
 
     def walk(self, match):
         """Generator of paths in manifest satisfying a matcher.
 
         If the matcher has explicit files listed and they don't exist in
         the manifest, ``match.bad()`` is called for each missing file.
         """
 
     def diff(self, other, match=None, clean=False):
         """Find differences between this manifest and another.
 
         This manifest is compared to ``other``.
 
         If ``match`` is provided, the two manifests are filtered against this
         matcher and only entries satisfying the matcher are compared.
 
         If ``clean`` is True, unchanged files are included in the returned
         object.
 
         Returns a dict with paths as keys and values of 2-tuples of 2-tuples of
         the form ``((node1, flag1), (node2, flag2))`` where ``(node1, flag1)``
         represents the node and flags for this manifest and ``(node2, flag2)``
         are the same for the other manifest.
         """
 
     def setflag(self, path, flag):
         """Set the flag value for a given path.
 
         Raises ``KeyError`` if the path is not already in the manifest.
         """
 
     def get(self, path, default=None):
         """Obtain the node value for a path or a default value if missing."""
 
     def flags(self, path):
         """Return the flags value for a path (default: empty bytestring)."""
 
     def copy(self):
         """Return a copy of this manifest."""
 
     def items(self):
         """Returns an iterable of (path, node) for items in this manifest."""
 
     def iteritems(self):
         """Identical to items()."""
 
     def iterentries(self):
         """Returns an iterable of (path, node, flags) for this manifest.
 
         Similar to ``iteritems()`` except items are a 3-tuple and include
         flags.
         """
 
     def text(self):
         """Obtain the raw data representation for this manifest.
 
         Result is used to create a manifest revision.
         """
 
     def fastdelta(self, base, changes):
         """Obtain a delta between this manifest and another given changes.
 
         ``base`` in the raw data representation for another manifest.
 
         ``changes`` is an iterable of ``(path, to_delete)``.
 
         Returns a 2-tuple containing ``bytearray(self.text())`` and the
         delta between ``base`` and this manifest.
 
         If this manifest implementation can't support ``fastdelta()``,
         raise ``mercurial.manifest.FastdeltaUnavailable``.
         """
 
 
 class imanifestrevisionbase(Protocol):
     """Base interface representing a single revision of a manifest.
 
     Should not be used as a primary interface: should always be inherited
     as part of a larger interface.
     """
 
     def copy(self):
         """Obtain a copy of this manifest instance.
 
         Returns an object conforming to the ``imanifestrevisionwritable``
         interface. The instance will be associated with the same
         ``imanifestlog`` collection as this instance.
         """
 
     def read(self):
         """Obtain the parsed manifest data structure.
 
         The returned object conforms to the ``imanifestdict`` interface.
         """
 
 
 class imanifestrevisionstored(imanifestrevisionbase):
     """Interface representing a manifest revision committed to storage."""
 
-    def node(self):
+    def node(self) -> bytes:
         """The binary node for this manifest."""
 
     parents: list[bytes]
     """List of binary nodes that are parents for this manifest revision."""
 
-    def readdelta(self, shallow=False):
+    def readdelta(self, shallow: bool = False):
         """Obtain the manifest data structure representing changes from parent.
 
         This manifest is compared to its 1st parent. A new manifest
         representing those differences is constructed.
 
         If `shallow` is True, this will read the delta for this directory,
         without recursively reading subdirectory manifests. Instead, any
         subdirectory entry will be reported as it appears in the manifest, i.e.
         the subdirectory will be reported among files and distinguished only by
         its 't' flag. This only apply if the underlying manifest support it.
 
         The returned object conforms to the ``imanifestdict`` interface.
         """
 
-    def read_any_fast_delta(self, valid_bases=None, *, shallow=False):
+    def read_any_fast_delta(
+        self,
+        valid_bases: Collection[int] | None = None,
+        *,
+        shallow: bool = False,
+    ):
         """read some manifest information as fast if possible
 
         This might return a "delta", a manifest object containing only file
         changed compared to another revisions. The `valid_bases` argument
         control the set of revision that might be used as a base.
 
         If no delta can be retrieved quickly, a full read of the manifest will
         be performed instead.
 
         The function return a tuple with two elements. The first one is the
         delta base used (or None if we did a full read), the second one is the
         manifest information.
 
         If `shallow` is True, this will read the delta for this directory,
         without recursively reading subdirectory manifests. Instead, any
         subdirectory entry will be reported as it appears in the manifest, i.e.
         the subdirectory will be reported among files and distinguished only by
         its 't' flag. This only apply if the underlying manifest support it.
 
         The returned object conforms to the ``imanifestdict`` interface.
         """
 
-    def read_delta_parents(self, *, shallow=False, exact=True):
+    def read_delta_parents(self, *, shallow: bool = False, exact: bool = True):
         """return a diff from this revision against both parents.
 
         If `exact` is False, this might return a superset of the diff, containing
         files that are actually present as is in one of the parents.
 
         If `shallow` is True, this will read the delta for this directory,
         without recursively reading subdirectory manifests. Instead, any
         subdirectory entry will be reported as it appears in the manifest, i.e.
         the subdirectory will be reported among files and distinguished only by
         its 't' flag. This only apply if the underlying manifest support it.
 
         The returned object conforms to the ``imanifestdict`` interface."""
 
-    def read_delta_new_entries(self, *, shallow=False):
+    def read_delta_new_entries(self, *, shallow: bool = False):
         """Return a manifest containing just the entries that might be new to
         the repository.
 
         This is often equivalent to a diff against both parents, but without
         garantee. For performance reason, It might contains more files in some cases.
 
         If `shallow` is True, this will read the delta for this directory,
         without recursively reading subdirectory manifests. Instead, any
         subdirectory entry will be reported as it appears in the manifest, i.e.
         the subdirectory will be reported among files and distinguished only by
         its 't' flag. This only apply if the underlying manifest support it.
 
         The returned object conforms to the ``imanifestdict`` interface."""
 
-    def readfast(self, shallow=False):
+    def readfast(self, shallow: bool = False):
         """Calls either ``read()`` or ``readdelta()``.
 
         The faster of the two options is called.
         """
 
-    def find(self, key):
+    def find(self, key: bytes) -> tuple[bytes, bytes]:
         """Calls self.read().find(key)``.
 
         Returns a 2-tuple of ``(node, flags)`` or raises ``KeyError``.
         """
 
 
 class imanifestrevisionwritable(imanifestrevisionbase):
     """Interface representing a manifest revision that can be committed."""
 
     def write(
         self, transaction, linkrev, p1node, p2node, added, removed, match=None
     ):
         """Add this revision to storage.
 
         Takes a transaction object, the changeset revision number it will
         be associated with, its parent nodes, and lists of added and
         removed paths.
 
         If match is provided, storage can choose not to inspect or write out
         items that do not match. Storage is still required to be able to provide
         the full manifest in the future for any directories written (these
         manifests should not be "narrowed on disk").
 
         Returns the binary node of the created revision.
         """
 
 
 class imanifeststorage(Protocol):
     """Storage interface for manifest data."""
 
     nodeconstants = interfaceutil.Attribute(
         """nodeconstants used by the current repository."""
     )
 
     tree = interfaceutil.Attribute(
         """The path to the directory this manifest tracks.
 
         The empty bytestring represents the root manifest.
         """
     )
 
     index = interfaceutil.Attribute(
         """An ``ifilerevisionssequence`` instance."""
     )
 
     opener = interfaceutil.Attribute(
         """VFS opener to use to access underlying files used for storage.
 
         TODO this is revlog specific and should not be exposed.
         """
     )
 
     fulltextcache = interfaceutil.Attribute(
         """Dict with cache of fulltexts.
 
         TODO this doesn't feel appropriate for the storage interface.
         """
     )
 
     def __len__(self):
         """Obtain the number of revisions stored for this manifest."""
 
     def __iter__(self):
         """Iterate over revision numbers for this manifest."""
 
     def rev(self, node):
         """Obtain the revision number given a binary node.
 
         Raises ``error.LookupError`` if the node is not known.
         """
 
     def node(self, rev):
         """Obtain the node value given a revision number.
 
         Raises ``error.LookupError`` if the revision is not known.
         """
 
     def lookup(self, value):
         """Attempt to resolve a value to a node.
 
         Value can be a binary node, hex node, revision number, or a bytes
         that can be converted to an integer.
 
         Raises ``error.LookupError`` if a ndoe could not be resolved.
         """
 
     def parents(self, node):
         """Returns a 2-tuple of parent nodes for a node.
 
         Values will be ``nullid`` if the parent is empty.
         """
 
     def parentrevs(self, rev):
         """Like parents() but operates on revision numbers."""
 
     def linkrev(self, rev):
         """Obtain the changeset revision number a revision is linked to."""
 
     def revision(self, node):
         """Obtain fulltext data for a node."""
 
     def rawdata(self, node):
         """Obtain raw data for a node."""
 
     def revdiff(self, rev1, rev2):
         """Obtain a delta between two revision numbers.
 
         The returned data is the result of ``bdiff.bdiff()`` on the raw
         revision data.
         """
 
     def cmp(self, node, fulltext):
         """Compare fulltext to another revision.
 
         Returns True if the fulltext is different from what is stored.
         """
 
     def emitrevisions(
         self,
         nodes,
         nodesorder=None,
         revisiondata=False,
         assumehaveparentrevisions=False,
     ):
         """Produce ``irevisiondelta`` describing revisions.
 
         See the documentation for ``ifiledata`` for more.
         """
 
     def addgroup(
         self,
         deltas,
         linkmapper,
         transaction,
         addrevisioncb=None,
         duplicaterevisioncb=None,
     ):
         """Process a series of deltas for storage.
 
         See the documentation in ``ifilemutation`` for more.
         """
 
     def rawsize(self, rev):
         """Obtain the size of tracked data.
 
         Is equivalent to ``len(m.rawdata(node))``.
 
         TODO this method is only used by upgrade code and may be removed.
         """
 
     def getstrippoint(self, minlink):
         """Find minimum revision that must be stripped to strip a linkrev.
 
         See the documentation in ``ifilemutation`` for more.
         """
 
     def strip(self, minlink, transaction):
         """Remove storage of items starting at a linkrev.
 
         See the documentation in ``ifilemutation`` for more.
         """
 
     def checksize(self):
         """Obtain the expected sizes of backing files.
 
         TODO this is used by verify and it should not be part of the interface.
         """
 
     def files(self):
         """Obtain paths that are backing storage for this manifest.
 
         TODO this is used by verify and there should probably be a better API
         for this functionality.
         """
 
     def deltaparent(self, rev):
         """Obtain the revision that a revision is delta'd against.
 
         TODO delta encoding is an implementation detail of storage and should
         not be exposed to the storage interface.
         """
 
     def clone(self, tr, dest, **kwargs):
         """Clone this instance to another."""
 
     def clearcaches(self, clear_persisted_data=False):
         """Clear any caches associated with this instance."""
 
     def dirlog(self, d):
         """Obtain a manifest storage instance for a tree."""
 
     def add(
         self,
         m,
         transaction,
         link,
         p1,
         p2,
         added,
         removed,
         readtree=None,
         match=None,
     ):
         """Add a revision to storage.
 
         ``m`` is an object conforming to ``imanifestdict``.
 
         ``link`` is the linkrev revision number.
 
         ``p1`` and ``p2`` are the parent revision numbers.
 
         ``added`` and ``removed`` are iterables of added and removed paths,
         respectively.
 
         ``readtree`` is a function that can be used to read the child tree(s)
         when recursively writing the full tree structure when using
         treemanifets.
 
         ``match`` is a matcher that can be used to hint to storage that not all
         paths must be inspected; this is an optimization and can be safely
         ignored. Note that the storage must still be able to reproduce a full
         manifest including files that did not match.
         """
 
     def storageinfo(
         self,
         exclusivefiles=False,
         sharedfiles=False,
         revisionscount=False,
         trackedsize=False,
         storedsize=False,
     ):
         """Obtain information about storage for this manifest's data.
 
         See ``ifilestorage.storageinfo()`` for a description of this method.
         This one behaves the same way, except for manifest data.
         """
 
     def get_revlog(self):
         """return an actual revlog instance if any
 
         This exist because a lot of code leverage the fact the underlying
         storage is a revlog for optimization, so giving simple way to access
         the revlog instance helps such code.
         """
 
 
 class imanifestlog(Protocol):
     """Interface representing a collection of manifest snapshots.
 
     Represents the root manifest in a repository.
 
     Also serves as a means to access nested tree manifests and to cache
     tree manifests.
     """
 
     nodeconstants = interfaceutil.Attribute(
         """nodeconstants used by the current repository."""
     )
 
     narrowed = interfaceutil.Attribute(
         """True, is the manifest is narrowed by a matcher"""
     )
 
     def __getitem__(self, node):
         """Obtain a manifest instance for a given binary node.
 
         Equivalent to calling ``self.get('', node)``.
 
         The returned object conforms to the ``imanifestrevisionstored``
         interface.
         """
 
     def get(self, tree, node, verify=True):
         """Retrieve the manifest instance for a given directory and binary node.
 
         ``node`` always refers to the node of the root manifest (which will be
         the only manifest if flat manifests are being used).
 
         If ``tree`` is the empty string, the root manifest is returned.
         Otherwise the manifest for the specified directory will be returned
         (requires tree manifests).
 
         If ``verify`` is True, ``LookupError`` is raised if the node is not
         known.
 
         The returned object conforms to the ``imanifestrevisionstored``
         interface.
         """
 
     def getstorage(self, tree):
         """Retrieve an interface to storage for a particular tree.
 
         If ``tree`` is the empty bytestring, storage for the root manifest will
         be returned. Otherwise storage for a tree manifest is returned.
 
         TODO formalize interface for returned object.
         """
 
     def clearcaches(self, clear_persisted_data: bool = False) -> None:
         """Clear caches associated with this collection."""
 
     def rev(self, node):
         """Obtain the revision number for a binary node.
 
         Raises ``error.LookupError`` if the node is not known.
         """
 
     def update_caches(self, transaction):
         """update whatever cache are relevant for the used storage."""
 
 
 class ilocalrepositoryfilestorage(Protocol):
     """Local repository sub-interface providing access to tracked file storage.
 
     This interface defines how a repository accesses storage for a single
     tracked file path.
     """
 
     def file(self, f):
         """Obtain a filelog for a tracked path.
 
         The returned type conforms to the ``ifilestorage`` interface.
         """
 
 
 class ilocalrepositorymain(Protocol):
     """Main interface for local repositories.
 
     This currently captures the reality of things - not how things should be.
     """
 
     nodeconstants = interfaceutil.Attribute(
         """Constant nodes matching the hash function used by the repository."""
     )
     nullid = interfaceutil.Attribute(
         """null revision for the hash function used by the repository."""
     )
 
     supported = interfaceutil.Attribute(
         """Set of requirements that this repo is capable of opening."""
     )
 
     requirements = interfaceutil.Attribute(
         """Set of requirements this repo uses."""
     )
 
     features = interfaceutil.Attribute(
         """Set of "features" this repository supports.
 
         A "feature" is a loosely-defined term. It can refer to a feature
         in the classical sense or can describe an implementation detail
         of the repository. For example, a ``readonly`` feature may denote
         the repository as read-only. Or a ``revlogfilestore`` feature may
         denote that the repository is using revlogs for file storage.
 
         The intent of features is to provide a machine-queryable mechanism
         for repo consumers to test for various repository characteristics.
 
         Features are similar to ``requirements``. The main difference is that
         requirements are stored on-disk and represent requirements to open the
         repository. Features are more run-time capabilities of the repository
         and more granular capabilities (which may be derived from requirements).
         """
     )
 
     filtername = interfaceutil.Attribute(
         """Name of the repoview that is active on this repo."""
     )
 
     vfs_map = interfaceutil.Attribute(
         """a bytes-key → vfs mapping used by transaction and others"""
     )
 
     wvfs = interfaceutil.Attribute(
         """VFS used to access the working directory."""
     )
 
     vfs = interfaceutil.Attribute(
         """VFS rooted at the .hg directory.
 
         Used to access repository data not in the store.
         """
     )
 
     svfs = interfaceutil.Attribute(
         """VFS rooted at the store.
 
         Used to access repository data in the store. Typically .hg/store.
         But can point elsewhere if the store is shared.
         """
     )
 
     root = interfaceutil.Attribute(
         """Path to the root of the working directory."""
     )
 
     path = interfaceutil.Attribute("""Path to the .hg directory.""")
 
     origroot = interfaceutil.Attribute(
         """The filesystem path that was used to construct the repo."""
     )
 
     auditor = interfaceutil.Attribute(
         """A pathauditor for the working directory.
 
         This checks if a path refers to a nested repository.
 
         Operates on the filesystem.
         """
     )
 
     nofsauditor = interfaceutil.Attribute(
         """A pathauditor for the working directory.
 
         This is like ``auditor`` except it doesn't do filesystem checks.
         """
     )
 
     baseui = interfaceutil.Attribute(
         """Original ui instance passed into constructor."""
     )
 
     ui = interfaceutil.Attribute("""Main ui instance for this instance.""")
 
     sharedpath = interfaceutil.Attribute(
         """Path to the .hg directory of the repo this repo was shared from."""
     )
 
     store = interfaceutil.Attribute("""A store instance.""")
 
     spath = interfaceutil.Attribute("""Path to the store.""")
 
     sjoin = interfaceutil.Attribute("""Alias to self.store.join.""")
 
     cachevfs = interfaceutil.Attribute(
         """A VFS used to access the cache directory.
 
         Typically .hg/cache.
         """
     )
 
     wcachevfs = interfaceutil.Attribute(
         """A VFS used to access the cache directory dedicated to working copy
 
         Typically .hg/wcache.
         """
     )
 
     filteredrevcache = interfaceutil.Attribute(
         """Holds sets of revisions to be filtered."""
     )
 
     names = interfaceutil.Attribute("""A ``namespaces`` instance.""")
 
     filecopiesmode = interfaceutil.Attribute(
         """The way files copies should be dealt with in this repo."""
     )
 
     def close(self):
         """Close the handle on this repository."""
 
     def peer(self, path=None):
         """Obtain an object conforming to the ``peer`` interface."""
 
     def unfiltered(self):
         """Obtain an unfiltered/raw view of this repo."""
 
     def filtered(self, name, visibilityexceptions=None):
         """Obtain a named view of this repository."""
 
     obsstore = interfaceutil.Attribute("""A store of obsolescence data.""")
 
     changelog = interfaceutil.Attribute("""A handle on the changelog revlog.""")
 
     manifestlog = interfaceutil.Attribute(
         """An instance conforming to the ``imanifestlog`` interface.
 
         Provides access to manifests for the repository.
         """
     )
 
     dirstate = interfaceutil.Attribute("""Working directory state.""")
 
     narrowpats = interfaceutil.Attribute(
         """Matcher patterns for this repository's narrowspec."""
     )
 
     def narrowmatch(self, match=None, includeexact=False):
         """Obtain a matcher for the narrowspec."""
 
     def setnarrowpats(self, newincludes, newexcludes):
         """Define the narrowspec for this repository."""
 
     def __getitem__(self, changeid):
         """Try to resolve a changectx."""
 
     def __contains__(self, changeid):
         """Whether a changeset exists."""
 
     def __nonzero__(self):
         """Always returns True."""
         return True
 
     __bool__ = __nonzero__
 
     def __len__(self):
         """Returns the number of changesets in the repo."""
 
     def __iter__(self):
         """Iterate over revisions in the changelog."""
 
     def revs(self, expr, *args):
         """Evaluate a revset.
 
         Emits revisions.
         """
 
     def set(self, expr, *args):
         """Evaluate a revset.
 
         Emits changectx instances.
         """
 
     def anyrevs(self, specs, user=False, localalias=None):
         """Find revisions matching one of the given revsets."""
 
     def url(self):
         """Returns a string representing the location of this repo."""
 
     def hook(self, name, throw=False, **args):
         """Call a hook."""
 
     def tags(self):
         """Return a mapping of tag to node."""
 
     def tagtype(self, tagname):
         """Return the type of a given tag."""
 
     def tagslist(self):
         """Return a list of tags ordered by revision."""
 
     def nodetags(self, node):
         """Return the tags associated with a node."""
 
     def nodebookmarks(self, node):
         """Return the list of bookmarks pointing to the specified node."""
 
     def branchmap(self):
         """Return a mapping of branch to heads in that branch."""
 
     def revbranchcache(self):
         pass
 
     def register_changeset(self, rev, changelogrevision):
         """Extension point for caches for new nodes.
 
         Multiple consumers are expected to need parts of the changelogrevision,
         so it is provided as optimization to avoid duplicate lookups. A simple
         cache would be fragile when other revisions are accessed, too."""
         pass
 
     def branchtip(self, branchtip, ignoremissing=False):
         """Return the tip node for a given branch."""
 
     def lookup(self, key):
         """Resolve the node for a revision."""
 
     def lookupbranch(self, key):
         """Look up the branch name of the given revision or branch name."""
 
     def known(self, nodes):
         """Determine whether a series of nodes is known.
 
         Returns a list of bools.
         """
 
     def local(self):
         """Whether the repository is local."""
         return True
 
     def publishing(self):
         """Whether the repository is a publishing repository."""
 
     def cancopy(self):
         pass
 
     def shared(self):
         """The type of shared repository or None."""
 
     def wjoin(self, f, *insidef):
         """Calls self.vfs.reljoin(self.root, f, *insidef)"""
 
     def setparents(self, p1, p2):
         """Set the parent nodes of the working directory."""
 
     def filectx(self, path, changeid=None, fileid=None):
         """Obtain a filectx for the given file revision."""
 
     def getcwd(self):
         """Obtain the current working directory from the dirstate."""
 
     def pathto(self, f, cwd=None):
         """Obtain the relative path to a file."""
 
     def adddatafilter(self, name, fltr):
         pass
 
     def wread(self, filename):
         """Read a file from wvfs, using data filters."""
 
     def wwrite(self, filename, data, flags, backgroundclose=False, **kwargs):
         """Write data to a file in the wvfs, using data filters."""
 
     def wwritedata(self, filename, data):
         """Resolve data for writing to the wvfs, using data filters."""
 
     def currenttransaction(self):
         """Obtain the current transaction instance or None."""
 
     def transaction(self, desc, report=None):
         """Open a new transaction to write to the repository."""
 
     def undofiles(self):
         """Returns a list of (vfs, path) for files to undo transactions."""
 
     def recover(self):
         """Roll back an interrupted transaction."""
 
     def rollback(self, dryrun=False, force=False):
         """Undo the last transaction.
 
         DANGEROUS.
         """
 
     def updatecaches(self, tr=None, full=False, caches=None):
         """Warm repo caches."""
 
     def invalidatecaches(self):
         """Invalidate cached data due to the repository mutating."""
 
     def invalidatevolatilesets(self):
         pass
 
     def invalidatedirstate(self):
         """Invalidate the dirstate."""
 
     def invalidate(self, clearfilecache=False):
         pass
 
     def invalidateall(self):
         pass
 
     def lock(self, wait=True):
         """Lock the repository store and return a lock instance."""
 
     def currentlock(self):
         """Return the lock if it's held or None."""
 
     def wlock(self, wait=True):
         """Lock the non-store parts of the repository."""
 
     def currentwlock(self):
         """Return the wlock if it's held or None."""
 
     def checkcommitpatterns(self, wctx, match, status, fail):
         pass
 
     def commit(
         self,
         text=b'',
         user=None,
         date=None,
         match=None,
         force=False,
         editor=False,
         extra=None,
     ):
         """Add a new revision to the repository."""
 
     def commitctx(self, ctx, error=False, origctx=None):
         """Commit a commitctx instance to the repository."""
 
     def destroying(self):
         """Inform the repository that nodes are about to be destroyed."""
 
     def destroyed(self):
         """Inform the repository that nodes have been destroyed."""
 
     def status(
         self,
         node1=b'.',
         node2=None,
         match=None,
         ignored=False,
         clean=False,
         unknown=False,
         listsubrepos=False,
     ):
         """Convenience method to call repo[x].status()."""
 
     def addpostdsstatus(self, ps):
         pass
 
     def postdsstatus(self):
         pass
 
     def clearpostdsstatus(self):
         pass
 
     def heads(self, start=None):
         """Obtain list of nodes that are DAG heads."""
 
     def branchheads(self, branch=None, start=None, closed=False):
         pass
 
     def branches(self, nodes):
         pass
 
     def between(self, pairs):
         pass
 
     def checkpush(self, pushop):
         pass
 
     prepushoutgoinghooks = interfaceutil.Attribute("""util.hooks instance.""")
 
     def pushkey(self, namespace, key, old, new):
         pass
 
     def listkeys(self, namespace):
         pass
 
     def debugwireargs(self, one, two, three=None, four=None, five=None):
         pass
 
     def savecommitmessage(self, text):
         pass
 
     def register_sidedata_computer(
         self, kind, category, keys, computer, flags, replace=False
     ):
         pass
 
     def register_wanted_sidedata(self, category):
         pass
 
 
 class completelocalrepository(
     ilocalrepositorymain, ilocalrepositoryfilestorage
 ):
     """Complete interface for a local repository."""
 
 
 class iwireprotocolcommandcacher(Protocol):
     """Represents a caching backend for wire protocol commands.
 
     Wire protocol version 2 supports transparent caching of many commands.
     To leverage this caching, servers can activate objects that cache
     command responses. Objects handle both cache writing and reading.
     This interface defines how that response caching mechanism works.
 
     Wire protocol version 2 commands emit a series of objects that are
     serialized and sent to the client. The caching layer exists between
     the invocation of the command function and the sending of its output
     objects to an output layer.
 
     Instances of this interface represent a binding to a cache that
     can serve a response (in place of calling a command function) and/or
     write responses to a cache for subsequent use.
 
     When a command request arrives, the following happens with regards
     to this interface:
 
     1. The server determines whether the command request is cacheable.
     2. If it is, an instance of this interface is spawned.
     3. The cacher is activated in a context manager (``__enter__`` is called).
     4. A cache *key* for that request is derived. This will call the
        instance's ``adjustcachekeystate()`` method so the derivation
        can be influenced.
     5. The cacher is informed of the derived cache key via a call to
        ``setcachekey()``.
     6. The cacher's ``lookup()`` method is called to test for presence of
        the derived key in the cache.
     7. If ``lookup()`` returns a hit, that cached result is used in place
        of invoking the command function. ``__exit__`` is called and the instance
        is discarded.
     8. The command function is invoked.
     9. ``onobject()`` is called for each object emitted by the command
        function.
     10. After the final object is seen, ``onfinished()`` is called.
     11. ``__exit__`` is called to signal the end of use of the instance.
 
     Cache *key* derivation can be influenced by the instance.
 
     Cache keys are initially derived by a deterministic representation of
     the command request. This includes the command name, arguments, protocol
     version, etc. This initial key derivation is performed by CBOR-encoding a
     data structure and feeding that output into a hasher.
 
     Instances of this interface can influence this initial key derivation
     via ``adjustcachekeystate()``.
 
     The instance is informed of the derived cache key via a call to
     ``setcachekey()``. The instance must store the key locally so it can
     be consulted on subsequent operations that may require it.
 
     When constructed, the instance has access to a callable that can be used
     for encoding response objects. This callable receives as its single
     argument an object emitted by a command function. It returns an iterable
     of bytes chunks representing the encoded object. Unless the cacher is
     caching native Python objects in memory or has a way of reconstructing
     the original Python objects, implementations typically call this function
     to produce bytes from the output objects and then store those bytes in
     the cache. When it comes time to re-emit those bytes, they are wrapped
     in a ``wireprototypes.encodedresponse`` instance to tell the output
     layer that they are pre-encoded.
 
     When receiving the objects emitted by the command function, instances
     can choose what to do with those objects. The simplest thing to do is
     re-emit the original objects. They will be forwarded to the output
     layer and will be processed as if the cacher did not exist.
 
     Implementations could also choose to not emit objects - instead locally
     buffering objects or their encoded representation. They could then emit
     a single "coalesced" object when ``onfinished()`` is called. In
     this way, the implementation would function as a filtering layer of
     sorts.
 
     When caching objects, typically the encoded form of the object will
     be stored. Keep in mind that if the original object is forwarded to
     the output layer, it will need to be encoded there as well. For large
     output, this redundant encoding could add overhead. Implementations
     could wrap the encoded object data in ``wireprototypes.encodedresponse``
     instances to avoid this overhead.
     """
 
     def __enter__(self):
         """Marks the instance as active.
 
         Should return self.
         """
 
     def __exit__(self, exctype, excvalue, exctb):
         """Called when cacher is no longer used.
 
         This can be used by implementations to perform cleanup actions (e.g.
         disconnecting network sockets, aborting a partially cached response.
         """
 
     def adjustcachekeystate(self, state):
         """Influences cache key derivation by adjusting state to derive key.
 
         A dict defining the state used to derive the cache key is passed.
 
         Implementations can modify this dict to record additional state that
         is wanted to influence key derivation.
 
         Implementations are *highly* encouraged to not modify or delete
         existing keys.
         """
 
     def setcachekey(self, key):
         """Record the derived cache key for this request.
 
         Instances may mutate the key for internal usage, as desired. e.g.
         instances may wish to prepend the repo name, introduce path
         components for filesystem or URL addressing, etc. Behavior is up to
         the cache.
 
         Returns a bool indicating if the request is cacheable by this
         instance.
         """
 
     def lookup(self):
         """Attempt to resolve an entry in the cache.
 
         The instance is instructed to look for the cache key that it was
         informed about via the call to ``setcachekey()``.
 
         If there's no cache hit or the cacher doesn't wish to use the cached
         entry, ``None`` should be returned.
 
         Else, a dict defining the cached result should be returned. The
         dict may have the following keys:
 
         objs
            An iterable of objects that should be sent to the client. That
            iterable of objects is expected to be what the command function
            would return if invoked or an equivalent representation thereof.
         """
 
     def onobject(self, obj):
         """Called when a new object is emitted from the command function.
 
         Receives as its argument the object that was emitted from the
         command function.
 
         This method returns an iterator of objects to forward to the output
         layer. The easiest implementation is a generator that just
         ``yield obj``.
         """
 
     def onfinished(self):
         """Called after all objects have been emitted from the command function.
 
         Implementations should return an iterator of objects to forward to
         the output layer.
 
         This method can be a generator.
         """

mercurial/manifest.py

@@ -1,2747 +1,2747
 # manifest.py - manifest revision class for mercurial
 #
 # Copyright 2005-2007 Olivia 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 annotations
 
 import heapq
 import itertools
 import struct
 import typing
 import weakref
 
 from typing import (
     Callable,
     Collection,
     Dict,
     Iterable,
     Iterator,
     List,
     Optional,
     Set,
     Tuple,
     Union,
     cast,
 )
 
 from .i18n import _
 from .node import (
     bin,
     hex,
     nullrev,
 )
 from . import (
     encoding,
     error,
     match as matchmod,
     mdiff,
     pathutil,
     policy,
     pycompat,
     revlog,
     util,
 )
 from .interfaces import (
     repository,
 )
 from .revlogutils import (
     constants as revlog_constants,
 )
 
 if typing.TYPE_CHECKING:
     from typing import (
         ByteString,
     )
 
 
 parsers = policy.importmod('parsers')
 propertycache = util.propertycache
 
 # Allow tests to more easily test the alternate path in manifestdict.fastdelta()
 FASTDELTA_TEXTDIFF_THRESHOLD = 1000
 
 
 def _parse(nodelen, data: bytes):
     # This method does a little bit of excessive-looking
     # precondition checking. This is so that the behavior of this
     # class exactly matches its C counterpart to try and help
     # prevent surprise breakage for anyone that develops against
     # the pure version.
     if data and data[-1:] != b'\n':
         raise ValueError(b'Manifest did not end in a newline.')
     prev = None
     for l in data.splitlines():
         if prev is not None and prev > l:
             raise ValueError(b'Manifest lines not in sorted order.')
         prev = l
         f, n = l.split(b'\0')
         nl = len(n)
         flags = n[-1:]
         if flags in _manifestflags:
             n = n[:-1]
             nl -= 1
         else:
             flags = b''
         if nl != 2 * nodelen:
             raise ValueError(b'Invalid manifest line')
 
         yield f, bin(n), flags
 
 
 def _text(it):
     files = []
     lines = []
     for f, n, fl in it:
         files.append(f)
         # if this is changed to support newlines in filenames,
         # be sure to check the templates/ dir again (especially *-raw.tmpl)
         lines.append(b"%s\0%s%s\n" % (f, hex(n), fl))
 
     _checkforbidden(files)
     return b''.join(lines)
 
 
 class lazymanifestiter:
     def __init__(self, lm: '_LazyManifest') -> None:
         self.pos = 0
         self.lm = lm
 
     def __iter__(self) -> 'lazymanifestiter':
         return self
 
     def next(self) -> bytes:
         try:
             data, pos = self.lm._get(self.pos)
         except IndexError:
             raise StopIteration
         if pos == -1:
             assert isinstance(data, tuple)
             self.pos += 1
             return data[0]
         assert isinstance(data, bytes)
         self.pos += 1
         zeropos = data.find(b'\x00', pos)
         return data[pos:zeropos]
 
     __next__ = next
 
 
 class lazymanifestiterentries:
     def __init__(self, lm: '_LazyManifest') -> None:
         self.lm = lm
         self.pos = 0
 
     def __iter__(self) -> 'lazymanifestiterentries':
         return self
 
     def next(self) -> Tuple[bytes, bytes, bytes]:
         try:
             data, pos = self.lm._get(self.pos)
         except IndexError:
             raise StopIteration
         if pos == -1:
             assert isinstance(data, tuple)
             self.pos += 1
             return data
         assert isinstance(data, bytes)
         zeropos = data.find(b'\x00', pos)
         nlpos = data.find(b'\n', pos)
         if zeropos == -1 or nlpos == -1 or nlpos < zeropos:
             raise error.StorageError(b'Invalid manifest line')
         flags = data[nlpos - 1 : nlpos]
         if flags in _manifestflags:
             hlen = nlpos - zeropos - 2
         else:
             hlen = nlpos - zeropos - 1
             flags = b''
         if hlen != 2 * self.lm._nodelen:
             raise error.StorageError(b'Invalid manifest line')
         hashval = unhexlify(
             data, self.lm.extrainfo[self.pos], zeropos + 1, hlen
         )
         self.pos += 1
         return (data[pos:zeropos], hashval, flags)
 
     __next__ = next
 
 
 def unhexlify(data: bytes, extra: int, pos, length: int):
     s = bin(data[pos : pos + length])
     if extra:
         s += bytes([extra & 0xFF])
     return s
 
 
 def _cmp(a, b):
     return (a > b) - (a < b)
 
 
 _manifestflags = {b'', b'l', b't', b'x'}
 
 
 class _LazyManifest:
     """A pure python manifest backed by a byte string.  It is supplimented with
     internal lists as it is modified, until it is compacted back to a pure byte
     string.
 
     ``data`` is the initial manifest data.
 
     ``positions`` is a list of offsets, one per manifest entry.  Positive
     values are offsets into ``data``, negative values are offsets into the
     ``extradata`` list.  When an entry is removed, its entry is dropped from
     ``positions``.  The values are encoded such that when walking the list and
     indexing into ``data`` or ``extradata`` as appropriate, the entries are
     sorted by filename.
 
     ``extradata`` is a list of (key, hash, flags) for entries that were added or
     modified since the manifest was created or compacted.
     """
 
     def __init__(
         self,
         nodelen: int,
         data: bytes,
         positions=None,
         extrainfo=None,
         extradata=None,
         hasremovals: bool = False,
     ):
         self._nodelen = nodelen
         if positions is None:
             self.positions = self.findlines(data)
             self.extrainfo = [0] * len(self.positions)
             self.data = data
             self.extradata = []
             self.hasremovals = False
         else:
             self.positions = positions[:]
             self.extrainfo = extrainfo[:]
             self.extradata = extradata[:]
             self.data = data
             self.hasremovals = hasremovals
 
     def findlines(self, data: bytes) -> List[int]:
         if not data:
             return []
         pos = data.find(b"\n")
         if pos == -1 or data[-1:] != b'\n':
             raise ValueError(b"Manifest did not end in a newline.")
         positions = [0]
         prev = data[: data.find(b'\x00')]
         while pos < len(data) - 1 and pos != -1:
             positions.append(pos + 1)
             nexts = data[pos + 1 : data.find(b'\x00', pos + 1)]
             if nexts < prev:
                 raise ValueError(b"Manifest lines not in sorted order.")
             prev = nexts
             pos = data.find(b"\n", pos + 1)
         return positions
 
     def _get(
         self, index: int
     ) -> Tuple[Union[bytes, Tuple[bytes, bytes, bytes]], int]:
         # get the position encoded in pos:
         #   positive number is an index in 'data'
         #   negative number is in extrapieces
         pos = self.positions[index]
         if pos >= 0:
             return self.data, pos
         return self.extradata[-pos - 1], -1
 
     def _getkey(self, pos) -> bytes:
         if pos >= 0:
             return self.data[pos : self.data.find(b'\x00', pos + 1)]
         return self.extradata[-pos - 1][0]
 
     def bsearch(self, key: bytes) -> int:
         first = 0
         last = len(self.positions) - 1
 
         while first <= last:
             midpoint = (first + last) // 2
             nextpos = self.positions[midpoint]
             candidate = self._getkey(nextpos)
             r = _cmp(key, candidate)
             if r == 0:
                 return midpoint
             else:
                 if r < 0:
                     last = midpoint - 1
                 else:
                     first = midpoint + 1
         return -1
 
     def bsearch2(self, key: bytes) -> Tuple[int, bool]:
         # same as the above, but will always return the position
         # done for performance reasons
         first = 0
         last = len(self.positions) - 1
 
         while first <= last:
             midpoint = (first + last) // 2
             nextpos = self.positions[midpoint]
             candidate = self._getkey(nextpos)
             r = _cmp(key, candidate)
             if r == 0:
                 return (midpoint, True)
             else:
                 if r < 0:
                     last = midpoint - 1
                 else:
                     first = midpoint + 1
         return (first, False)
 
     def __contains__(self, key: bytes) -> bool:
         return self.bsearch(key) != -1
 
     def __getitem__(self, key: bytes) -> Tuple[bytes, bytes]:
         if not isinstance(key, bytes):
             raise TypeError(b"getitem: manifest keys must be a bytes.")
         needle = self.bsearch(key)
         if needle == -1:
             raise KeyError
         data, pos = self._get(needle)
         if pos == -1:
             assert isinstance(data, tuple)
             return (data[1], data[2])
 
         assert isinstance(data, bytes)
         zeropos = data.find(b'\x00', pos)
         nlpos = data.find(b'\n', zeropos)
         assert 0 <= needle <= len(self.positions)
         assert len(self.extrainfo) == len(self.positions)
         if zeropos == -1 or nlpos == -1 or nlpos < zeropos:
             raise error.StorageError(b'Invalid manifest line')
         hlen = nlpos - zeropos - 1
         flags = data[nlpos - 1 : nlpos]
         if flags in _manifestflags:
             hlen -= 1
         else:
             flags = b''
         if hlen != 2 * self._nodelen:
             raise error.StorageError(b'Invalid manifest line')
         hashval = unhexlify(data, self.extrainfo[needle], zeropos + 1, hlen)
         return (hashval, flags)
 
     def __delitem__(self, key: bytes) -> None:
         needle, found = self.bsearch2(key)
         if not found:
             raise KeyError
         cur = self.positions[needle]
         self.positions = self.positions[:needle] + self.positions[needle + 1 :]
         self.extrainfo = self.extrainfo[:needle] + self.extrainfo[needle + 1 :]
         if cur >= 0:
             # This does NOT unsort the list as far as the search functions are
             # concerned, as they only examine lines mapped by self.positions.
             self.data = self.data[:cur] + b'\x00' + self.data[cur + 1 :]
             self.hasremovals = True
 
     def __setitem__(self, key: bytes, value: Tuple[bytes, bytes]):
         if not isinstance(key, bytes):
             raise TypeError(b"setitem: manifest keys must be a byte string.")
         if not isinstance(value, tuple) or len(value) != 2:
             raise TypeError(
                 b"Manifest values must be a tuple of (node, flags)."
             )
         hashval = value[0]
         if not isinstance(hashval, bytes) or len(hashval) not in (20, 32):
             raise TypeError(b"node must be a 20-byte or 32-byte byte string")
         flags = value[1]
         if not isinstance(flags, bytes) or len(flags) > 1:
             raise TypeError(b"flags must a 0 or 1 byte string, got %r", flags)
         needle, found = self.bsearch2(key)
         if found:
             # put the item
             pos = self.positions[needle]
             if pos < 0:
                 self.extradata[-pos - 1] = (key, hashval, value[1])
             else:
                 # just don't bother
                 self.extradata.append((key, hashval, value[1]))
                 self.positions[needle] = -len(self.extradata)
         else:
             # not found, put it in with extra positions
             self.extradata.append((key, hashval, value[1]))
             self.positions = (
                 self.positions[:needle]
                 + [-len(self.extradata)]
                 + self.positions[needle:]
             )
             self.extrainfo = (
                 self.extrainfo[:needle] + [0] + self.extrainfo[needle:]
             )
 
     def copy(self) -> '_LazyManifest':
         # XXX call _compact like in C?
         return _lazymanifest(
             self._nodelen,
             self.data,
             self.positions,
             self.extrainfo,
             self.extradata,
             self.hasremovals,
         )
 
     def _compact(self) -> None:
         # hopefully not called TOO often
         if len(self.extradata) == 0 and not self.hasremovals:
             return
         l = []
         i = 0
         offset = 0
         self.extrainfo = [0] * len(self.positions)
         while i < len(self.positions):
             if self.positions[i] >= 0:
                 cur = self.positions[i]
                 last_cut = cur
 
                 # Collect all contiguous entries in the buffer at the current
                 # offset, breaking out only for added/modified items held in
                 # extradata, or a deleted line prior to the next position.
                 while True:
                     self.positions[i] = offset
                     i += 1
                     if i == len(self.positions) or self.positions[i] < 0:
                         break
 
                     # A removed file has no positions[] entry, but does have an
                     # overwritten first byte.  Break out and find the end of the
                     # current good entry/entries if there is a removed file
                     # before the next position.
                     if (
                         self.hasremovals
                         and self.data.find(b'\n\x00', cur, self.positions[i])
                         != -1
                     ):
                         break
 
                     offset += self.positions[i] - cur
                     cur = self.positions[i]
                 end_cut = self.data.find(b'\n', cur)
                 if end_cut != -1:
                     end_cut += 1
                 offset += end_cut - cur
                 l.append(self.data[last_cut:end_cut])
             else:
                 while i < len(self.positions) and self.positions[i] < 0:
                     cur = self.positions[i]
                     t = self.extradata[-cur - 1]
                     l.append(self._pack(t))
                     self.positions[i] = offset
                     # Hashes are either 20 bytes (old sha1s) or 32
                     # bytes (new non-sha1).
                     hlen = 20
                     if len(t[1]) > 25:
                         hlen = 32
                     if len(t[1]) > hlen:
                         self.extrainfo[i] = ord(t[1][hlen + 1])
                     offset += len(l[-1])
                     i += 1
         self.data = b''.join(l)
         self.hasremovals = False
         self.extradata = []
 
     def _pack(self, d: Tuple[bytes, bytes, bytes]) -> bytes:
         n = d[1]
         assert len(n) in (20, 32)
         return d[0] + b'\x00' + hex(n) + d[2] + b'\n'
 
     def text(self) -> ByteString:
         self._compact()
         return self.data
 
     def diff(
         self, m2: '_LazyManifest', clean: bool = False
     ) -> Dict[
         bytes,
         Optional[
             Tuple[Tuple[Optional[bytes], bytes], Tuple[Optional[bytes], bytes]]
         ],
     ]:
         '''Finds changes between the current manifest and m2.'''
         # XXX think whether efficiency matters here
         diff = {}
 
         for fn, e1, flags in self.iterentries():
             if fn not in m2:
                 diff[fn] = (e1, flags), (None, b'')
             else:
                 e2 = m2[fn]
                 if (e1, flags) != e2:
                     diff[fn] = (e1, flags), e2
                 elif clean:
                     diff[fn] = None
 
         for fn, e2, flags in m2.iterentries():
             if fn not in self:
                 diff[fn] = (None, b''), (e2, flags)
 
         return diff
 
     def iterentries(self) -> lazymanifestiterentries:
         return lazymanifestiterentries(self)
 
     def iterkeys(self) -> lazymanifestiter:
         return lazymanifestiter(self)
 
     def __iter__(self) -> lazymanifestiter:
         return lazymanifestiter(self)
 
     def __len__(self) -> int:
         return len(self.positions)
 
     def filtercopy(self, filterfn: Callable[[bytes], bool]) -> '_LazyManifest':
         # XXX should be optimized
         c = _lazymanifest(self._nodelen, b'')
         for f, n, fl in self.iterentries():
             if filterfn(f):
                 c[f] = n, fl
         return c
 
 
 try:
     _lazymanifest = parsers.lazymanifest
 except AttributeError:
     _lazymanifest = _LazyManifest
 
 
 class manifestdict:  # (repository.imanifestdict)
     def __init__(self, nodelen: int, data: ByteString = b''):
         self._nodelen = nodelen
         self._lm = _lazymanifest(nodelen, data)
 
     def __getitem__(self, key: bytes) -> bytes:
         return self._lm[key][0]
 
     def find(self, key: bytes) -> Tuple[bytes, bytes]:
         return self._lm[key]
 
     def __len__(self) -> int:
         return len(self._lm)
 
     def __nonzero__(self) -> bool:
         # nonzero is covered by the __len__ function, but implementing it here
         # makes it easier for extensions to override.
         return len(self._lm) != 0
 
     __bool__ = __nonzero__
 
     def set(self, key: bytes, node: bytes, flags: bytes) -> None:
         self._lm[key] = node, flags
 
     def __setitem__(self, key: bytes, node: bytes) -> None:
         self._lm[key] = node, self.flags(key)
 
     def __contains__(self, key: bytes) -> bool:
         if key is None:
             return False
         return key in self._lm
 
     def __delitem__(self, key: bytes) -> None:
         del self._lm[key]
 
     def __iter__(self) -> Iterator[bytes]:
         return self._lm.__iter__()
 
     def iterkeys(self) -> Iterator[bytes]:
         return self._lm.iterkeys()
 
     def keys(self) -> List[bytes]:
         return list(self.iterkeys())
 
     def filesnotin(self, m2, match=None) -> Set[bytes]:
         '''Set of files in this manifest that are not in the other'''
         if match is not None:
             match = matchmod.badmatch(match, lambda path, msg: None)
             sm2 = set(m2.walk(match))
             return {f for f in self.walk(match) if f not in sm2}
         return {f for f in self if f not in m2}
 
     @propertycache
     def _dirs(self) -> pathutil.dirs:
         return pathutil.dirs(self)
 
     def dirs(self) -> pathutil.dirs:
         return self._dirs
 
     def hasdir(self, dir: bytes) -> bool:
         return dir in self._dirs
 
     def _filesfastpath(self, match: matchmod.basematcher) -> bool:
         """Checks whether we can correctly and quickly iterate over matcher
         files instead of over manifest files."""
         files = match.files()
         return len(files) < 100 and (
             match.isexact()
             or (match.prefix() and all(fn in self for fn in files))
         )
 
     def walk(self, match: matchmod.basematcher) -> Iterator[bytes]:
         """Generates matching file names.
 
         Equivalent to manifest.matches(match).iterkeys(), but without creating
         an entirely new manifest.
 
         It also reports nonexistent files by marking them bad with match.bad().
         """
         if match.always():
             for f in iter(self):
                 yield f
             return
 
         fset = set(match.files())
 
         # avoid the entire walk if we're only looking for specific files
         if self._filesfastpath(match):
             for fn in sorted(fset):
                 if fn in self:
                     yield fn
             return
 
         for fn in self:
             if fn in fset:
                 # specified pattern is the exact name
                 fset.remove(fn)
             if match(fn):
                 yield fn
 
         # for dirstate.walk, files=[''] means "walk the whole tree".
         # follow that here, too
         fset.discard(b'')
 
         for fn in sorted(fset):
             if not self.hasdir(fn):
                 match.bad(fn, None)
 
     def _matches(self, match: matchmod.basematcher) -> 'manifestdict':
         '''generate a new manifest filtered by the match argument'''
         if match.always():
             return self.copy()
 
         if self._filesfastpath(match):
             m = manifestdict(self._nodelen)
             lm = self._lm
             for fn in match.files():
                 if fn in lm:
                     m._lm[fn] = lm[fn]
             return m
 
         m = manifestdict(self._nodelen)
         m._lm = self._lm.filtercopy(match)
         return m
 
     def diff(
         self,
         m2: 'manifestdict',
         match: Optional[matchmod.basematcher] = None,
         clean: bool = False,
     ) -> Dict[
         bytes,
         Optional[
             Tuple[Tuple[Optional[bytes], bytes], Tuple[Optional[bytes], bytes]]
         ],
     ]:
         """Finds changes between the current manifest and m2.
 
         Args:
           m2: the manifest to which this manifest should be compared.
           clean: if true, include files unchanged between these manifests
                  with a None value in the returned dictionary.
 
         The result is returned as a dict with filename as key and
         values of the form ((n1,fl1),(n2,fl2)), where n1/n2 is the
         nodeid in the current/other manifest and fl1/fl2 is the flag
         in the current/other manifest. Where the file does not exist,
         the nodeid will be None and the flags will be the empty
         string.
         """
         if match:
             m1 = self._matches(match)
             m2 = m2._matches(match)
             return m1.diff(m2, clean=clean)
         return self._lm.diff(m2._lm, clean)
 
     def setflag(self, key: bytes, flag: bytes) -> None:
         if flag not in _manifestflags:
             raise TypeError(b"Invalid manifest flag set.")
         self._lm[key] = self[key], flag
 
     def get(self, key: bytes, default=None) -> Optional[bytes]:
         try:
             return self._lm[key][0]
         except KeyError:
             return default
 
     def flags(self, key: bytes) -> bytes:
         try:
             return self._lm[key][1]
         except KeyError:
             return b''
 
     def copy(self) -> 'manifestdict':
         c = manifestdict(self._nodelen)
         c._lm = self._lm.copy()
         return c
 
     def items(self) -> Iterator[Tuple[bytes, bytes]]:
         return (x[:2] for x in self._lm.iterentries())
 
     def iteritems(self) -> Iterator[Tuple[bytes, bytes]]:
         return (x[:2] for x in self._lm.iterentries())
 
     def iterentries(self) -> Iterator[Tuple[bytes, bytes, bytes]]:
         return self._lm.iterentries()
 
     def text(self) -> ByteString:
         # most likely uses native version
         return self._lm.text()
 
     def fastdelta(
         self, base: ByteString, changes: Iterable[Tuple[bytes, bool]]
     ) -> Tuple[ByteString, ByteString]:
         """Given a base manifest text as a bytearray and a list of changes
         relative to that text, compute a delta that can be used by revlog.
         """
         delta = []
         dstart = None
         dend = None
         dline = [b""]
         start = 0
         # zero copy representation of base as a buffer
         addbuf = util.buffer(base)
 
         changes = list(changes)
         if len(changes) < FASTDELTA_TEXTDIFF_THRESHOLD:
             # start with a readonly loop that finds the offset of
             # each line and creates the deltas
             for f, todelete in changes:
                 # bs will either be the index of the item or the insert point
                 start, end = _msearch(addbuf, f, start)
                 if not todelete:
                     h, fl = self._lm[f]
                     l = b"%s\0%s%s\n" % (f, hex(h), fl)
                 else:
                     if start == end:
                         # item we want to delete was not found, error out
                         raise AssertionError(
                             _(b"failed to remove %s from manifest") % f
                         )
                     l = b""
                 if dstart is not None and dstart <= start and dend >= start:
                     if dend < end:
                         dend = end
                     if l:
                         dline.append(l)
                 else:
                     if dstart is not None:
                         delta.append((dstart, dend, b"".join(dline)))
                     dstart = start
                     dend = end
                     dline = [l]
 
             if dstart is not None:
                 delta.append((dstart, dend, b"".join(dline)))
             # apply the delta to the base, and get a delta for addrevision
             deltatext, arraytext = _addlistdelta(base, delta)
         else:
             # For large changes, it's much cheaper to just build the text and
             # diff it.
             arraytext = bytearray(self.text())
             deltatext = mdiff.textdiff(
                 util.buffer(base), util.buffer(arraytext)
             )
 
         return arraytext, deltatext
 
 
 def _msearch(
     m: ByteString, s: bytes, lo: int = 0, hi: Optional[int] = None
 ) -> Tuple[int, int]:
     """return a tuple (start, end) that says where to find s within m.
 
     If the string is found m[start:end] are the line containing
     that string.  If start == end the string was not found and
     they indicate the proper sorted insertion point.
     """
 
     def advance(i: int, c: bytes):
         while i < lenm and m[i : i + 1] != c:
             i += 1
         return i
 
     if not s:
         return (lo, lo)
     lenm = len(m)
     if not hi:
         hi = lenm
     while lo < hi:
         mid = (lo + hi) // 2
         start = mid
         while start > 0 and m[start - 1 : start] != b'\n':
             start -= 1
         end = advance(start, b'\0')
         if bytes(m[start:end]) < s:
             # we know that after the null there are 40 bytes of sha1
             # this translates to the bisect lo = mid + 1
             lo = advance(end + 40, b'\n') + 1
         else:
             # this translates to the bisect hi = mid
             hi = start
     end = advance(lo, b'\0')
     found = m[lo:end]
     if s == found:
         # we know that after the null there are 40 bytes of sha1
         end = advance(end + 40, b'\n')
         return (lo, end + 1)
     else:
         return (lo, lo)
 
 
 def _checkforbidden(l: Iterable[bytes]) -> None:
     """Check filenames for illegal characters."""
     for f in l:
         if b'\n' in f or b'\r' in f:
             raise error.StorageError(
                 _(b"'\\n' and '\\r' disallowed in filenames: %r")
                 % pycompat.bytestr(f)
             )
 
 
 # apply the changes collected during the bisect loop to our addlist
 # return a delta suitable for addrevision
 def _addlistdelta(
     addlist: ByteString,
     x: Iterable[Tuple[int, int, bytes]],
 ) -> Tuple[bytes, ByteString]:
     # for large addlist arrays, building a new array is cheaper
     # than repeatedly modifying the existing one
     currentposition = 0
     newaddlist = bytearray()
 
     for start, end, content in x:
         newaddlist += addlist[currentposition:start]
         if content:
             newaddlist += bytearray(content)
 
         currentposition = end
 
     newaddlist += addlist[currentposition:]
 
     deltatext = b"".join(
         struct.pack(b">lll", start, end, len(content)) + content
         for start, end, content in x
     )
     return deltatext, newaddlist
 
 
 def _splittopdir(f: bytes) -> Tuple[bytes, bytes]:
     if b'/' in f:
         dir, subpath = f.split(b'/', 1)
         return dir + b'/', subpath
     else:
         return b'', f
 
 
 _noop = lambda s: None
 
 
 class treemanifest:  # (repository.imanifestdict)
     _dir: bytes
     _dirs: Dict[bytes, 'treemanifest']
     _dirty: bool
     _files: Dict[bytes, bytes]
     _flags: Dict[bytes, bytes]
 
     def __init__(self, nodeconstants, dir: bytes = b'', text: bytes = b''):
         self._dir = dir
         self.nodeconstants = nodeconstants
         self._node = self.nodeconstants.nullid
         self._nodelen = self.nodeconstants.nodelen
         self._loadfunc = _noop
         self._copyfunc = _noop
         self._dirty = False
         self._dirs = {}
         self._lazydirs: Dict[
             bytes,
             Tuple[bytes, Callable[[bytes, bytes], 'treemanifest'], bool],
         ] = {}
         # Using _lazymanifest here is a little slower than plain old dicts
         self._files = {}
         self._flags = {}
         if text:
 
             def readsubtree(subdir, subm):
                 raise AssertionError(
                     b'treemanifest constructor only accepts flat manifests'
                 )
 
             self.parse(text, readsubtree)
             self._dirty = True  # Mark flat manifest dirty after parsing
 
     def _subpath(self, path: bytes) -> bytes:
         return self._dir + path
 
     def _loadalllazy(self) -> None:
         selfdirs = self._dirs
         subpath = self._subpath
         for d, (node, readsubtree, docopy) in self._lazydirs.items():
             if docopy:
                 selfdirs[d] = readsubtree(subpath(d), node).copy()
             else:
                 selfdirs[d] = readsubtree(subpath(d), node)
         self._lazydirs.clear()
 
     def _loadlazy(self, d: bytes) -> None:
         v = self._lazydirs.get(d)
         if v is not None:
             node, readsubtree, docopy = v
             if docopy:
                 self._dirs[d] = readsubtree(self._subpath(d), node).copy()
             else:
                 self._dirs[d] = readsubtree(self._subpath(d), node)
             del self._lazydirs[d]
 
     def _loadchildrensetlazy(
         self, visit: Union[Set[bytes], bytes]
     ) -> Optional[Set[bytes]]:
         if not visit:
             return None
         if visit == b'all' or visit == b'this':
             self._loadalllazy()
             return None
 
         visit = cast(Set[bytes], visit)
 
         loadlazy = self._loadlazy
         for k in visit:
             loadlazy(k + b'/')
         return visit
 
     def _loaddifflazy(self, t1: 'treemanifest', t2: 'treemanifest'):
         """load items in t1 and t2 if they're needed for diffing.
 
         The criteria currently is:
         - if it's not present in _lazydirs in either t1 or t2, load it in the
           other (it may already be loaded or it may not exist, doesn't matter)
         - if it's present in _lazydirs in both, compare the nodeid; if it
           differs, load it in both
         """
         toloadlazy = []
         for d, v1 in t1._lazydirs.items():
             v2 = t2._lazydirs.get(d)
             if v2 is None or v2[0] != v1[0]:
                 toloadlazy.append(d)
         for d, v1 in t2._lazydirs.items():
             if d not in t1._lazydirs:
                 toloadlazy.append(d)
 
         for d in toloadlazy:
             t1._loadlazy(d)
             t2._loadlazy(d)
 
     def __len__(self) -> int:
         self._load()
         size = len(self._files)
         self._loadalllazy()
         for m in self._dirs.values():
             size += m.__len__()
         return size
 
     def __nonzero__(self) -> bool:
         # Faster than "__len__() != 0" since it avoids loading sub-manifests
         return not self._isempty()
 
     __bool__ = __nonzero__
 
     def _isempty(self) -> bool:
         self._load()  # for consistency; already loaded by all callers
         # See if we can skip loading everything.
         if self._files or (
             self._dirs and any(not m._isempty() for m in self._dirs.values())
         ):
             return False
         self._loadalllazy()
         return not self._dirs or all(m._isempty() for m in self._dirs.values())
 
     @encoding.strmethod
     def __repr__(self) -> bytes:
         return (
             b'<treemanifest dir=%s, node=%s, loaded=%r, dirty=%r at 0x%x>'
             % (
                 self._dir,
                 hex(self._node),
                 bool(self._loadfunc is _noop),
                 self._dirty,
                 id(self),
             )
         )
 
     def dir(self) -> bytes:
         """The directory that this tree manifest represents, including a
         trailing '/'. Empty string for the repo root directory."""
         return self._dir
 
     def node(self) -> bytes:
         """This node of this instance. nullid for unsaved instances. Should
         be updated when the instance is read or written from a revlog.
         """
         assert not self._dirty
         return self._node
 
     def setnode(self, node: bytes) -> None:
         self._node = node
         self._dirty = False
 
     def iterentries(
         self,
     ) -> Iterator[Tuple[bytes, Union[bytes, 'treemanifest'], bytes]]:
         self._load()
         self._loadalllazy()
         for p, n in sorted(
             itertools.chain(self._dirs.items(), self._files.items())
         ):
             if p in self._files:
                 yield self._subpath(p), n, self._flags.get(p, b'')
             else:
                 for x in n.iterentries():
                     yield x
 
     def items(self) -> Iterator[Tuple[bytes, Union[bytes, 'treemanifest']]]:
         self._load()
         self._loadalllazy()
         for p, n in sorted(
             itertools.chain(self._dirs.items(), self._files.items())
         ):
             if p in self._files:
                 yield self._subpath(p), n
             else:
                 for f, sn in n.items():
                     yield f, sn
 
     iteritems = items
 
     def iterkeys(self) -> Iterator[bytes]:
         self._load()
         self._loadalllazy()
         for p in sorted(itertools.chain(self._dirs, self._files)):
             if p in self._files:
                 yield self._subpath(p)
             else:
                 for f in self._dirs[p]:
                     yield f
 
     def keys(self) -> List[bytes]:
         return list(self.iterkeys())
 
     def __iter__(self) -> Iterator[bytes]:
         return self.iterkeys()
 
     def __contains__(self, f: bytes) -> bool:
         if f is None:
             return False
         self._load()
         dir, subpath = _splittopdir(f)
         if dir:
             self._loadlazy(dir)
 
             if dir not in self._dirs:
                 return False
 
             return self._dirs[dir].__contains__(subpath)
         else:
             return f in self._files
 
     def get(self, f: bytes, default: Optional[bytes] = None) -> Optional[bytes]:
         self._load()
         dir, subpath = _splittopdir(f)
         if dir:
             self._loadlazy(dir)
 
             if dir not in self._dirs:
                 return default
             return self._dirs[dir].get(subpath, default)
         else:
             return self._files.get(f, default)
 
     def __getitem__(self, f: bytes) -> bytes:
         self._load()
         dir, subpath = _splittopdir(f)
         if dir:
             self._loadlazy(dir)
 
             return self._dirs[dir].__getitem__(subpath)
         else:
             return self._files[f]
 
     def flags(self, f: bytes) -> bytes:
         self._load()
         dir, subpath = _splittopdir(f)
         if dir:
             self._loadlazy(dir)
 
             if dir not in self._dirs:
                 return b''
             return self._dirs[dir].flags(subpath)
         else:
             if f in self._lazydirs or f in self._dirs:
                 return b''
             return self._flags.get(f, b'')
 
     def find(self, f: bytes) -> Tuple[bytes, bytes]:
         self._load()
         dir, subpath = _splittopdir(f)
         if dir:
             self._loadlazy(dir)
 
             return self._dirs[dir].find(subpath)
         else:
             return self._files[f], self._flags.get(f, b'')
 
     def __delitem__(self, f: bytes) -> None:
         self._load()
         dir, subpath = _splittopdir(f)
         if dir:
             self._loadlazy(dir)
 
             self._dirs[dir].__delitem__(subpath)
             # If the directory is now empty, remove it
             if self._dirs[dir]._isempty():
                 del self._dirs[dir]
         else:
             del self._files[f]
             if f in self._flags:
                 del self._flags[f]
         self._dirty = True
 
     def set(self, f: bytes, node: bytes, flags: bytes) -> None:
         """Set both the node and the flags for path f."""
         assert node is not None
         if flags not in _manifestflags:
             raise TypeError(b"Invalid manifest flag set.")
         self._load()
         dir, subpath = _splittopdir(f)
         if dir:
             self._loadlazy(dir)
             if dir not in self._dirs:
                 self._dirs[dir] = treemanifest(
                     self.nodeconstants, self._subpath(dir)
                 )
             self._dirs[dir].set(subpath, node, flags)
         else:
             assert len(node) in (20, 32)
             self._files[f] = node
             self._flags[f] = flags
         self._dirty = True
 
     def __setitem__(self, f: bytes, n: bytes) -> None:
         assert n is not None
         self._load()
         dir, subpath = _splittopdir(f)
         if dir:
             self._loadlazy(dir)
             if dir not in self._dirs:
                 self._dirs[dir] = treemanifest(
                     self.nodeconstants, self._subpath(dir)
                 )
             self._dirs[dir].__setitem__(subpath, n)
         else:
             # manifest nodes are either 20 bytes or 32 bytes,
             # depending on the hash in use. Assert this as historically
             # sometimes extra bytes were added.
             assert len(n) in (20, 32)
             self._files[f] = n
         self._dirty = True
 
     def _load(self) -> None:
         if self._loadfunc is not _noop:
             lf, self._loadfunc = self._loadfunc, _noop
             lf(self)
         elif self._copyfunc is not _noop:
             cf, self._copyfunc = self._copyfunc, _noop
             cf(self)
 
     def setflag(self, f: bytes, flags: bytes) -> None:
         """Set the flags (symlink, executable) for path f."""
         if flags not in _manifestflags:
             raise TypeError(b"Invalid manifest flag set.")
         self._load()
         dir, subpath = _splittopdir(f)
         if dir:
             self._loadlazy(dir)
             if dir not in self._dirs:
                 self._dirs[dir] = treemanifest(
                     self.nodeconstants, self._subpath(dir)
                 )
             self._dirs[dir].setflag(subpath, flags)
         else:
             self._flags[f] = flags
         self._dirty = True
 
     def copy(self) -> 'treemanifest':
         copy = treemanifest(self.nodeconstants, self._dir)
         copy._node = self._node
         copy._dirty = self._dirty
         if self._copyfunc is _noop:
 
             def _copyfunc(s):
                 self._load()
                 s._lazydirs = {
                     d: (n, r, True) for d, (n, r, c) in self._lazydirs.items()
                 }
                 sdirs = s._dirs
                 for d, v in self._dirs.items():
                     sdirs[d] = v.copy()
                 s._files = dict.copy(self._files)
                 s._flags = dict.copy(self._flags)
 
             if self._loadfunc is _noop:
                 _copyfunc(copy)
             else:
                 copy._copyfunc = _copyfunc
         else:
             copy._copyfunc = self._copyfunc
         return copy
 
     def filesnotin(
         self, m2: 'treemanifest', match: Optional[matchmod.basematcher] = None
     ) -> Set[bytes]:
         '''Set of files in this manifest that are not in the other'''
         if match and not match.always():
             m1 = self._matches(match)
             m2 = m2._matches(match)
             return m1.filesnotin(m2)
 
         files = set()
 
         def _filesnotin(t1, t2):
             if t1._node == t2._node and not t1._dirty and not t2._dirty:
                 return
             t1._load()
             t2._load()
             self._loaddifflazy(t1, t2)
             for d, m1 in t1._dirs.items():
                 if d in t2._dirs:
                     m2 = t2._dirs[d]
                     _filesnotin(m1, m2)
                 else:
                     files.update(m1.iterkeys())
 
             for fn in t1._files:
                 if fn not in t2._files:
                     files.add(t1._subpath(fn))
 
         _filesnotin(self, m2)
         return files
 
     @propertycache
     def _alldirs(self) -> pathutil.dirs:
         return pathutil.dirs(self)
 
     def dirs(self) -> pathutil.dirs:
         return self._alldirs
 
     def hasdir(self, dir: bytes) -> bool:
         self._load()
         topdir, subdir = _splittopdir(dir)
         if topdir:
             self._loadlazy(topdir)
             if topdir in self._dirs:
                 return self._dirs[topdir].hasdir(subdir)
             return False
         dirslash = dir + b'/'
         return dirslash in self._dirs or dirslash in self._lazydirs
 
     def walk(self, match: matchmod.basematcher) -> Iterator[bytes]:
         """Generates matching file names.
 
         It also reports nonexistent files by marking them bad with match.bad().
         """
         if match.always():
             for f in iter(self):
                 yield f
             return
 
         fset = set(match.files())
 
         for fn in self._walk(match):
             if fn in fset:
                 # specified pattern is the exact name
                 fset.remove(fn)
             yield fn
 
         # for dirstate.walk, files=[''] means "walk the whole tree".
         # follow that here, too
         fset.discard(b'')
 
         for fn in sorted(fset):
             if not self.hasdir(fn):
                 match.bad(fn, None)
 
     def _walk(self, match: matchmod.basematcher) -> Iterator[bytes]:
         '''Recursively generates matching file names for walk().'''
         visit = match.visitchildrenset(self._dir[:-1])
         if not visit:
             return
 
         # yield this dir's files and walk its submanifests
         self._load()
         visit = self._loadchildrensetlazy(visit)
         for p in sorted(list(self._dirs) + list(self._files)):
             if p in self._files:
                 fullp = self._subpath(p)
                 if match(fullp):
                     yield fullp
             else:
                 if not visit or p[:-1] in visit:
                     for f in self._dirs[p]._walk(match):
                         yield f
 
     def _matches(self, match: matchmod.basematcher) -> 'treemanifest':
         """recursively generate a new manifest filtered by the match argument."""
         if match.always():
             return self.copy()
         return self._matches_inner(match)
 
     def _matches_inner(self, match: matchmod.basematcher) -> 'treemanifest':
         if match.always():
             return self.copy()
 
         visit = match.visitchildrenset(self._dir[:-1])
         if visit == b'all':
             return self.copy()
         ret = treemanifest(self.nodeconstants, self._dir)
         if not visit:
             return ret
 
         self._load()
         for fn in self._files:
             # While visitchildrenset *usually* lists only subdirs, this is
             # actually up to the matcher and may have some files in the set().
             # If visit == 'this', we should obviously look at the files in this
             # directory; if visit is a set, and fn is in it, we should inspect
             # fn (but no need to inspect things not in the set).
             if visit != b'this' and fn not in visit:
                 continue
             fullp = self._subpath(fn)
             # visitchildrenset isn't perfect, we still need to call the regular
             # matcher code to further filter results.
             if not match(fullp):
                 continue
             ret._files[fn] = self._files[fn]
             if fn in self._flags:
                 ret._flags[fn] = self._flags[fn]
 
         visit = self._loadchildrensetlazy(visit)
         for dir, subm in self._dirs.items():
             if visit and dir[:-1] not in visit:
                 continue
             m = subm._matches_inner(match)
             if not m._isempty():
                 ret._dirs[dir] = m
 
         if not ret._isempty():
             ret._dirty = True
         return ret
 
     def fastdelta(
         self, base: ByteString, changes: Iterable[Tuple[bytes, bool]]
     ) -> ByteString:
         raise FastdeltaUnavailable()
 
     def diff(
         self,
         m2: 'treemanifest',
         match: Optional[matchmod.basematcher] = None,
         clean: bool = False,
     ) -> Dict[
         bytes,
         Optional[
             Tuple[Tuple[Optional[bytes], bytes], Tuple[Optional[bytes], bytes]]
         ],
     ]:
         """Finds changes between the current manifest and m2.
 
         Args:
           m2: the manifest to which this manifest should be compared.
           clean: if true, include files unchanged between these manifests
                  with a None value in the returned dictionary.
 
         The result is returned as a dict with filename as key and
         values of the form ((n1,fl1),(n2,fl2)), where n1/n2 is the
         nodeid in the current/other manifest and fl1/fl2 is the flag
         in the current/other manifest. Where the file does not exist,
         the nodeid will be None and the flags will be the empty
         string.
         """
         if match and not match.always():
             m1 = self._matches(match)
             m2 = m2._matches(match)
             return m1.diff(m2, clean=clean)
         result = {}
         emptytree = treemanifest(self.nodeconstants)
 
         def _iterativediff(t1, t2, stack):
             """compares two tree manifests and append new tree-manifests which
             needs to be compared to stack"""
             if t1._node == t2._node and not t1._dirty and not t2._dirty:
                 return
             t1._load()
             t2._load()
             self._loaddifflazy(t1, t2)
 
             for d, m1 in t1._dirs.items():
                 m2 = t2._dirs.get(d, emptytree)
                 stack.append((m1, m2))
 
             for d, m2 in t2._dirs.items():
                 if d not in t1._dirs:
                     stack.append((emptytree, m2))
 
             for fn, n1 in t1._files.items():
                 fl1 = t1._flags.get(fn, b'')
                 n2 = t2._files.get(fn, None)
                 fl2 = t2._flags.get(fn, b'')
                 if n1 != n2 or fl1 != fl2:
                     result[t1._subpath(fn)] = ((n1, fl1), (n2, fl2))
                 elif clean:
                     result[t1._subpath(fn)] = None
 
             for fn, n2 in t2._files.items():
                 if fn not in t1._files:
                     fl2 = t2._flags.get(fn, b'')
                     result[t2._subpath(fn)] = ((None, b''), (n2, fl2))
 
         stackls = []
         _iterativediff(self, m2, stackls)
         while stackls:
             t1, t2 = stackls.pop()
             # stackls is populated in the function call
             _iterativediff(t1, t2, stackls)
         return result
 
     def unmodifiedsince(self, m2: 'treemanifest') -> bool:
         return not self._dirty and not m2._dirty and self._node == m2._node
 
     def parse(
         self,
         text: bytes,
         readsubtree: Callable[[bytes, bytes], 'treemanifest'],
     ) -> None:
         selflazy = self._lazydirs
         for f, n, fl in _parse(self._nodelen, text):
             if fl == b't':
                 f = f + b'/'
                 # False below means "doesn't need to be copied" and can use the
                 # cached value from readsubtree directly.
                 selflazy[f] = (n, readsubtree, False)
             elif b'/' in f:
                 # This is a flat manifest, so use __setitem__ and setflag rather
                 # than assigning directly to _files and _flags, so we can
                 # assign a path in a subdirectory, and to mark dirty (compared
                 # to nullid).
                 self[f] = n
                 if fl:
                     self.setflag(f, fl)
             else:
                 # Assigning to _files and _flags avoids marking as dirty,
                 # and should be a little faster.
                 self._files[f] = n
                 if fl:
                     self._flags[f] = fl
 
     def text(self) -> ByteString:
         """Get the full data of this manifest as a bytestring."""
         self._load()
         return _text(self.iterentries())
 
     def dirtext(self) -> ByteString:
         """Get the full data of this directory as a bytestring. Make sure that
         any submanifests have been written first, so their nodeids are correct.
         """
         self._load()
         flags = self.flags
         lazydirs = [(d[:-1], v[0], b't') for d, v in self._lazydirs.items()]
         dirs = [(d[:-1], self._dirs[d]._node, b't') for d in self._dirs]
         files = [(f, self._files[f], flags(f)) for f in self._files]
         return _text(sorted(dirs + files + lazydirs))
 
     def read(
         self,
         gettext: Callable[[], ByteString],
         readsubtree: Callable[[bytes, bytes], 'treemanifest'],
     ) -> None:
         def _load_for_read(s):
             s.parse(gettext(), readsubtree)
             s._dirty = False
 
         self._loadfunc = _load_for_read
 
     def writesubtrees(
         self,
         m1: 'treemanifest',
         m2: 'treemanifest',
         writesubtree: Callable[
             [
                 Callable[['treemanifest'], None],
                 bytes,
                 bytes,
                 matchmod.basematcher,
             ],
             None,
         ],
         match: matchmod.basematcher,
     ) -> None:
         self._load()  # for consistency; should never have any effect here
         m1._load()
         m2._load()
         emptytree = treemanifest(self.nodeconstants)
 
         def getnode(m, d):
             ld = m._lazydirs.get(d)
             if ld:
                 return ld[0]
             tree = m._dirs.get(d, emptytree)
             assert tree is not None  # helps pytype
             return tree._node
 
         # let's skip investigating things that `match` says we do not need.
         visit = match.visitchildrenset(self._dir[:-1])
         visit = self._loadchildrensetlazy(visit)
         if visit == b'this' or visit == b'all':
             visit = None
         for d, subm in self._dirs.items():
             if visit and d[:-1] not in visit:
                 continue
             subp1 = getnode(m1, d)
             subp2 = getnode(m2, d)
             if subp1 == self.nodeconstants.nullid:
                 subp1, subp2 = subp2, subp1
             writesubtree(subm, subp1, subp2, match)
 
     def walksubtrees(
         self, matcher: Optional[matchmod.basematcher] = None
     ) -> Iterator['treemanifest']:
         """Returns an iterator of the subtrees of this manifest, including this
         manifest itself.
 
         If `matcher` is provided, it only returns subtrees that match.
         """
         if matcher and not matcher.visitdir(self._dir[:-1]):
             return
         if not matcher or matcher(self._dir[:-1]):
             yield self
 
         self._load()
         # OPT: use visitchildrenset to avoid loading everything.
         self._loadalllazy()
         for d, subm in self._dirs.items():
             for subtree in subm.walksubtrees(matcher=matcher):
                 yield subtree
 
 
 class manifestfulltextcache(util.lrucachedict):
     """File-backed LRU cache for the manifest cache
 
     File consists of entries, up to EOF:
 
     - 20 bytes node, 4 bytes length, <length> manifest data
 
     These are written in reverse cache order (oldest to newest).
 
     """
 
     _file = b'manifestfulltextcache'
 
     def __init__(self, max):
         super(manifestfulltextcache, self).__init__(max)
         self._dirty = False
         self._read = False
         self._opener = None
 
     def read(self):
         if self._read or self._opener is None:
             return
 
         try:
             with self._opener(self._file) as fp:
                 set = super(manifestfulltextcache, self).__setitem__
                 # ignore trailing data, this is a cache, corruption is skipped
                 while True:
                     # TODO do we need to do work here for sha1 portability?
                     node = fp.read(20)
                     if len(node) < 20:
                         break
                     try:
                         size = struct.unpack(b'>L', fp.read(4))[0]
                     except struct.error:
                         break
                     value = bytearray(fp.read(size))
                     if len(value) != size:
                         break
                     set(node, value)
         except IOError:
             # the file is allowed to be missing
             pass
 
         self._read = True
         self._dirty = False
 
     def write(self):
         if not self._dirty or self._opener is None:
             return
         # rotate backwards to the first used node
         try:
             with self._opener(
                 self._file, b'w', atomictemp=True, checkambig=True
             ) as fp:
                 node = self._head.prev
                 while True:
                     if node.key in self._cache:
                         fp.write(node.key)
                         fp.write(struct.pack(b'>L', len(node.value)))
                         fp.write(node.value)
                     if node is self._head:
                         break
                     node = node.prev
         except IOError:
             # We could not write the cache (eg: permission error)
             # the content can be missing.
             #
             # We could try harder and see if we could recreate a wcache
             # directory were we coudl write too.
             #
             # XXX the error pass silently, having some way to issue an error
             # log `ui.log` would be nice.
             pass
 
     def __len__(self):
         if not self._read:
             self.read()
         return super(manifestfulltextcache, self).__len__()
 
     def __contains__(self, k):
         if not self._read:
             self.read()
         return super(manifestfulltextcache, self).__contains__(k)
 
     def __iter__(self):
         if not self._read:
             self.read()
         return super(manifestfulltextcache, self).__iter__()
 
     def __getitem__(self, k):
         if not self._read:
             self.read()
         # the cache lru order can change on read
         setdirty = self._cache.get(k) is not self._head
         value = super(manifestfulltextcache, self).__getitem__(k)
         if setdirty:
             self._dirty = True
         return value
 
     def __setitem__(self, k, v):
         if not self._read:
             self.read()
         super(manifestfulltextcache, self).__setitem__(k, v)
         self._dirty = True
 
     def __delitem__(self, k):
         if not self._read:
             self.read()
         super(manifestfulltextcache, self).__delitem__(k)
         self._dirty = True
 
     def get(self, k, default=None):
         if not self._read:
             self.read()
         return super(manifestfulltextcache, self).get(k, default=default)
 
     def clear(self, clear_persisted_data=False):
         super(manifestfulltextcache, self).clear()
         if clear_persisted_data:
             self._dirty = True
             self.write()
         self._read = False
 
 
 # and upper bound of what we expect from compression
 # (real live value seems to be "3")
 MAXCOMPRESSION = 3
 
 
 class FastdeltaUnavailable(Exception):
     """Exception raised when fastdelta isn't usable on a manifest."""
 
 
 class manifestrevlog:  # (repository.imanifeststorage)
     """A revlog that stores manifest texts. This is responsible for caching the
     full-text manifest contents.
     """
 
     def __init__(
         self,
         nodeconstants,
         opener,
         tree=b'',
         dirlogcache=None,
         treemanifest=False,
     ):
         """Constructs a new manifest revlog
 
         `indexfile` - used by extensions to have two manifests at once, like
         when transitioning between flatmanifeset and treemanifests.
 
         `treemanifest` - used to indicate this is a tree manifest revlog. Opener
         options can also be used to make this a tree manifest revlog. The opener
         option takes precedence, so if it is set to True, we ignore whatever
         value is passed in to the constructor.
         """
         self.nodeconstants = nodeconstants
         # During normal operations, we expect to deal with not more than four
         # revs at a time (such as during commit --amend). When rebasing large
         # stacks of commits, the number can go up, hence the config knob below.
         cachesize = 4
         optiontreemanifest = False
         persistentnodemap = False
         opts = getattr(opener, 'options', None)
         if opts is not None:
             cachesize = opts.get(b'manifestcachesize', cachesize)
             optiontreemanifest = opts.get(b'treemanifest', False)
             persistentnodemap = opts.get(b'persistent-nodemap', False)
 
         self._treeondisk = optiontreemanifest or treemanifest
 
         self._fulltextcache = manifestfulltextcache(cachesize)
 
         if tree:
             assert self._treeondisk, (tree, b'opts is %r' % opts)
 
         radix = b'00manifest'
         if tree:
             radix = b"meta/" + tree + radix
 
         self.tree = tree
 
         # The dirlogcache is kept on the root manifest log
         if tree:
             self._dirlogcache = dirlogcache
         else:
             self._dirlogcache = {b'': self}
 
         self._revlog = revlog.revlog(
             opener,
             target=(revlog_constants.KIND_MANIFESTLOG, self.tree),
             radix=radix,
             # only root indexfile is cached
             checkambig=not bool(tree),
             mmaplargeindex=True,
             upperboundcomp=MAXCOMPRESSION,
             persistentnodemap=persistentnodemap,
         )
 
         self.index = self._revlog.index
 
     def get_revlog(self):
         """return an actual revlog instance if any
 
         This exist because a lot of code leverage the fact the underlying
         storage is a revlog for optimization, so giving simple way to access
         the revlog instance helps such code.
         """
         return self._revlog
 
     def _setupmanifestcachehooks(self, repo):
         """Persist the manifestfulltextcache on lock release"""
         if not hasattr(repo, '_wlockref'):
             return
 
         self._fulltextcache._opener = repo.wcachevfs
         if repo._currentlock(repo._wlockref) is None:
             return
 
         reporef = weakref.ref(repo)
         manifestrevlogref = weakref.ref(self)
 
         def persistmanifestcache(success):
             # Repo is in an unknown state, do not persist.
             if not success:
                 return
 
             repo = reporef()
             self = manifestrevlogref()
             if repo is None or self is None:
                 return
             if repo.manifestlog.getstorage(b'') is not self:
                 # there's a different manifest in play now, abort
                 return
             self._fulltextcache.write()
 
         repo._afterlock(persistmanifestcache)
 
     @property
     def fulltextcache(self):
         return self._fulltextcache
 
     def clearcaches(self, clear_persisted_data: bool = False) -> None:
         self._revlog.clearcaches()
         self._fulltextcache.clear(clear_persisted_data=clear_persisted_data)
         self._dirlogcache = {self.tree: self}
 
     def dirlog(self, d):
         if d:
             assert self._treeondisk
         if d not in self._dirlogcache:
             mfrevlog = manifestrevlog(
                 self.nodeconstants,
                 self.opener,
                 d,
                 self._dirlogcache,
                 treemanifest=self._treeondisk,
             )
             self._dirlogcache[d] = mfrevlog
         return self._dirlogcache[d]
 
     def add(
         self,
         m,
         transaction,
         link,
         p1,
         p2,
         added: Iterable[bytes],
         removed: Iterable[bytes],
         readtree=None,
         match=None,
     ):
         """add some manifest entry in to the manifest log
 
         input:
 
           m:           the manifest dict we want to store
           transaction: the open transaction
           p1:          manifest-node of p1
           p2:          manifest-node of p2
           added:       file added/changed compared to parent
           removed:     file removed compared to parent
 
         tree manifest input:
 
           readtree:    a function to read a subtree
           match:       a filematcher for the subpart of the tree manifest
         """
         try:
             if p1 not in self.fulltextcache:
                 raise FastdeltaUnavailable()
             # If our first parent is in the manifest cache, we can
             # compute a delta here using properties we know about the
             # manifest up-front, which may save time later for the
             # revlog layer.
 
             _checkforbidden(added)
             # combine the changed lists into one sorted iterator
             work = heapq.merge(
                 [(x, False) for x in sorted(added)],
                 [(x, True) for x in sorted(removed)],
             )
 
             arraytext, deltatext = m.fastdelta(self.fulltextcache[p1], work)
             cachedelta = self._revlog.rev(p1), deltatext
             text = util.buffer(arraytext)
             rev = self._revlog.addrevision(
                 text, transaction, link, p1, p2, cachedelta
             )
             n = self._revlog.node(rev)
         except FastdeltaUnavailable:
             # The first parent manifest isn't already loaded or the
             # manifest implementation doesn't support fastdelta, so
             # we'll just encode a fulltext of the manifest and pass
             # that through to the revlog layer, and let it handle the
             # delta process.
             if self._treeondisk:
                 assert readtree, b"readtree must be set for treemanifest writes"
                 assert match, b"match must be specified for treemanifest writes"
                 m1 = readtree(self.tree, p1)
                 m2 = readtree(self.tree, p2)
                 n = self._addtree(
                     m, transaction, link, m1, m2, readtree, match=match
                 )
                 arraytext = None
             else:
                 text = m.text()
                 rev = self._revlog.addrevision(text, transaction, link, p1, p2)
                 n = self._revlog.node(rev)
                 arraytext = bytearray(text)
 
         if arraytext is not None:
             self.fulltextcache[n] = arraytext
 
         return n
 
     def _addtree(self, m, transaction, link, m1, m2, readtree, match):
         # If the manifest is unchanged compared to one parent,
         # don't write a new revision
         if self.tree != b'' and (
             m.unmodifiedsince(m1) or m.unmodifiedsince(m2)
         ):
             return m.node()
 
         def writesubtree(subm, subp1, subp2, match):
             sublog = self.dirlog(subm.dir())
             sublog.add(
                 subm,
                 transaction,
                 link,
                 subp1,
                 subp2,
                 None,
                 None,
                 readtree=readtree,
                 match=match,
             )
 
         m.writesubtrees(m1, m2, writesubtree, match)
         text = m.dirtext()
         n = None
         if self.tree != b'':
             # Double-check whether contents are unchanged to one parent
             if text == m1.dirtext():
                 n = m1.node()
             elif text == m2.dirtext():
                 n = m2.node()
 
         if not n:
             rev = self._revlog.addrevision(
                 text, transaction, link, m1.node(), m2.node()
             )
             n = self._revlog.node(rev)
 
         # Save nodeid so parent manifest can calculate its nodeid
         m.setnode(n)
         return n
 
     def __len__(self):
         return len(self._revlog)
 
     def __iter__(self):
         return self._revlog.__iter__()
 
     def rev(self, node):
         return self._revlog.rev(node)
 
     def node(self, rev):
         return self._revlog.node(rev)
 
     def lookup(self, value):
         return self._revlog.lookup(value)
 
     def parentrevs(self, rev):
         return self._revlog.parentrevs(rev)
 
     def parents(self, node):
         return self._revlog.parents(node)
 
     def linkrev(self, rev):
         return self._revlog.linkrev(rev)
 
     def checksize(self):
         return self._revlog.checksize()
 
     def revision(self, node):
         return self._revlog.revision(node)
 
     def rawdata(self, node):
         return self._revlog.rawdata(node)
 
     def revdiff(self, rev1, rev2):
         return self._revlog.revdiff(rev1, rev2)
 
     def cmp(self, node, text):
         return self._revlog.cmp(node, text)
 
     def deltaparent(self, rev):
         return self._revlog.deltaparent(rev)
 
     def emitrevisions(
         self,
         nodes,
         nodesorder=None,
         revisiondata=False,
         assumehaveparentrevisions=False,
         deltamode=repository.CG_DELTAMODE_STD,
         sidedata_helpers=None,
         debug_info=None,
     ):
         return self._revlog.emitrevisions(
             nodes,
             nodesorder=nodesorder,
             revisiondata=revisiondata,
             assumehaveparentrevisions=assumehaveparentrevisions,
             deltamode=deltamode,
             sidedata_helpers=sidedata_helpers,
             debug_info=debug_info,
         )
 
     def addgroup(
         self,
         deltas,
         linkmapper,
         transaction,
         alwayscache=False,
         addrevisioncb=None,
         duplicaterevisioncb=None,
         debug_info=None,
         delta_base_reuse_policy=None,
     ):
         return self._revlog.addgroup(
             deltas,
             linkmapper,
             transaction,
             alwayscache=alwayscache,
             addrevisioncb=addrevisioncb,
             duplicaterevisioncb=duplicaterevisioncb,
             debug_info=debug_info,
             delta_base_reuse_policy=delta_base_reuse_policy,
         )
 
     def rawsize(self, rev):
         return self._revlog.rawsize(rev)
 
     def getstrippoint(self, minlink):
         return self._revlog.getstrippoint(minlink)
 
     def strip(self, minlink, transaction):
         return self._revlog.strip(minlink, transaction)
 
     def files(self):
         return self._revlog.files()
 
     def clone(self, tr, destrevlog, **kwargs):
         if not isinstance(destrevlog, manifestrevlog):
             raise error.ProgrammingError(b'expected manifestrevlog to clone()')
 
         return self._revlog.clone(tr, destrevlog._revlog, **kwargs)
 
     def storageinfo(
         self,
         exclusivefiles=False,
         sharedfiles=False,
         revisionscount=False,
         trackedsize=False,
         storedsize=False,
     ):
         return self._revlog.storageinfo(
             exclusivefiles=exclusivefiles,
             sharedfiles=sharedfiles,
             revisionscount=revisionscount,
             trackedsize=trackedsize,
             storedsize=storedsize,
         )
 
     @property
     def opener(self):
         return self._revlog.opener
 
     @opener.setter
     def opener(self, value):
         self._revlog.opener = value
 
 
 # TODO: drop this in favor of repository.imanifestrevisionstored?
 AnyManifestCtx = Union['manifestctx', 'treemanifestctx']
 # TODO: drop this in favor of repository.imanifestdict
 AnyManifestDict = Union[manifestdict, treemanifest]
 
 
 class manifestlog:  # (repository.imanifestlog)
     """A collection class representing the collection of manifest snapshots
     referenced by commits in the repository.
 
     In this situation, 'manifest' refers to the abstract concept of a snapshot
     of the list of files in the given commit. Consumers of the output of this
     class do not care about the implementation details of the actual manifests
     they receive (i.e. tree or flat or lazily loaded, etc)."""
 
     def __init__(self, opener, repo, rootstore, narrowmatch):
         self.nodeconstants = repo.nodeconstants
         usetreemanifest = False
         cachesize = 4
 
         opts = getattr(opener, 'options', None)
         if opts is not None:
             usetreemanifest = opts.get(b'treemanifest', usetreemanifest)
             cachesize = opts.get(b'manifestcachesize', cachesize)
 
         self._treemanifests = usetreemanifest
 
         self._rootstore = rootstore
         self._rootstore._setupmanifestcachehooks(repo)
         self._narrowmatch = narrowmatch
 
         # A cache of the manifestctx or treemanifestctx for each directory
         self._dirmancache = {}
         self._dirmancache[b''] = util.lrucachedict(cachesize)
 
         self._cachesize = cachesize
 
     def __getitem__(self, node):
         """Retrieves the manifest instance for the given node. Throws a
         LookupError if not found.
         """
         return self.get(b'', node)
 
     @property
     def narrowed(self):
         return not (self._narrowmatch is None or self._narrowmatch.always())
 
     def get(
         self, tree: bytes, node: bytes, verify: bool = True
     ) -> AnyManifestCtx:
         """Retrieves the manifest instance for the given node. Throws a
         LookupError if not found.
 
         `verify` - if True an exception will be thrown if the node is not in
                    the revlog
         """
         if node in self._dirmancache.get(tree, ()):
             return self._dirmancache[tree][node]
 
         if not self._narrowmatch.always():
             if not self._narrowmatch.visitdir(tree[:-1]):
                 return excludeddirmanifestctx(self.nodeconstants, tree, node)
         if tree:
             if self._rootstore._treeondisk:
                 if verify:
                     # Side-effect is LookupError is raised if node doesn't
                     # exist.
                     self.getstorage(tree).rev(node)
 
                 m = treemanifestctx(self, tree, node)
             else:
                 raise error.Abort(
                     _(
                         b"cannot ask for manifest directory '%s' in a flat "
                         b"manifest"
                     )
                     % tree
                 )
         else:
             if verify:
                 # Side-effect is LookupError is raised if node doesn't exist.
                 self._rootstore.rev(node)
 
             if self._treemanifests:
                 m = treemanifestctx(self, b'', node)
             else:
                 m = manifestctx(self, node)
 
         if node != self.nodeconstants.nullid:
             mancache = self._dirmancache.get(tree)
             if not mancache:
                 mancache = util.lrucachedict(self._cachesize)
                 self._dirmancache[tree] = mancache
             mancache[node] = m
         return m
 
     def getstorage(self, tree):
         return self._rootstore.dirlog(tree)
 
     def clearcaches(self, clear_persisted_data: bool = False) -> None:
         self._dirmancache.clear()
         self._rootstore.clearcaches(clear_persisted_data=clear_persisted_data)
 
     def rev(self, node) -> int:
         return self._rootstore.rev(node)
 
     def update_caches(self, transaction) -> None:
         return self._rootstore._revlog.update_caches(transaction=transaction)
 
 
 class memmanifestctx:  # (repository.imanifestrevisionwritable)
     _manifestdict: manifestdict
 
     def __init__(self, manifestlog):
         self._manifestlog = manifestlog
         self._manifestdict = manifestdict(manifestlog.nodeconstants.nodelen)
 
     def _storage(self) -> manifestrevlog:
         return self._manifestlog.getstorage(b'')
 
     def copy(self) -> 'memmanifestctx':
         memmf = memmanifestctx(self._manifestlog)
         memmf._manifestdict = self.read().copy()
         return memmf
 
     def read(self) -> 'manifestdict':
         return self._manifestdict
 
     def write(self, transaction, link, p1, p2, added, removed, match=None):
         return self._storage().add(
             self._manifestdict,
             transaction,
             link,
             p1,
             p2,
             added,
             removed,
             match=match,
         )
 
 
 class manifestctx:  # (repository.imanifestrevisionstored)
     """A class representing a single revision of a manifest, including its
     contents, its parent revs, and its linkrev.
     """
 
     _data: Optional[manifestdict]
 
     def __init__(self, manifestlog, node):
         self._manifestlog = manifestlog
         self._data = None
 
         self._node = node
 
         # TODO: We eventually want p1, p2, and linkrev exposed on this class,
         # but let's add it later when something needs it and we can load it
         # lazily.
         # self.p1, self.p2 = store.parents(node)
         # rev = store.rev(node)
         # self.linkrev = store.linkrev(rev)
 
     def _storage(self) -> 'manifestrevlog':
         return self._manifestlog.getstorage(b'')
 
     def node(self) -> bytes:
         return self._node
 
     def copy(self) -> memmanifestctx:
         memmf = memmanifestctx(self._manifestlog)
         memmf._manifestdict = self.read().copy()
         return memmf
 
     @propertycache
     def parents(self) -> Tuple[bytes, bytes]:
         return self._storage().parents(self._node)
 
     def read(self) -> 'manifestdict':
         if self._data is None:
             nc = self._manifestlog.nodeconstants
             if self._node == nc.nullid:
                 self._data = manifestdict(nc.nodelen)
             else:
                 store = self._storage()
                 if self._node in store.fulltextcache:
                     text = pycompat.bytestr(store.fulltextcache[self._node])
                 else:
                     text = store.revision(self._node)
                     arraytext = bytearray(text)
                     store.fulltextcache[self._node] = arraytext
                 self._data = manifestdict(nc.nodelen, text)
         return self._data
 
     def readfast(self, shallow: bool = False) -> 'manifestdict':
         """Calls either readdelta or read, based on which would be less work.
         readdelta is called if the delta is against the p1, and therefore can be
         read quickly.
 
         If `shallow` is True, nothing changes since this is a flat manifest.
         """
         util.nouideprecwarn(
             b'"readfast" is deprecated use "read_any_fast_delta" or "read_delta_parents"',
             b"6.9",
             stacklevel=2,
         )
         store = self._storage()
         r = store.rev(self._node)
         deltaparent = store.deltaparent(r)
         if deltaparent != nullrev and deltaparent in store.parentrevs(r):
             return self.readdelta()
         return self.read()
 
     def readdelta(self, shallow: bool = False) -> 'manifestdict':
         """Returns a manifest containing just the entries that are present
         in this manifest, but not in its p1 manifest. This is efficient to read
         if the revlog delta is already p1.
 
         Changing the value of `shallow` has no effect on flat manifests.
         """
         util.nouideprecwarn(
             b'"readfast" is deprecated use "read_any_fast_delta" or "read_delta_new_entries"',
             b"6.9",
             stacklevel=2,
         )
         store = self._storage()
         r = store.rev(self._node)
         d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))
         return manifestdict(store.nodeconstants.nodelen, d)
 
     def read_any_fast_delta(
         self,
         valid_bases: Optional[Collection[int]] = None,
         *,
         shallow: bool = False,
     ) -> Tuple[Optional[int], manifestdict]:
         """see `imanifestrevisionstored` documentation"""
         store = self._storage()
         r = store.rev(self._node)
         deltaparent = store.deltaparent(r)
         if valid_bases is None:
             # make sure the next check is True
             valid_bases = (deltaparent,)
         if deltaparent != nullrev and deltaparent in valid_bases:
             d = mdiff.patchtext(store.revdiff(deltaparent, r))
             return (
                 deltaparent,
                 manifestdict(store.nodeconstants.nodelen, d),
             )
         return (None, self.read())
 
     def read_delta_parents(
         self,
         *,
         shallow: bool = False,
         exact: bool = True,
     ) -> manifestdict:
         """see `interface.imanifestrevisionbase` documentations"""
         store = self._storage()
         r = store.rev(self._node)
         deltaparent = store.deltaparent(r)
         parents = [p for p in store.parentrevs(r) if p is not nullrev]
         if not exact and deltaparent in parents:
             d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))
             return manifestdict(store.nodeconstants.nodelen, d)
         elif not exact or len(parents) == 0:
             return self.read()
         elif len(parents) == 1:
             p = parents[0]
             d = mdiff.patchtext(store.revdiff(p, r))
             return manifestdict(store.nodeconstants.nodelen, d)
         else:
             p1, p2 = parents
             d1 = mdiff.patchtext(store.revdiff(p1, r))
             d2 = mdiff.patchtext(store.revdiff(p2, r))
             d1 = manifestdict(store.nodeconstants.nodelen, d1)
             d2 = manifestdict(store.nodeconstants.nodelen, d2)
             md = manifestdict(store.nodeconstants.nodelen)
             for f, new_node, new_flag in d1.iterentries():
                 if f not in d2:
                     continue
                 if new_node is not None:
                     md.set(f, new_node, new_flag)
             return md
 
-    def read_delta_new_entries(self, *, shallow=False) -> manifestdict:
+    def read_delta_new_entries(self, *, shallow: bool = False) -> manifestdict:
         """see `interface.imanifestrevisionbase` documentations"""
         # If we are using narrow, returning a delta against an arbitrary
         # changeset might return file outside the narrowspec. This can create
         # issue when running validation server side with strict security as
         # push from low priviledge usage might be seen as adding new revision
         # for files they cannot touch. So we are strict if narrow is involved.
         if self._manifestlog.narrowed:
             return self.read_delta_parents(shallow=shallow, exact=True)
         store = self._storage()
         r = store.rev(self._node)
         d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))
         return manifestdict(store.nodeconstants.nodelen, d)
 
     def find(self, key: bytes) -> Tuple[bytes, bytes]:
         return self.read().find(key)
 
 
 class memtreemanifestctx:  # (repository.imanifestrevisionwritable)
     _treemanifest: treemanifest
 
     def __init__(self, manifestlog, dir=b''):
         self._manifestlog = manifestlog
         self._dir = dir
         self._treemanifest = treemanifest(manifestlog.nodeconstants)
 
     def _storage(self) -> manifestrevlog:
         return self._manifestlog.getstorage(b'')
 
     def copy(self) -> 'memtreemanifestctx':
         memmf = memtreemanifestctx(self._manifestlog, dir=self._dir)
         memmf._treemanifest = self._treemanifest.copy()
         return memmf
 
     def read(self) -> 'treemanifest':
         return self._treemanifest
 
     def write(self, transaction, link, p1, p2, added, removed, match=None):
         def readtree(dir, node):
             return self._manifestlog.get(dir, node).read()
 
         return self._storage().add(
             self._treemanifest,
             transaction,
             link,
             p1,
             p2,
             added,
             removed,
             readtree=readtree,
             match=match,
         )
 
 
 class treemanifestctx:  # (repository.imanifestrevisionstored)
     _data: Optional[treemanifest]
 
     def __init__(self, manifestlog, dir, node):
         self._manifestlog = manifestlog
         self._dir = dir
         self._data = None
 
         self._node = node
 
         # TODO: Load p1/p2/linkrev lazily. They need to be lazily loaded so that
         # we can instantiate treemanifestctx objects for directories we don't
         # have on disk.
         # self.p1, self.p2 = store.parents(node)
         # rev = store.rev(node)
         # self.linkrev = store.linkrev(rev)
 
     def _storage(self) -> manifestrevlog:
         narrowmatch = self._manifestlog._narrowmatch
         if not narrowmatch.always():
             if not narrowmatch.visitdir(self._dir[:-1]):
                 return excludedmanifestrevlog(
                     self._manifestlog.nodeconstants, self._dir
                 )
         return self._manifestlog.getstorage(self._dir)
 
     def read(self) -> 'treemanifest':
         if self._data is None:
             store = self._storage()
             if self._node == self._manifestlog.nodeconstants.nullid:
                 self._data = treemanifest(self._manifestlog.nodeconstants)
             # TODO accessing non-public API
             elif store._treeondisk:
                 m = treemanifest(self._manifestlog.nodeconstants, dir=self._dir)
 
                 def gettext():
                     return store.revision(self._node)
 
                 def readsubtree(dir, subm):
                     # Set verify to False since we need to be able to create
                     # subtrees for trees that don't exist on disk.
                     return self._manifestlog.get(dir, subm, verify=False).read()
 
                 m.read(gettext, readsubtree)
                 m.setnode(self._node)
                 self._data = m
             else:
                 if self._node in store.fulltextcache:
                     text = pycompat.bytestr(store.fulltextcache[self._node])
                 else:
                     text = store.revision(self._node)
                     arraytext = bytearray(text)
                     store.fulltextcache[self._node] = arraytext
                 self._data = treemanifest(
                     self._manifestlog.nodeconstants, dir=self._dir, text=text
                 )
 
         return self._data
 
     def node(self) -> bytes:
         return self._node
 
     def copy(self) -> 'memtreemanifestctx':
         memmf = memtreemanifestctx(self._manifestlog, dir=self._dir)
         memmf._treemanifest = self.read().copy()
         return memmf
 
     @propertycache
     def parents(self) -> Tuple[bytes, bytes]:
         return self._storage().parents(self._node)
 
     def readdelta(self, shallow: bool = False) -> AnyManifestDict:
         """see `imanifestrevisionstored` documentation"""
         util.nouideprecwarn(
             b'"readdelta" is deprecated use "read_any_fast_delta" or "read_delta_new_entries"',
             b"6.9",
             stacklevel=2,
         )
         store = self._storage()
         if shallow:
             r = store.rev(self._node)
             d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))
             return manifestdict(store.nodeconstants.nodelen, d)
         else:
             # Need to perform a slow delta
             r0 = store.deltaparent(store.rev(self._node))
             m0 = self._manifestlog.get(self._dir, store.node(r0)).read()
             m1 = self.read()
             md = treemanifest(self._manifestlog.nodeconstants, dir=self._dir)
             for f, ((n0, fl0), (n1, fl1)) in m0.diff(m1).items():
                 if n1:
                     md[f] = n1
                     if fl1:
                         md.setflag(f, fl1)
             return md
 
     def read_any_fast_delta(
         self,
         valid_bases: Optional[Collection[int]] = None,
         *,
         shallow: bool = False,
     ) -> Tuple[Optional[int], AnyManifestDict]:
         """see `imanifestrevisionstored` documentation"""
         store = self._storage()
         r = store.rev(self._node)
         deltaparent = store.deltaparent(r)
 
         if valid_bases is None:
             # make sure the next check is True
             valid_bases = (deltaparent,)
         can_use_delta = deltaparent != nullrev and deltaparent in valid_bases
 
         if shallow:
             if can_use_delta:
                 return (deltaparent, self._read_storage_delta_shallow())
             else:
                 d = store.revision(self._node)
                 return (None, manifestdict(store.nodeconstants.nodelen, d))
         else:
             # note: This use "slow_delta" here is cargo culted from the previous
             # implementation. I am not sure it make sense since the goal here is to
             # be fast, so why are we computing a delta? On the other hand, tree
             # manifest delta as fairly "cheap" and allow for skipping whole part of
             # the tree that a full read would access. So it might be a good idea.
             #
             # If we realize we don't need delta here, we should simply use:
             #
             #     return (None, self.read())
             if can_use_delta:
                 return (None, self._read_storage_slow_delta(base=deltaparent))
             else:
                 parents = [
                     p
                     for p in store.parentrevs(r)
                     if p is not nullrev and p in valid_bases
                 ]
                 if parents:
                     best_base = max(parents)
                 else:
                     best_base = max(valid_bases)
                 return (None, self._read_storage_slow_delta(base=best_base))
 
     def _read_storage_delta_shallow(self) -> manifestdict:
         store = self._storage()
         r = store.rev(self._node)
         d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))
         return manifestdict(store.nodeconstants.nodelen, d)
 
     def _read_storage_slow_delta(self, base) -> 'treemanifest':
         store = self._storage()
         if base is None:
             base = store.deltaparent(store.rev(self._node))
         m0 = self._manifestlog.get(self._dir, store.node(base)).read()
         m1 = self.read()
         md = treemanifest(self._manifestlog.nodeconstants, dir=self._dir)
         for f, ((n0, fl0), (n1, fl1)) in m0.diff(m1).items():
             if n1:
                 md[f] = n1
                 if fl1:
                     md.setflag(f, fl1)
         return md
 
     def read_delta_parents(
         self,
         *,
         shallow: bool = False,
         exact: bool = True,
     ) -> AnyManifestDict:
         """see `interface.imanifestrevisionbase` documentations"""
         store = self._storage()
         r = store.rev(self._node)
         parents = [p for p in store.parentrevs(r) if p is not nullrev]
         if not exact:
             return self.read_any_fast_delta(parents, shallow=shallow)[1]
         elif len(parents) == 0:
             if shallow:
                 d = store.revision(self._node)
                 return manifestdict(store.nodeconstants.nodelen, d)
             else:
                 return self.read()
         elif len(parents) == 1:
             p = parents[0]
             if shallow:
                 d = mdiff.patchtext(store.revdiff(p, r))
                 return manifestdict(store.nodeconstants.nodelen, d)
             else:
                 return self._read_storage_slow_delta(base=p)
         else:
             p1, p2 = parents
             if shallow:
                 d1 = mdiff.patchtext(store.revdiff(p1, r))
                 d2 = mdiff.patchtext(store.revdiff(p2, r))
                 d1 = manifestdict(store.nodeconstants.nodelen, d1)
                 d2 = manifestdict(store.nodeconstants.nodelen, d2)
                 md = manifestdict(store.nodeconstants.nodelen)
                 for f, new_node, new_flag in d1.iterentries():
                     if f not in d2:
                         continue
                     if new_node is not None:
                         md.set(f, new_node, new_flag)
                 return md
             else:
                 m1 = self._manifestlog.get(self._dir, store.node(p1)).read()
                 m2 = self._manifestlog.get(self._dir, store.node(p2)).read()
                 mc = self.read()
                 d1 = m1.diff(mc)
                 d2 = m2.diff(mc)
                 md = treemanifest(
                     self._manifestlog.nodeconstants,
                     dir=self._dir,
                 )
                 for f, new_node, new_flag in d1.iterentries():
                     if f not in d2:
                         continue
                     if new_node is not None:
                         md.set(f, new_node, new_flag)
                 return md
 
     def read_delta_new_entries(
         self, *, shallow: bool = False
     ) -> AnyManifestDict:
         """see `interface.imanifestrevisionbase` documentations"""
         # If we are using narrow, returning a delta against an arbitrary
         # changeset might return file outside the narrowspec. This can create
         # issue when running validation server side with strict security as
         # push from low priviledge usage might be seen as adding new revision
         # for files they cannot touch. So we are strict if narrow is involved.
         if self._manifestlog.narrowed:
             return self.read_delta_parents(shallow=shallow, exact=True)
         # delegate to existing another existing method for simplicity
         store = self._storage()
         r = store.rev(self._node)
         bases = (store.deltaparent(r),)
         return self.read_any_fast_delta(bases, shallow=shallow)[1]
 
-    def readfast(self, shallow=False) -> AnyManifestDict:
+    def readfast(self, shallow: bool = False) -> AnyManifestDict:
         """Calls either readdelta or read, based on which would be less work.
         readdelta is called if the delta is against the p1, and therefore can be
         read quickly.
 
         If `shallow` is True, it only returns the entries from this manifest,
         and not any submanifests.
         """
         util.nouideprecwarn(
             b'"readdelta" is deprecated use "read_any_fast_delta" or "read_delta_parents"',
             b"6.9",
             stacklevel=2,
         )
         store = self._storage()
         r = store.rev(self._node)
         deltaparent = store.deltaparent(r)
         if deltaparent != nullrev and deltaparent in store.parentrevs(r):
             return self.readdelta(shallow=shallow)
 
         if shallow:
             return manifestdict(
                 store.nodeconstants.nodelen, store.revision(self._node)
             )
         else:
             return self.read()
 
     def find(self, key: bytes) -> Tuple[bytes, bytes]:
         return self.read().find(key)
 
 
 class excludeddir(treemanifest):
     """Stand-in for a directory that is excluded from the repository.
 
     With narrowing active on a repository that uses treemanifests,
     some of the directory revlogs will be excluded from the resulting
     clone. This is a huge storage win for clients, but means we need
     some sort of pseudo-manifest to surface to internals so we can
     detect a merge conflict outside the narrowspec. That's what this
     class is: it stands in for a directory whose node is known, but
     whose contents are unknown.
     """
 
     _files: Dict[bytes, bytes]
     _flags: Dict[bytes, bytes]
 
     def __init__(self, nodeconstants, dir, node):
         super(excludeddir, self).__init__(nodeconstants, dir)
         self._node = node
         # Add an empty file, which will be included by iterators and such,
         # appearing as the directory itself (i.e. something like "dir/")
         self._files[b''] = node
         self._flags[b''] = b't'
 
     # Manifests outside the narrowspec should never be modified, so avoid
     # copying. This makes a noticeable difference when there are very many
     # directories outside the narrowspec. Also, it makes sense for the copy to
     # be of the same type as the original, which would not happen with the
     # super type's copy().
     def copy(self):
         return self
 
 
 class excludeddirmanifestctx(treemanifestctx):
     """context wrapper for excludeddir - see that docstring for rationale"""
 
     def __init__(self, nodeconstants, dir, node):
         self.nodeconstants = nodeconstants
         self._dir = dir
         self._node = node
 
     def read(self):
         return excludeddir(self.nodeconstants, self._dir, self._node)
 
-    def readfast(self, shallow=False):
+    def readfast(self, shallow: bool = False):
         # special version of readfast since we don't have underlying storage
         return self.read()
 
     def write(self, *args):
         raise error.ProgrammingError(
             b'attempt to write manifest from excluded dir %s' % self._dir
         )
 
 
 class excludedmanifestrevlog(manifestrevlog):
     """Stand-in for excluded treemanifest revlogs.
 
     When narrowing is active on a treemanifest repository, we'll have
     references to directories we can't see due to the revlog being
     skipped. This class exists to conform to the manifestrevlog
     interface for those directories and proactively prevent writes to
     outside the narrowspec.
     """
 
     def __init__(self, nodeconstants, dir):
         self.nodeconstants = nodeconstants
         self._dir = dir
 
     def __len__(self):
         raise error.ProgrammingError(
             b'attempt to get length of excluded dir %s' % self._dir
         )
 
     def rev(self, node):
         raise error.ProgrammingError(
             b'attempt to get rev from excluded dir %s' % self._dir
         )
 
     def linkrev(self, node):
         raise error.ProgrammingError(
             b'attempt to get linkrev from excluded dir %s' % self._dir
         )
 
     def node(self, rev):
         raise error.ProgrammingError(
             b'attempt to get node from excluded dir %s' % self._dir
         )
 
     def add(self, *args, **kwargs):
         # We should never write entries in dirlogs outside the narrow clone.
         # However, the method still gets called from writesubtree() in
         # _addtree(), so we need to handle it. We should possibly make that
         # avoid calling add() with a clean manifest (_dirty is always False
         # in excludeddir instances).
         pass