This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7860

graftcopies: remove `skip` and `repo` arguments
ClosedPublic

Authored by martinvonz on Jan 14 2020, 12:06 PM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG833210fbd900: graftcopies: remove `skip` and `repo` arguments
Summary

The skip argument was added in 2ba6c9b4e0eb (rebase: fix bug that
caused transitive copy records to disappear (issue4192), 2014-06-07)
in order to fix https://bz.mercurial-scm.org/show_bug.cgi?id=4192. I
ran tests at that commit without the skiprev argument and the only
difference I noticed was that test-rebase-collapse.t failed
differently, in the call that is now on line 501. Without the
skiprev argument, that call would end up creating another commit
because it tried to record an invalid copy. With the previous patch in
this series, such invalid copies are no longer recorded, so it seems
we don't need the skip argument anymore.

I also removed the repo argument since that also becomes unused with
the removal of the skip argument.

Diff Detail

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

Event Timeline

martinvonz created this revision.Jan 14 2020, 12:06 PM
pulkit accepted this revision.Jan 16 2020, 10:37 AM
This revision is now accepted and ready to land.Jan 16 2020, 10:37 AM
martinvonz added a commit: rHG833210fbd900: graftcopies: remove `skip` and `repo` arguments.Jan 16 2020, 11:30 AM
Closed by commit rHG833210fbd900: graftcopies: remove `skip` and `repo` arguments (authored by martinvonz). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mhgext/fix.py (5 lines)
Mhgext/rebase.py (9 lines)
Mmercurial/copies.py (23 lines)
Mmercurial/merge.py (2 lines)
Mrelnotes/next (3 lines)

Diff 19251

hgext/fix.py

and p2ctx.node() not in replacements and p2ctx.node() not in replacements
): ):
return return
extra = ctx.extra().copy() extra = ctx.extra().copy()
extra[b'fix_source'] = ctx.hex() extra[b'fix_source'] = ctx.hex()
wctx = context.overlayworkingctx(repo) wctx = context.overlayworkingctx(repo)
newp1ctx = repo[newp1node] wctx.setbase(repo[newp1node])
wctx.setbase(newp1ctx)
merge.update( merge.update(
repo, repo,
ctx.rev(), ctx.rev(),
branchmerge=False, branchmerge=False,
force=True, force=True,
ancestor=p1rev, ancestor=p1rev,
mergeancestor=False, mergeancestor=False,
wc=wctx, wc=wctx,
) )
copies.graftcopies(repo, wctx, ctx, ctx.p1(), skip=newp1ctx) copies.graftcopies(wctx, ctx, ctx.p1())
for path in filedata.keys(): for path in filedata.keys():
fctx = ctx[path] fctx = ctx[path]
copysource = fctx.copysource() copysource = fctx.copysource()
wctx.write(path, filedata[path], flags=fctx.flags()) wctx.write(path, filedata[path], flags=fctx.flags())
if copysource: if copysource:
wctx.markcopied(path, copysource) wctx.markcopied(path, copysource)

hgext/rebase.py

rev, rev,
branchmerge=True, branchmerge=True,
force=True, force=True,
ancestor=base, ancestor=base,
mergeancestor=collapse, mergeancestor=collapse,
labels=[b'dest', b'source'], labels=[b'dest', b'source'],
wc=wctx, wc=wctx,
) )
destctx = repo[dest]
if collapse: if collapse:
copies.graftcopies(repo, wctx, ctx, destctx) copies.graftcopies(wctx, ctx, repo[dest])
else: else:
# If we're not using --collapse, we need to # If we're not using --collapse, we need to
# duplicate copies between the revision we're # duplicate copies between the revision we're
# rebasing and its first parent, but *not* # rebasing and its first parent.
# duplicate any copies that have already been copies.graftcopies(wctx, ctx, ctx.p1())
# performed in the destination.
copies.graftcopies(repo, wctx, ctx, ctx.p1(), skip=destctx)
return stats return stats
def adjustdest(repo, rev, destmap, state, skipped): def adjustdest(repo, rev, destmap, state, skipped):
r"""adjust rebase destination given the current rebase state r"""adjust rebase destination given the current rebase state
rev is what is being rebased. Return a list of two revs, which are the rev is what is being rebased. Return a list of two revs, which are the
adjusted destinations for rev's p1 and p2, respectively. If a parent is adjusted destinations for rev's p1 and p2, respectively. If a parent is

