This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4874

treemanifests: store whether a lazydirs entry needs copied after materializing
ClosedPublic

Authored by spectral on Oct 3 2018, 6:22 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGa0c18b271ea1: treemanifests: store whether a lazydirs entry needs copied after materializing
Summary

Due to the way that things like manifestlog.get caches its values, without
making a copy (if necessary) after calling readsubtree(), we might end up
adjusting the state of the same object on different contexts, breaking things
like dirty state tracking (and probably other things).

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Revision Contents
Changeset List

PathPackages
Mmercurial/manifest.py (22 lines)

Diff 11673

mercurial/manifest.py

'flat manifests') 'flat manifests')
self.parse(text, readsubtree) self.parse(text, readsubtree)
self._dirty = True # Mark flat manifest dirty after parsing self._dirty = True # Mark flat manifest dirty after parsing
def _subpath(self, path): def _subpath(self, path):
return self._dir + path return self._dir + path
def _loadalllazy(self): def _loadalllazy(self):
for k, (path, node, readsubtree) in self._lazydirs.iteritems(): selfdirs = self._dirs
self._dirs[k] = readsubtree(path, node) for d, (path, node, readsubtree, docopy) in self._lazydirs.iteritems():
if docopy:
selfdirs[d] = readsubtree(path, node).copy()
else:
selfdirs[d] = readsubtree(path, node)
self._lazydirs = {} self._lazydirs = {}
def _loadlazy(self, d): def _loadlazy(self, d):
v = self._lazydirs.get(d) v = self._lazydirs.get(d)
if v: if v:
path, node, readsubtree = v path, node, readsubtree, docopy = v
if docopy:
self._dirs[d] = readsubtree(path, node).copy()
else:
self._dirs[d] = readsubtree(path, node) self._dirs[d] = readsubtree(path, node)
del self._lazydirs[d] del self._lazydirs[d]
def _loadchildrensetlazy(self, visit): def _loadchildrensetlazy(self, visit):
if not visit: if not visit:
return None return None
if visit == 'all' or visit == 'this': if visit == 'all' or visit == 'this':
self._loadalllazy() self._loadalllazy()
return None return None
return not self._dirty and not m2._dirty and self._node == m2._node return not self._dirty and not m2._dirty and self._node == m2._node
def parse(self, text, readsubtree): def parse(self, text, readsubtree):
selflazy = self._lazydirs selflazy = self._lazydirs
subpath = self._subpath subpath = self._subpath
for f, n, fl in _parse(text): for f, n, fl in _parse(text):
if fl == 't': if fl == 't':
f = f + '/' f = f + '/'
selflazy[f] = (subpath(f), n, readsubtree) # False below means "doesn't need to be copied" and can use the
# cached value from readsubtree directly.
selflazy[f] = (subpath(f), n, readsubtree, False)
elif '/' in f: elif '/' in f:
# This is a flat manifest, so use __setitem__ and setflag rather # This is a flat manifest, so use __setitem__ and setflag rather
# than assigning directly to _files and _flags, so we can # than assigning directly to _files and _flags, so we can
# assign a path in a subdirectory, and to mark dirty (compared # assign a path in a subdirectory, and to mark dirty (compared
# to nullid). # to nullid).
self[f] = n self[f] = n
if fl: if fl:
self.setflag(f, fl) self.setflag(f, fl)
return _text(self.iterentries()) return _text(self.iterentries())
def dirtext(self): def dirtext(self):
"""Get the full data of this directory as a bytestring. Make sure that """Get the full data of this directory as a bytestring. Make sure that
any submanifests have been written first, so their nodeids are correct. any submanifests have been written first, so their nodeids are correct.
""" """
self._load() self._load()
flags = self.flags flags = self.flags
lazydirs = [(d[:-1], node, 't') for lazydirs = [(d[:-1], v[1], 't') for d, v in self._lazydirs.iteritems()]
d, (path, node, readsubtree) in self._lazydirs.iteritems()]
dirs = [(d[:-1], self._dirs[d]._node, 't') for d in self._dirs] dirs = [(d[:-1], self._dirs[d]._node, 't') for d in self._dirs]
files = [(f, self._files[f], flags(f)) for f in self._files] files = [(f, self._files[f], flags(f)) for f in self._files]
return _text(sorted(dirs + files + lazydirs)) return _text(sorted(dirs + files + lazydirs))
def read(self, gettext, readsubtree): def read(self, gettext, readsubtree):
def _load_for_read(s): def _load_for_read(s):
s.parse(gettext(), readsubtree) s.parse(gettext(), readsubtree)
s._dirty = False s._dirty = False