This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9040

merge: use in-memory mergestate when using in-memory context
ClosedPublic

Authored by martinvonz on Sep 17 2020, 4:10 PM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHG19590b126764: merge: use in-memory mergestate when using in-memory context
Summary

This is my version of Augie's D8568. It makes it so we don't touch the
mergestate on disk when using an in-memory context.

The reason that I want this is not the same as the reason that Augie
write his patch (though I agree with that reason too). My hope is to
make in-memory rebase not fall back to on-disk rebase when there are
conflict. I plan to do that by adding a
overlayworkingctx.reflect_in_workingcopy(). The idea is that that
will update the working copy, the dirstate and the mergestate as
necessary.

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

martinvonz created this revision.Sep 17 2020, 4:10 PM
indygreg accepted this revision.Sep 17 2020, 10:24 PM
This revision is now accepted and ready to land.Sep 17 2020, 10:24 PM

Revision Contents
Changeset List

PathPackages
Mmercurial/context.py (6 lines)
Mmercurial/merge.py (8 lines)
Mmercurial/mergestate.py (26 lines)

Diff 22707

mercurial/context.py

date=precursor.date(), date=precursor.date(),
user=precursor.user(), user=precursor.user(),
) )
def isdirty(self, path): def isdirty(self, path):
return path in self._cache return path in self._cache
def clean(self): def clean(self):
self._mergestate = None
self._cache = {} self._cache = {}
def _compact(self): def _compact(self):
"""Removes keys from the cache that are actually clean, by comparing """Removes keys from the cache that are actually clean, by comparing
them with the underlying context. them with the underlying context.
This can occur during the merge process, e.g. by passing --tool :local This can occur during the merge process, e.g. by passing --tool :local
to resolve a conflict. to resolve a conflict.
b'copied': copied, b'copied': copied,
} }
def filectx(self, path, filelog=None): def filectx(self, path, filelog=None):
return overlayworkingfilectx( return overlayworkingfilectx(
self._repo, path, parent=self, filelog=filelog self._repo, path, parent=self, filelog=filelog
) )
def mergestate(self, clean=False):
if clean or self._mergestate is None:
self._mergestate = mergestatemod.memmergestate(self._repo)
return self._mergestate
class overlayworkingfilectx(committablefilectx): class overlayworkingfilectx(committablefilectx):
"""Wrap a ``workingfilectx`` but intercepts all writes into an in-memory """Wrap a ``workingfilectx`` but intercepts all writes into an in-memory
cache, which can be flushed through later by calling ``flush()``.""" cache, which can be flushed through later by calling ``flush()``."""
def __init__(self, repo, path, filelog=None, parent=None): def __init__(self, repo, path, filelog=None, parent=None):
super(overlayworkingfilectx, self).__init__(repo, path, filelog, parent) super(overlayworkingfilectx, self).__init__(repo, path, filelog, parent)
self._repo = repo self._repo = repo

mercurial/merge.py