mercurial/copies.py

elif f2r > f1r: elif f2r > f1r:
f2 = next(g2) f2 = next(g2)
else: # f1 and f2 point to files in the same linkrev else: # f1 and f2 point to files in the same linkrev
return f1 == f2 # true if they point to the same file return f1 == f2 # true if they point to the same file
except StopIteration: except StopIteration:
return False return False
def graftcopies(repo, wctx, ctx, base, skip=None): def graftcopies(wctx, ctx, base):
"""reproduce copies between base and ctx in the wctx """reproduce copies between base and ctx in the wctx"""
If skip is specified, it's a revision that should be used to
filter copy records. Any copies that occur between base and
skip will not be duplicated, even if they appear in the set of
copies between base and ctx.
"""
exclude = {}
ctraceconfig = repo.ui.config(b'experimental', b'copytrace')
bctrace = stringutil.parsebool(ctraceconfig)
if skip is not None and (
ctraceconfig == b'heuristics' or bctrace or bctrace is None
):
# copytrace='off' skips this line, but not the entire function because
# the line below is O(size of the repo) during a rebase, while the rest
# of the function is much faster (and is required for carrying copy
# metadata across the rebase anyway).
exclude = pathcopies(base, skip)
new_copies = pathcopies(base, ctx) new_copies = pathcopies(base, ctx)
_filter(wctx.p1(), wctx, new_copies) _filter(wctx.p1(), wctx, new_copies)
for dst, src in pycompat.iteritems(new_copies): for dst, src in pycompat.iteritems(new_copies):
if dst in exclude:
continue
wctx[dst].markcopied(src) wctx[dst].markcopied(src)
def computechangesetfilesadded(ctx): def computechangesetfilesadded(ctx):
"""return the list of files added in a changeset """return the list of files added in a changeset
""" """
added = [] added = []
for f in ctx.files(): for f in ctx.files():

mercurial/merge.py

# Never set both parents equal to each other # Never set both parents equal to each other
if pother == pctx.node(): if pother == pctx.node():
pother = nullid pother = nullid
with repo.dirstate.parentchange(): with repo.dirstate.parentchange():
repo.setparents(pctx.node(), pother) repo.setparents(pctx.node(), pother)
repo.dirstate.write(repo.currenttransaction()) repo.dirstate.write(repo.currenttransaction())
# fix up dirstate for copies and renames # fix up dirstate for copies and renames
copies.graftcopies(repo, wctx, ctx, base) copies.graftcopies(wctx, ctx, base)
return stats return stats
def purge( def purge(
repo, repo,
matcher, matcher,
ignored=False, ignored=False,
removeemptydirs=True, removeemptydirs=True,

relnotes/next

* The `revlog.nodemap` object have been merged into the `revlog.index` object. * The `revlog.nodemap` object have been merged into the `revlog.index` object.
* `n in revlog.nodemap` becomes `revlog.index.has_node(n)`, * `n in revlog.nodemap` becomes `revlog.index.has_node(n)`,
* `revlog.nodemap[n]` becomes `revlog.index.rev(n)`, * `revlog.nodemap[n]` becomes `revlog.index.rev(n)`,
* `revlog.nodemap.get(n)` becomes `revlog.index.get_rev(n)`. * `revlog.nodemap.get(n)` becomes `revlog.index.get_rev(n)`.
* `copies.duplicatecopies()` was renamed to * `copies.duplicatecopies()` was renamed to
`copies.graftcopies()`. Its arguments changed from revision numbers `copies.graftcopies()`. Its arguments changed from revision numbers
to context objects. to context objects. It also lost its `repo` and `skip` arguments
(they should no longer be needed).