( )⚙ D10926 dirstate: introduce a symbolic constant for the FROM_P2 marker

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10926

dirstate: introduce a symbolic constant for the FROM_P2 marker
ClosedPublic

Authored by marmoute on Jul 2 2021, 11:17 AM.

Details

Reviewers
SimonSapin
pulkit
Group Reviewers
hg-reviewers
Commits
rHGcb29484eaade: dirstate: introduce a symbolic constant for the FROM_P2 marker
Summary

This is going to be clearer and easier to track than -2. Ultimately I would
like to get ride of this special value everywhere but in the lower level,
however we need to clarify the API first. This changeset is part of such
clarification.

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/dirstate.py (26 lines)

Diff 28758

mercurial/dirstate.py

propertycache = util.propertycache propertycache = util.propertycache
filecache = scmutil.filecache filecache = scmutil.filecache
_rangemask = 0x7FFFFFFF _rangemask = 0x7FFFFFFF
dirstatetuple = parsers.dirstatetuple dirstatetuple = parsers.dirstatetuple
# a special value used internally for `size` if the file come from the other parent
FROM_P2 = -2
class repocache(filecache): class repocache(filecache):
"""filecache for files in .hg/""" """filecache for files in .hg/"""
def join(self, obj, fname): def join(self, obj, fname):
return obj._opener.join(fname) return obj._opener.join(fname)
class rootcache(filecache): class rootcache(filecache):
# Discard 'm' markers when moving away from a merge state # Discard 'm' markers when moving away from a merge state
if s[0] == b'm': if s[0] == b'm':
source = self._map.copymap.get(f) source = self._map.copymap.get(f)
if source: if source:
copies[f] = source copies[f] = source
self.normallookup(f) self.normallookup(f)
# Also fix up otherparent markers # Also fix up otherparent markers
elif s[0] == b'n' and s[2] == -2: elif s[0] == b'n' and s[2] == FROM_P2:
source = self._map.copymap.get(f) source = self._map.copymap.get(f)
if source: if source:
copies[f] = source copies[f] = source
self.add(f) self.add(f)
return copies return copies
def setbranch(self, branch): def setbranch(self, branch):
self.__class__._branch.set(self, encoding.fromlocal(branch)) self.__class__._branch.set(self, encoding.fromlocal(branch))
def normallookup(self, f): def normallookup(self, f):
'''Mark a file normal, but possibly dirty.''' '''Mark a file normal, but possibly dirty.'''
if self._pl[1] != self._nodeconstants.nullid: if self._pl[1] != self._nodeconstants.nullid:
# if there is a merge going on and the file was either # if there is a merge going on and the file was either
# in state 'm' (-1) or coming from other parent (-2) before # in state 'm' (-1) or coming from other parent (-2) before
# being removed, restore that state. # being removed, restore that state.
entry = self._map.get(f) entry = self._map.get(f)
if entry is not None: if entry is not None:
if entry[0] == b'r' and entry[2] in (-1, -2): if entry[0] == b'r' and entry[2] in (-1, FROM_P2):
source = self._map.copymap.get(f) source = self._map.copymap.get(f)
if entry[2] == -1: if entry[2] == -1:
self.merge(f) self.merge(f)
elif entry[2] == -2: elif entry[2] == FROM_P2:
self.otherparent(f) self.otherparent(f)
if source: if source:
self.copy(source, f) self.copy(source, f)
return return
if entry[0] == b'm' or entry[0] == b'n' and entry[2] == -2: if entry[0] == b'm' or entry[0] == b'n' and entry[2] == FROM_P2:
return return
self._addpath(f, b'n', 0, -1, -1) self._addpath(f, b'n', 0, -1, -1)
self._map.copymap.pop(f, None) self._map.copymap.pop(f, None)
def otherparent(self, f): def otherparent(self, f):
'''Mark as coming from the other parent, always dirty.''' '''Mark as coming from the other parent, always dirty.'''
if self._pl[1] == self._nodeconstants.nullid: if self._pl[1] == self._nodeconstants.nullid:
msg = _(b"setting %r to other parent only allowed in merges") % f msg = _(b"setting %r to other parent only allowed in merges") % f
raise error.Abort(msg) raise error.Abort(msg)
if f in self and self[f] == b'n': if f in self and self[f] == b'n':
# merge-like # merge-like
self._addpath(f, b'm', 0, -2, -1) self._addpath(f, b'm', 0, FROM_P2, -1)
else: else:
# add-like # add-like
self._addpath(f, b'n', 0, -2, -1) self._addpath(f, b'n', 0, FROM_P2, -1)
self._map.copymap.pop(f, None) self._map.copymap.pop(f, None)
def add(self, f): def add(self, f):
'''Mark a file added.''' '''Mark a file added.'''
self._addpath(f, b'a', 0, -1, -1) self._addpath(f, b'a', 0, -1, -1)
self._map.copymap.pop(f, None) self._map.copymap.pop(f, None)
def remove(self, f): def remove(self, f):
'''Mark a file removed.''' '''Mark a file removed.'''
self._dirty = True self._dirty = True
oldstate = self[f] oldstate = self[f]
size = 0 size = 0
if self._pl[1] != self._nodeconstants.nullid: if self._pl[1] != self._nodeconstants.nullid:
entry = self._map.get(f) entry = self._map.get(f)
if entry is not None: if entry is not None:
# backup the previous state # backup the previous state
if entry[0] == b'm': # merge if entry[0] == b'm': # merge
size = -1 size = -1
elif entry[0] == b'n' and entry[2] == -2: # other parent elif entry[0] == b'n' and entry[2] == FROM_P2: # other parent
size = -2 size = FROM_P2
self._map.otherparentset.add(f) self._map.otherparentset.add(f)
self._updatedfiles.add(f) self._updatedfiles.add(f)
self._map.removefile(f, oldstate, size) self._map.removefile(f, oldstate, size)
if size == 0: if size == 0:
self._map.copymap.pop(f, None) self._map.copymap.pop(f, None)
def merge(self, f): def merge(self, f):
'''Mark a file merged.''' '''Mark a file merged.'''
dadd(fn) dadd(fn)
elif state == b'n': elif state == b'n':
if ( if (
size >= 0 size >= 0
and ( and (
(size != st.st_size and size != st.st_size & _rangemask) (size != st.st_size and size != st.st_size & _rangemask)
or ((mode ^ st.st_mode) & 0o100 and checkexec) or ((mode ^ st.st_mode) & 0o100 and checkexec)
) )
or size == -2 # other parent or size == FROM_P2 # other parent
or fn in copymap or fn in copymap
): ):
if stat.S_ISLNK(st.st_mode) and size != st.st_size: if stat.S_ISLNK(st.st_mode) and size != st.st_size:
# issue6456: Size returned may be longer due to # issue6456: Size returned may be longer due to
# encryption on EXT-4 fscrypt, undecided. # encryption on EXT-4 fscrypt, undecided.
ladd(fn) ladd(fn)
else: else:
madd(fn) madd(fn)
"""Add a tracked file to the dirstate.""" """Add a tracked file to the dirstate."""
if oldstate in b"?r" and "_dirs" in self.__dict__: if oldstate in b"?r" and "_dirs" in self.__dict__:
self._dirs.addpath(f) self._dirs.addpath(f)
if oldstate == b"?" and "_alldirs" in self.__dict__: if oldstate == b"?" and "_alldirs" in self.__dict__:
self._alldirs.addpath(f) self._alldirs.addpath(f)
self._map[f] = dirstatetuple(state, mode, size, mtime) self._map[f] = dirstatetuple(state, mode, size, mtime)
if state != b'n' or mtime == -1: if state != b'n' or mtime == -1:
self.nonnormalset.add(f) self.nonnormalset.add(f)
if size == -2: if size == FROM_P2:
self.otherparentset.add(f) self.otherparentset.add(f)
def removefile(self, f, oldstate, size): def removefile(self, f, oldstate, size):
""" """
Mark a file as removed in the dirstate. Mark a file as removed in the dirstate.
The `size` parameter is used to store sentinel values that indicate The `size` parameter is used to store sentinel values that indicate
the file's previous state. In the future, we should refactor this the file's previous state. In the future, we should refactor this
try: try:
return parsers.nonnormalotherparententries(self._map) return parsers.nonnormalotherparententries(self._map)
except AttributeError: except AttributeError:
nonnorm = set() nonnorm = set()
otherparent = set() otherparent = set()
for fname, e in pycompat.iteritems(self._map): for fname, e in pycompat.iteritems(self._map):
if e[0] != b'n' or e[3] == -1: if e[0] != b'n' or e[3] == -1:
nonnorm.add(fname) nonnorm.add(fname)
if e[0] == b'n' and e[2] == -2: if e[0] == b'n' and e[2] == FROM_P2:
otherparent.add(fname) otherparent.add(fname)
return nonnorm, otherparent return nonnorm, otherparent
@propertycache @propertycache
def filefoldmap(self): def filefoldmap(self):
"""Returns a dictionary mapping normalized case paths to their """Returns a dictionary mapping normalized case paths to their
non-normalized versions. non-normalized versions.
""" """