This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7989

copies: define a type to return from mergecopies()
ClosedPublic

Authored by martinvonz on Jan 24 2020, 5:01 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG7f8bdee0034e: copies: define a type to return from mergecopies()
rHGece703502f52: copies: define a type to return from mergecopies()
Summary

We'll soon return two instances of many of the dicts from
copies.mergecopies(). That will mean that we need to return 9
different dicts, which is clearly not manageable. This patch instead
encapsulates the 4 dicts we'll duplicate in a new type. For now, we
still just return one instance of it (plus the separate diverge
dict).

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

martinvonz created this revision.Jan 24 2020, 5:01 PM
martinvonz updated this revision to Diff 19582.Jan 24 2020, 6:34 PM
martinvonz added a commit: rHGece703502f52: copies: define a type to return from mergecopies().Jan 29 2020, 6:18 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGece703502f52: copies: define a type to return from mergecopies() (authored by martinvonz). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/copies.py (57 lines)
Mmercurial/merge.py (7 lines)

Diff 19566

mercurial/copies.py

o ---> 1 merge base o ---> 1 merge base
If we try to rebase revision 3 on revision 4, since there is no a.txt in If we try to rebase revision 3 on revision 4, since there is no a.txt in
revision 4, and if user have copytrace disabled, we prints the following revision 4, and if user have copytrace disabled, we prints the following
message: message:
```other changed <file> which local deleted``` ```other changed <file> which local deleted```
Returns five dicts: "copy", "movewithdir", "diverge", "renamedelete" and Returns a tuple where:
"dirmove".
"copy" is a mapping from destination name -> source name, "branch_copies" an instance of branch_copies.
where source is in c1 and destination is in c2 or vice-versa.
"movewithdir" is a mapping from source name -> destination name,
where the file at source present in one context but not the other
needs to be moved to destination by the merge process, because the
other context moved the directory it is in.
"diverge" is a mapping of source name -> list of destination names "diverge" is a mapping of source name -> list of destination names
for divergent renames. for divergent renames.
"renamedelete" is a mapping of source name -> list of destination
names for files deleted in c1 that were renamed in c2 or vice-versa.
"dirmove" is a mapping of detected source dir -> destination dir renames.
This is needed for handling changes to new files previously grafted into
renamed directories.
This function calls different copytracing algorithms based on config. This function calls different copytracing algorithms based on config.
""" """
# avoid silly behavior for update from empty dir # avoid silly behavior for update from empty dir
if not c1 or not c2 or c1 == c2: if not c1 or not c2 or c1 == c2:
return {}, {}, {}, {}, {} return branch_copies(), {}
narrowmatch = c1.repo().narrowmatch() narrowmatch = c1.repo().narrowmatch()
# avoid silly behavior for parent -> working dir # avoid silly behavior for parent -> working dir
if c2.node() is None and c1.node() == repo.dirstate.p1(): if c2.node() is None and c1.node() == repo.dirstate.p1():
return _dirstatecopies(repo, narrowmatch), {}, {}, {}, {} return branch_copies(_dirstatecopies(repo, narrowmatch)), {}
copytracing = repo.ui.config(b'experimental', b'copytrace') copytracing = repo.ui.config(b'experimental', b'copytrace')
if stringutil.parsebool(copytracing) is False: if stringutil.parsebool(copytracing) is False:
# stringutil.parsebool() returns None when it is unable to parse the # stringutil.parsebool() returns None when it is unable to parse the
# value, so we should rely on making sure copytracing is on such cases # value, so we should rely on making sure copytracing is on such cases
return {}, {}, {}, {}, {} return branch_copies(), {}
if usechangesetcentricalgo(repo): if usechangesetcentricalgo(repo):
# The heuristics don't make sense when we need changeset-centric algos # The heuristics don't make sense when we need changeset-centric algos
return _fullcopytracing(repo, c1, c2, base) return _fullcopytracing(repo, c1, c2, base)
# Copy trace disabling is explicitly below the node == p1 logic above # Copy trace disabling is explicitly below the node == p1 logic above
# because the logic above is required for a simple copy to be kept across a # because the logic above is required for a simple copy to be kept across a
# rebase. # rebase.
# modified on side 2 # modified on side 2
for dst in dsts1: for dst in dsts1:
if dst not in m2: if dst not in m2:
# dst not added on side 2 (handle as regular # dst not added on side 2 (handle as regular
# "both created" case in manifestmerge otherwise) # "both created" case in manifestmerge otherwise)
copy[dst] = src copy[dst] = src
class branch_copies(object):
"""Information about copies made on one side of a merge/graft.
"copy" is a mapping from destination name -> source name,
where source is in c1 and destination is in c2 or vice-versa.
"movewithdir" is a mapping from source name -> destination name,
where the file at source present in one context but not the other
needs to be moved to destination by the merge process, because the
other context moved the directory it is in.
"renamedelete" is a mapping of source name -> list of destination
names for files deleted in c1 that were renamed in c2 or vice-versa.
"dirmove" is a mapping of detected source dir -> destination dir renames.
This is needed for handling changes to new files previously grafted into
renamed directories.
"""
def __init__(self, copy=None, renamedelete=None, dirmove=None, movewithdir=None):
self.copy = {} if copy is None else copy
self.renamedelete = {} if renamedelete is None else renamedelete
self.dirmove = {} if dirmove is None else dirmove
self.movewithdir = {} if movewithdir is None else movewithdir
def _fullcopytracing(repo, c1, c2, base): def _fullcopytracing(repo, c1, c2, base):
""" The full copytracing algorithm which finds all the new files that were """ The full copytracing algorithm which finds all the new files that were
added from merge base up to the top commit and for each file it checks if added from merge base up to the top commit and for each file it checks if
this file was copied from another file. this file was copied from another file.
This is pretty slow when a lot of changesets are involved but will track all This is pretty slow when a lot of changesets are involved but will track all
the copies. the copies.
""" """
m1 = c1.manifest() m1 = c1.manifest()
m2 = c2.manifest() m2 = c2.manifest()
mb = base.manifest() mb = base.manifest()
copies1 = pathcopies(base, c1) copies1 = pathcopies(base, c1)
copies2 = pathcopies(base, c2) copies2 = pathcopies(base, c2)
if not (copies1 or copies2): if not (copies1 or copies2):
return {}, {}, {}, {}, {} return branch_copies(), {}
inversecopies1 = {} inversecopies1 = {}
inversecopies2 = {} inversecopies2 = {}
for dst, src in copies1.items(): for dst, src in copies1.items():
inversecopies1.setdefault(src, []).append(dst) inversecopies1.setdefault(src, []).append(dst)
for dst, src in copies2.items(): for dst, src in copies2.items():
inversecopies2.setdefault(src, []).append(dst) inversecopies2.setdefault(src, []).append(dst)
dirmove1, movewithdir2 = _dir_renames(repo, c1, copy1, copies1, u2) dirmove1, movewithdir2 = _dir_renames(repo, c1, copy1, copies1, u2)
dirmove2, movewithdir1 = _dir_renames(repo, c2, copy2, copies2, u1) dirmove2, movewithdir1 = _dir_renames(repo, c2, copy2, copies2, u1)
copy1.update(copy2) copy1.update(copy2)
renamedelete1.update(renamedelete2) renamedelete1.update(renamedelete2)
movewithdir1.update(movewithdir2) movewithdir1.update(movewithdir2)
dirmove1.update(dirmove2) dirmove1.update(dirmove2)
return copy1, movewithdir1, diverge, renamedelete1, dirmove1 return branch_copies(copy1, renamedelete1, dirmove1, movewithdir1), diverge
def _dir_renames(repo, ctx, copy, fullcopy, addedfiles): def _dir_renames(repo, ctx, copy, fullcopy, addedfiles):
"""Finds moved directories and files that should move with them. """Finds moved directories and files that should move with them.
ctx: the context for one of the sides ctx: the context for one of the sides
copy: files copied on the same side (as ctx) copy: files copied on the same side (as ctx)
fullcopy: files copied on the same side (as ctx), including those that fullcopy: files copied on the same side (as ctx), including those that
for candidate in movecandidates: for candidate in movecandidates:
f1 = c1.filectx(candidate) f1 = c1.filectx(candidate)
if _related(f1, f2): if _related(f1, f2):
# if there are a few related copies then we'll merge # if there are a few related copies then we'll merge
# changes into all of them. This matches the behaviour # changes into all of them. This matches the behaviour
# of upstream copytracing # of upstream copytracing
copies[candidate] = f copies[candidate] = f
return copies, {}, {}, {}, {}
return branch_copies(copies), {}
def _related(f1, f2): def _related(f1, f2):
"""return True if f1 and f2 filectx have a common ancestor """return True if f1 and f2 filectx have a common ancestor
Walk back to common ancestor to see if the two files originate Walk back to common ancestor to see if the two files originate
from the same file. Since workingfilectx's rev() is None it messes from the same file. Since workingfilectx's rev() is None it messes
up the integer comparison logic, hence the pre-step check for up the integer comparison logic, hence the pre-step check for

