This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11583

dirstate: align the dirstatemap's API to the data change
ClosedPublic

Authored by marmoute on Oct 2 2021, 8:25 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG98b3eb6c1479: dirstate: align the dirstatemap's API to the data change
Summary

We are passing different data, so lets simplify the dirstatemap API too.

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.

Event Timeline

marmoute created this revision.Oct 2 2021, 8:25 PM
marmoute updated this revision to Diff 30580.Oct 2 2021, 8:39 PM
Alphare accepted this revision.Oct 3 2021, 5:08 PM
This revision is now accepted and ready to land.Oct 3 2021, 5:08 PM
marmoute added a commit: rHG98b3eb6c1479: dirstate: align the dirstatemap's API to the data change.Oct 3 2021, 5:33 PM
Closed by commit rHG98b3eb6c1479: dirstate: align the dirstatemap's API to the data change (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/dirstate.py (23 lines)
Mmercurial/dirstatemap.py (19 lines)

Diff 30642

mercurial/dirstate.py

if self.in_merge: if self.in_merge:
msg = b'update_file_reference should not be called when merging' msg = b'update_file_reference should not be called when merging'
raise error.ProgrammingError(msg) raise error.ProgrammingError(msg)
entry = self._map.get(filename) entry = self._map.get(filename)
if entry is None: if entry is None:
wc_tracked = False wc_tracked = False
else: else:
wc_tracked = entry.tracked wc_tracked = entry.tracked
possibly_dirty = False if not (p1_tracked or wc_tracked):
if p1_tracked and wc_tracked:
# the underlying reference might have changed, we will have to
# check it.
possibly_dirty = True
elif not (p1_tracked or wc_tracked):
# the file is no longer relevant to anyone # the file is no longer relevant to anyone
if self._map.get(filename) is not None: if self._map.get(filename) is not None:
self._map.reset_state(filename) self._map.reset_state(filename)
self._dirty = True self._dirty = True
elif (not p1_tracked) and wc_tracked: elif (not p1_tracked) and wc_tracked:
if entry is not None and entry.added: if entry is not None and entry.added:
return # avoid dropping copy information (maybe?) return # avoid dropping copy information (maybe?)
elif p1_tracked and not wc_tracked:
pass
else:
assert False, 'unreachable'
# this mean we are doing call for file we do not really care about the # this mean we are doing call for file we do not really care about the
# data (eg: added or removed), however this should be a minor overhead # data (eg: added or removed), however this should be a minor overhead
# compared to the overall update process calling this. # compared to the overall update process calling this.
parentfiledata = None parentfiledata = None
if wc_tracked: if wc_tracked:
parentfiledata = self._get_filedata(filename) parentfiledata = self._get_filedata(filename)
self._map.reset_state( self._map.reset_state(
filename, filename,
wc_tracked, wc_tracked,
p1_tracked, p1_tracked,
possibly_dirty=possibly_dirty, # the underlying reference might have changed, we will have to
# check it.
has_meaningful_mtime=False,
parentfiledata=parentfiledata, parentfiledata=parentfiledata,
) )
if ( if (
parentfiledata is not None parentfiledata is not None
and parentfiledata[2] > self._lastnormaltime and parentfiledata[2] > self._lastnormaltime
): ):
# Remember the most recent modification timeslot for status(), # Remember the most recent modification timeslot for status(),
# to make sure we won't miss future size-preserving file content # to make sure we won't miss future size-preserving file content
# size-preserving file content modifications that happen # size-preserving file content modifications that happen
# within the same timeslot. # within the same timeslot.
self._lastnormaltime = mtime self._lastnormaltime = mtime
self._map.reset_state( self._map.reset_state(
filename, filename,
wc_tracked, wc_tracked,
p1_tracked, p1_tracked,
p2_tracked=p2_tracked, p2_info=merged or clean_p2,
merged=merged, has_meaningful_mtime=not possibly_dirty,
clean_p1=clean_p1,
clean_p2=clean_p2,
possibly_dirty=possibly_dirty,
parentfiledata=parentfiledata, parentfiledata=parentfiledata,
) )
if ( if (
parentfiledata is not None parentfiledata is not None
and parentfiledata[2] > self._lastnormaltime and parentfiledata[2] > self._lastnormaltime
): ):
# Remember the most recent modification timeslot for status(), # Remember the most recent modification timeslot for status(),
# to make sure we won't miss future size-preserving file content # to make sure we won't miss future size-preserving file content
if self.in_merge: if self.in_merge:
self.set_tracked(f) self.set_tracked(f)
else: else:
self._map.reset_state( self._map.reset_state(
f, f,
wc_tracked=True, wc_tracked=True,
p1_tracked=True, p1_tracked=True,
possibly_dirty=True,
) )
for f in to_drop: for f in to_drop:
self._map.reset_state(f) self._map.reset_state(f)
self._dirty = True self._dirty = True
def identity(self): def identity(self):
"""Return identity of dirstate itself to detect changing in storage """Return identity of dirstate itself to detect changing in storage

mercurial/dirstatemap.py

self._refresh_entry(f, entry) self._refresh_entry(f, entry)
return True return True
def reset_state( def reset_state(
self, self,
filename, filename,
wc_tracked=False, wc_tracked=False,
p1_tracked=False, p1_tracked=False,
p2_tracked=False, p2_info=False,
merged=False, has_meaningful_mtime=True,
clean_p1=False, has_meaningful_data=True,
clean_p2=False,
possibly_dirty=False,
parentfiledata=None, parentfiledata=None,
): ):
"""Set a entry to a given state, diregarding all previous state """Set a entry to a given state, diregarding all previous state
This is to be used by the part of the dirstate API dedicated to This is to be used by the part of the dirstate API dedicated to
adjusting the dirstate after a update/merge. adjusting the dirstate after a update/merge.
note: calling this might result to no entry existing at all if the note: calling this might result to no entry existing at all if the
dirstate map does not see any point at having one for this file dirstate map does not see any point at having one for this file
anymore. anymore.
""" """
if merged and (clean_p1 or clean_p2):
msg = b'`merged` argument incompatible with `clean_p1`/`clean_p2`'
raise error.ProgrammingError(msg)
# copy information are now outdated # copy information are now outdated
# (maybe new information should be in directly passed to this function) # (maybe new information should be in directly passed to this function)
self.copymap.pop(filename, None) self.copymap.pop(filename, None)
if not (p1_tracked or p2_tracked or wc_tracked): if not (p1_tracked or p2_info or wc_tracked):
old_entry = self._map.get(filename) old_entry = self._map.get(filename)
self._drop_entry(filename) self._drop_entry(filename)
self._dirs_decr(filename, old_entry=old_entry) self._dirs_decr(filename, old_entry=old_entry)
return return
p2_info = merged or clean_p2
if merged:
assert p1_tracked
has_meaningful_mtime = not possibly_dirty
old_entry = self._map.get(filename) old_entry = self._map.get(filename)
self._dirs_incr(filename, old_entry) self._dirs_incr(filename, old_entry)
entry = DirstateItem( entry = DirstateItem(
wc_tracked=wc_tracked, wc_tracked=wc_tracked,
p1_tracked=p1_tracked, p1_tracked=p1_tracked,
p2_info=p2_info, p2_info=p2_info,
has_meaningful_mtime=has_meaningful_mtime, has_meaningful_mtime=has_meaningful_mtime,
parentfiledata=parentfiledata, parentfiledata=parentfiledata,