(updated, merged, removed, unresolved) that describes how many (updated, merged, removed, unresolved) that describes how many
files were affected by the update, and filedata is as described in files were affected by the update, and filedata is as described in
batchget. batchget.
""" """
_prefetchfiles(repo, mctx, mresult) _prefetchfiles(repo, mctx, mresult)
updated, merged, removed = 0, 0, 0 updated, merged, removed = 0, 0, 0
ms = mergestatemod.mergestate.clean(repo) ms = wctx.mergestate(clean=True)
ms.start(wctx.p1().node(), mctx.node(), labels) ms.start(wctx.p1().node(), mctx.node(), labels)
for f, op in pycompat.iteritems(mresult.commitinfo): for f, op in pycompat.iteritems(mresult.commitinfo):
# the other side of filenode was choosen while merging, store this in # the other side of filenode was choosen while merging, store this in
# mergestate so that it can be reused on commit # mergestate so that it can be reused on commit
ms.addcommitinfo(f, op) ms.addcommitinfo(f, op)
numupdates = mresult.len() - mresult.len(mergeresult.NO_OP_ACTIONS) numupdates = mresult.len() - mresult.len(mergeresult.NO_OP_ACTIONS)
) )
) )
# the ordering is important here -- ms.mergedriver will raise if the merge # the ordering is important here -- ms.mergedriver will raise if the merge
# driver has changed, and we want to be able to bypass it when overwrite is # driver has changed, and we want to be able to bypass it when overwrite is
# True # True
usemergedriver = not overwrite and mergeactions and ms.mergedriver usemergedriver = not overwrite and mergeactions and ms.mergedriver
if usemergedriver: if usemergedriver:
if wctx.isinmemory():
raise error.InMemoryMergeConflictsError(
b"in-memory merge does not support mergedriver"
)
ms.commit() ms.commit()
proceed = driverpreprocess(repo, ms, wctx, labels=labels) proceed = driverpreprocess(repo, ms, wctx, labels=labels)
# the driver might leave some files unresolved # the driver might leave some files unresolved
unresolvedf = set(ms.unresolved()) unresolvedf = set(ms.unresolved())
if not proceed: if not proceed:
# XXX setting unresolved to at least 1 is a hack to make sure we # XXX setting unresolved to at least 1 is a hack to make sure we
# error out # error out
return updateresult( return updateresult(
fp1, fp2, xp1, xp2 = p1.node(), p2.node(), bytes(p1), bytes(p2) fp1, fp2, xp1, xp2 = p1.node(), p2.node(), bytes(p1), bytes(p2)
overwrite = force and not branchmerge overwrite = force and not branchmerge
### check phase ### check phase
if not overwrite: if not overwrite:
if len(pl) > 1: if len(pl) > 1:
raise error.Abort(_(b"outstanding uncommitted merge")) raise error.Abort(_(b"outstanding uncommitted merge"))
ms = mergestatemod.mergestate.read(repo) ms = wc.mergestate()
if list(ms.unresolved()): if list(ms.unresolved()):
raise error.Abort( raise error.Abort(
_(b"outstanding merge conflicts"), _(b"outstanding merge conflicts"),
hint=_(b"use 'hg resolve' to resolve"), hint=_(b"use 'hg resolve' to resolve"),
) )
if branchmerge: if branchmerge:
if pas == [p2]: if pas == [p2]:
raise error.Abort( raise error.Abort(

mercurial/mergestate.py

def _restore_backup(self, fctx, localkey, flags): def _restore_backup(self, fctx, localkey, flags):
with self._repo.vfs(b'merge/' + localkey) as f: with self._repo.vfs(b'merge/' + localkey) as f:
fctx.write(f.read(), flags) fctx.write(f.read(), flags)
def reset(self): def reset(self):
shutil.rmtree(self._repo.vfs.join(b'merge'), True) shutil.rmtree(self._repo.vfs.join(b'merge'), True)
class memmergestate(_mergestate_base):
def __init__(self, repo):
super(memmergestate, self).__init__(repo)
self._backups = {}
def _make_backup(self, fctx, localkey):
self._backups[localkey] = fctx.data()
def _restore_backup(self, fctx, localkey, flags):
fctx.write(self._backups[localkey], flags)
@util.propertycache
def mergedriver(self):
configmergedriver = self._repo.ui.config(
b'experimental', b'mergedriver'
)
if configmergedriver:
raise error.InMemoryMergeConflictsError(
b"in-memory merge does not support mergedriver"
)
return None
def commit(self):
pass
def recordupdates(repo, actions, branchmerge, getfiledata): def recordupdates(repo, actions, branchmerge, getfiledata):
"""record merge actions to the dirstate""" """record merge actions to the dirstate"""
# remove (must come first) # remove (must come first)
for f, args, msg in actions.get(ACTION_REMOVE, []): for f, args, msg in actions.get(ACTION_REMOVE, []):
if branchmerge: if branchmerge:
repo.dirstate.remove(f) repo.dirstate.remove(f)
else: else:
repo.dirstate.drop(f) repo.dirstate.drop(f)