mercurial/merge.py

# manifests fetched in order are going to be faster, so prime the caches # manifests fetched in order are going to be faster, so prime the caches
[ [
x.manifest() x.manifest()
for x in sorted(wctx.parents() + [p2, pa], key=scmutil.intrev) for x in sorted(wctx.parents() + [p2, pa], key=scmutil.intrev)
] ]
copy, movewithdir, diverge, renamedelete, dirmove = {}, {}, {}, {}, {} copy, movewithdir, diverge, renamedelete, dirmove = {}, {}, {}, {}, {}
if followcopies: if followcopies:
ret = copies.mergecopies(repo, wctx, p2, pa) branch_copies, diverge = copies.mergecopies(repo, wctx, p2, pa)
copy, movewithdir, diverge, renamedelete, dirmove = ret copy = branch_copies.copy
renamedelete = branch_copies.renamedelete
dirmove = branch_copies.dirmove
movewithdir = branch_copies.movewithdir
boolbm = pycompat.bytestr(bool(branchmerge)) boolbm = pycompat.bytestr(bool(branchmerge))
boolf = pycompat.bytestr(bool(force)) boolf = pycompat.bytestr(bool(force))
boolm = pycompat.bytestr(bool(matcher)) boolm = pycompat.bytestr(bool(matcher))
repo.ui.note(_(b"resolving manifests\n")) repo.ui.note(_(b"resolving manifests\n"))
repo.ui.debug( repo.ui.debug(
b" branchmerge: %s, force: %s, partial: %s\n" % (boolbm, boolf, boolm) b" branchmerge: %s, force: %s, partial: %s\n" % (boolbm, boolf, boolm)
) )