( )⚙ D10248 rebase: clarify names of variables and function related to obsolete revisions

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10248

rebase: clarify names of variables and function related to obsolete revisions
ClosedPublic

Authored by martinvonz on Mar 22 2021, 1:36 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG47c251a14525: rebase: clarify names of variables and function related to obsolete revisions

Diff Detail

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

Event Timeline

martinvonz created this revision.Mar 22 2021, 1:36 PM
martinvonz updated this revision to Diff 26561.Mar 24 2021, 2:25 AM
martinvonz added a commit: rHG47c251a14525: rebase: clarify names of variables and function related to obsolete revisions.Mar 25 2021, 5:30 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG47c251a14525: rebase: clarify names of variables and function related to obsolete revisions (authored by martinvonz). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mhgext/rebase.py (60 lines)

Diff 26531

hgext/rebase.py

self.extrafns = [e] self.extrafns = [e]
self.backupf = ui.configbool(b'rewrite', b'backup-bundle') self.backupf = ui.configbool(b'rewrite', b'backup-bundle')
self.keepf = opts.get(b'keep', False) self.keepf = opts.get(b'keep', False)
self.keepbranchesf = opts.get(b'keepbranches', False) self.keepbranchesf = opts.get(b'keepbranches', False)
self.skipemptysuccessorf = rewriteutil.skip_empty_successor( self.skipemptysuccessorf = rewriteutil.skip_empty_successor(
repo.ui, b'rebase' repo.ui, b'rebase'
) )
self.obsoletenotrebased = {} self.obsolete_with_successor_in_destination = {}
self.obsoletewithoutsuccessorindestination = set() self.obsolete_would_cause_divergence = set()
self.inmemory = inmemory self.inmemory = inmemory
self.dryrun = dryrun self.dryrun = dryrun
self.stateobj = statemod.cmdstate(repo, b'rebasestate') self.stateobj = statemod.cmdstate(repo, b'rebasestate')
@property @property
def repo(self): def repo(self):
if self.prepared: if self.prepared:
return self._repo.unfiltered() return self._repo.unfiltered()
% (b' '.join(b'%d' % r for r in sorted(skipped)) or b'') % (b' '.join(b'%d' % r for r in sorted(skipped)) or b'')
) )
return data return data
def _handleskippingobsolete(self): def _handleskippingobsolete(self):
"""Compute structures necessary for skipping obsolete revisions""" """Compute structures necessary for skipping obsolete revisions"""
obsoleterevs = {r for r in self.state if self.repo[r].obsolete()} obsoleterevs = {r for r in self.state if self.repo[r].obsolete()}
self.obsoletenotrebased = {} self.obsolete_with_successor_in_destination = {}
if not self.ui.configbool(b'experimental', b'rebaseskipobsolete'): if not self.ui.configbool(b'experimental', b'rebaseskipobsolete'):
return return
obsoleteset = set(obsoleterevs) obsoleteset = set(obsoleterevs)
( (
self.obsoletenotrebased, self.obsolete_with_successor_in_destination,
self.obsoletewithoutsuccessorindestination, self.obsolete_would_cause_divergence,
) = _computeobsoletenotrebased(self.repo, obsoleteset, self.destmap) ) = _compute_obsolete_sets(self.repo, obsoleteset, self.destmap)
skippedset = set(self.obsoletenotrebased) skippedset = set(self.obsolete_with_successor_in_destination)
skippedset.update(self.obsoletewithoutsuccessorindestination) skippedset.update(self.obsolete_would_cause_divergence)
_checkobsrebase(self.repo, self.ui, obsoleteset, skippedset) _checkobsrebase(self.repo, self.ui, obsoleteset, skippedset)
def _prepareabortorcontinue( def _prepareabortorcontinue(
self, isabort, backup=True, suppwarns=False, dryrun=False, confirm=False self, isabort, backup=True, suppwarns=False, dryrun=False, confirm=False
): ):
self.resume = True self.resume = True
try: try:
self.restorestatus() self.restorestatus()
# Calculate self.obsoletenotrebased # Calculate self.obsolete_* sets
self._handleskippingobsolete() self._handleskippingobsolete()
self.collapsemsg = restorecollapsemsg(self.repo, isabort) self.collapsemsg = restorecollapsemsg(self.repo, isabort)
except error.RepoLookupError: except error.RepoLookupError:
if isabort: if isabort:
clearstatus(self.repo) clearstatus(self.repo)
clearcollapsemsg(self.repo) clearcollapsemsg(self.repo)
self.repo.ui.warn( self.repo.ui.warn(
_( _(
for destrev in sorted(set(destmap.values())): for destrev in sorted(set(destmap.values())):
dest = self.repo[destrev] dest = self.repo[destrev]
if dest.closesbranch() and not self.keepbranchesf: if dest.closesbranch() and not self.keepbranchesf:
self.ui.status(_(b'reopening closed branch head %s\n') % dest) self.ui.status(_(b'reopening closed branch head %s\n') % dest)
self.prepared = True self.prepared = True
# Calculate self.obsoletenotrebased # Calculate self.obsolete_* sets
self._handleskippingobsolete() self._handleskippingobsolete()
def _assignworkingcopy(self): def _assignworkingcopy(self):
if self.inmemory: if self.inmemory:
from mercurial.context import overlayworkingctx from mercurial.context import overlayworkingctx
self.wctx = overlayworkingctx(self.repo) self.wctx = overlayworkingctx(self.repo)
self.repo.ui.debug(b"rebasing in memory\n") self.repo.ui.debug(b"rebasing in memory\n")
allowdivergence = self.ui.configbool( allowdivergence = self.ui.configbool(
b'experimental', b'evolution.allowdivergence' b'experimental', b'evolution.allowdivergence'
) )
for subset in sortsource(self.destmap): for subset in sortsource(self.destmap):
sortedrevs = self.repo.revs(b'sort(%ld, -topo)', subset) sortedrevs = self.repo.revs(b'sort(%ld, -topo)', subset)
if not allowdivergence: if not allowdivergence:
sortedrevs -= self.repo.revs( sortedrevs -= self.repo.revs(
b'descendants(%ld) and not %ld', b'descendants(%ld) and not %ld',
self.obsoletewithoutsuccessorindestination, self.obsolete_would_cause_divergence,
self.obsoletewithoutsuccessorindestination, self.obsolete_would_cause_divergence,
) )
for rev in sortedrevs: for rev in sortedrevs:
self._rebasenode(tr, rev, allowdivergence, progress) self._rebasenode(tr, rev, allowdivergence, progress)
p.complete() p.complete()
ui.note(_(b'rebase merging completed\n')) ui.note(_(b'rebase merging completed\n'))
def _concludenode(self, rev, editor, commitmsg=None): def _concludenode(self, rev, editor, commitmsg=None):
"""Commit the wd changes with parents p1 and p2. """Commit the wd changes with parents p1 and p2.
def _rebasenode(self, tr, rev, allowdivergence, progressfn): def _rebasenode(self, tr, rev, allowdivergence, progressfn):
repo, ui, opts = self.repo, self.ui, self.opts repo, ui, opts = self.repo, self.ui, self.opts
ctx = repo[rev] ctx = repo[rev]
desc = _ctxdesc(ctx) desc = _ctxdesc(ctx)
if self.state[rev] == rev: if self.state[rev] == rev:
ui.status(_(b'already rebased %s\n') % desc) ui.status(_(b'already rebased %s\n') % desc)
elif ( elif (
not allowdivergence not allowdivergence and rev in self.obsolete_would_cause_divergence
and rev in self.obsoletewithoutsuccessorindestination
): ):
msg = ( msg = (
_( _(
b'note: not rebasing %s and its descendants as ' b'note: not rebasing %s and its descendants as '
b'this would cause divergence\n' b'this would cause divergence\n'
) )
% desc % desc
) )
repo.ui.status(msg) repo.ui.status(msg)
self.skipped.add(rev) self.skipped.add(rev)
elif rev in self.obsoletenotrebased: elif rev in self.obsolete_with_successor_in_destination:
succ = self.obsoletenotrebased[rev] succ = self.obsolete_with_successor_in_destination[rev]
if succ is None: if succ is None:
msg = _(b'note: not rebasing %s, it has no successor\n') % desc msg = _(b'note: not rebasing %s, it has no successor\n') % desc
else: else:
succdesc = _ctxdesc(repo[succ]) succdesc = _ctxdesc(repo[succ])
msg = _( msg = _(
b'note: not rebasing %s, already in destination as %s\n' b'note: not rebasing %s, already in destination as %s\n'
) % (desc, succdesc) ) % (desc, succdesc)
repo.ui.status(msg) repo.ui.status(msg)
ui.status(_(b'rebasing %s\n') % desc) ui.status(_(b'rebasing %s\n') % desc)
progressfn(ctx) progressfn(ctx)
p1, p2, base = defineparents( p1, p2, base = defineparents(
repo, repo,
rev, rev,
self.destmap, self.destmap,
self.state, self.state,
self.skipped, self.skipped,
self.obsoletenotrebased, self.obsolete_with_successor_in_destination,
) )
if self.resume and self.wctx.p1().rev() == p1: if self.resume and self.wctx.p1().rev() == p1:
repo.ui.debug(b'resuming interrupted rebase\n') repo.ui.debug(b'resuming interrupted rebase\n')
self.resume = False self.resume = False
else: else:
overrides = {(b'ui', b'forcemerge'): opts.get(b'tool', b'')} overrides = {(b'ui', b'forcemerge'): opts.get(b'tool', b'')}
with ui.configoverride(overrides, b'rebase'): with ui.configoverride(overrides, b'rebase'):
try: try:
fm.startitem() fm.startitem()
if self.collapsef: if self.collapsef:
p1, p2, _base = defineparents( p1, p2, _base = defineparents(
repo, repo,
min(self.state), min(self.state),
self.destmap, self.destmap,
self.state, self.state,
self.skipped, self.skipped,
self.obsoletenotrebased, self.obsolete_with_successor_in_destination,
) )
editopt = opts.get(b'edit') editopt = opts.get(b'edit')
editform = b'rebase.collapse' editform = b'rebase.collapse'
if self.collapsemsg: if self.collapsemsg:
commitmsg = self.collapsemsg commitmsg = self.collapsemsg
else: else:
commitmsg = b'Collapsed revision' commitmsg = b'Collapsed revision'
for rebased in sorted(self.state): for rebased in sorted(self.state):
else: else:
if opts.get('tool'): if opts.get('tool'):
raise error.InputError(_(b'--tool can only be used with --rebase')) raise error.InputError(_(b'--tool can only be used with --rebase'))
ret = orig(ui, repo, *args, **opts) ret = orig(ui, repo, *args, **opts)
return ret return ret
def _computeobsoletenotrebased(repo, rebaseobsrevs, destmap): def _compute_obsolete_sets(repo, rebaseobsrevs, destmap):
"""Return (obsoletenotrebased, obsoletewithoutsuccessorindestination). """Figure out what to do about about obsolete revisions
`obsoletenotrebased` is a mapping mapping obsolete => successor for all `obsolete_with_successor_in_destination` is a mapping mapping obsolete => successor for all
obsolete nodes to be rebased given in `rebaseobsrevs`. obsolete nodes to be rebased given in `rebaseobsrevs`.
`obsoletewithoutsuccessorindestination` is a set with obsolete revisions `obsolete_would_cause_divergence` is a set with obsolete revisions,
without a successor in destination. without a successor in destination, that would cause divergence.
""" """
obsoletenotrebased = {} obsolete_with_successor_in_destination = {}
obsoletewithoutsuccessorindestination = set() obsolete_would_cause_divergence = set()
assert repo.filtername is None assert repo.filtername is None
cl = repo.changelog cl = repo.changelog
get_rev = cl.index.get_rev get_rev = cl.index.get_rev
extinctrevs = set(repo.revs(b'extinct()')) extinctrevs = set(repo.revs(b'extinct()'))
for srcrev in rebaseobsrevs: for srcrev in rebaseobsrevs:
srcnode = cl.node(srcrev) srcnode = cl.node(srcrev)
# XXX: more advanced APIs are required to handle split correctly # XXX: more advanced APIs are required to handle split correctly
successors = set(obsutil.allsuccessors(repo.obsstore, [srcnode])) successors = set(obsutil.allsuccessors(repo.obsstore, [srcnode]))
# obsutil.allsuccessors includes node itself # obsutil.allsuccessors includes node itself
successors.remove(srcnode) successors.remove(srcnode)
succrevs = {get_rev(s) for s in successors} succrevs = {get_rev(s) for s in successors}
succrevs.discard(None) succrevs.discard(None)
if not successors or succrevs.issubset(extinctrevs): if not successors or succrevs.issubset(extinctrevs):
# no successor, or all successors are extinct # no successor, or all successors are extinct
obsoletenotrebased[srcrev] = None obsolete_with_successor_in_destination[srcrev] = None
else: else:
dstrev = destmap[srcrev] dstrev = destmap[srcrev]
for succrev in succrevs: for succrev in succrevs:
if cl.isancestorrev(succrev, dstrev): if cl.isancestorrev(succrev, dstrev):
obsoletenotrebased[srcrev] = succrev obsolete_with_successor_in_destination[srcrev] = succrev
break break
else: else:
# If 'srcrev' has a successor in rebase set but none in # If 'srcrev' has a successor in rebase set but none in
# destination (which would be catched above), we shall skip it # destination (which would be catched above), we shall skip it
# and its descendants to avoid divergence. # and its descendants to avoid divergence.
if srcrev in extinctrevs or any(s in destmap for s in succrevs): if srcrev in extinctrevs or any(s in destmap for s in succrevs):
obsoletewithoutsuccessorindestination.add(srcrev) obsolete_would_cause_divergence.add(srcrev)
return obsoletenotrebased, obsoletewithoutsuccessorindestination return (
obsolete_with_successor_in_destination,
obsolete_would_cause_divergence,
)
def abortrebase(ui, repo): def abortrebase(ui, repo):
with repo.wlock(), repo.lock(): with repo.wlock(), repo.lock():
rbsrt = rebaseruntime(repo, ui) rbsrt = rebaseruntime(repo, ui)
rbsrt._prepareabortorcontinue(isabort=True) rbsrt._prepareabortorcontinue(isabort=True)