This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12156

obsolete: always return frozensets from obsolete.getrevs()
ClosedPublic

Authored by av6 on Feb 9 2022, 10:44 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG27fe84a8dd60: obsolete: always return frozensets from obsolete.getrevs()
Summary

getrevs function already returns an empty frozenset when there is no obsstore,
but let's make sure to return a frozenset in any case. This makes it possible
to use the result of this function as a dict key or provide it to hash()
built-in function without any conversions.

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

av6 created this revision.Feb 9 2022, 10:44 AM
Alphare accepted this revision.Feb 9 2022, 11:08 AM
This revision is now accepted and ready to land.Feb 9 2022, 11:08 AM
av6 added a commit: rHG27fe84a8dd60: obsolete: always return frozensets from obsolete.getrevs().Feb 10 2022, 4:34 AM
Closed by commit rHG27fe84a8dd60: obsolete: always return frozensets from obsolete.getrevs() (authored by av6). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/obsolete.py (11 lines)

Diff 32116

mercurial/obsolete.py

@cachefor(b'obsolete') @cachefor(b'obsolete')
def _computeobsoleteset(repo): def _computeobsoleteset(repo):
"""the set of obsolete revisions""" """the set of obsolete revisions"""
getnode = repo.changelog.node getnode = repo.changelog.node
notpublic = _mutablerevs(repo) notpublic = _mutablerevs(repo)
isobs = repo.obsstore.successors.__contains__ isobs = repo.obsstore.successors.__contains__
obs = {r for r in notpublic if isobs(getnode(r))} return frozenset(r for r in notpublic if isobs(getnode(r)))
return obs
@cachefor(b'orphan') @cachefor(b'orphan')
def _computeorphanset(repo): def _computeorphanset(repo):
"""the set of non obsolete revisions with obsolete parents""" """the set of non obsolete revisions with obsolete parents"""
pfunc = repo.changelog.parentrevs pfunc = repo.changelog.parentrevs
mutable = _mutablerevs(repo) mutable = _mutablerevs(repo)
obsolete = getrevs(repo, b'obsolete') obsolete = getrevs(repo, b'obsolete')
others = mutable - obsolete others = mutable - obsolete
unstable = set() unstable = set()
for r in sorted(others): for r in sorted(others):
# A rev is unstable if one of its parent is obsolete or unstable # A rev is unstable if one of its parent is obsolete or unstable
# this works since we traverse following growing rev order # this works since we traverse following growing rev order
for p in pfunc(r): for p in pfunc(r):
if p in obsolete or p in unstable: if p in obsolete or p in unstable:
unstable.add(r) unstable.add(r)
break break
return unstable return frozenset(unstable)
@cachefor(b'suspended') @cachefor(b'suspended')
def _computesuspendedset(repo): def _computesuspendedset(repo):
"""the set of obsolete parents with non obsolete descendants""" """the set of obsolete parents with non obsolete descendants"""
suspended = repo.changelog.ancestors(getrevs(repo, b'orphan')) suspended = repo.changelog.ancestors(getrevs(repo, b'orphan'))
return {r for r in getrevs(repo, b'obsolete') if r in suspended} return frozenset(r for r in getrevs(repo, b'obsolete') if r in suspended)
@cachefor(b'extinct') @cachefor(b'extinct')
def _computeextinctset(repo): def _computeextinctset(repo):
"""the set of obsolete parents without non obsolete descendants""" """the set of obsolete parents without non obsolete descendants"""
return getrevs(repo, b'obsolete') - getrevs(repo, b'suspended') return getrevs(repo, b'obsolete') - getrevs(repo, b'suspended')
for pnode in obsutil.allpredecessors( for pnode in obsutil.allpredecessors(
obsstore, [node], ignoreflags=bumpedfix obsstore, [node], ignoreflags=bumpedfix
): ):
prev = torev(pnode) # unfiltered! but so is phasecache prev = torev(pnode) # unfiltered! but so is phasecache
if (prev is not None) and (phase(repo, prev) <= public): if (prev is not None) and (phase(repo, prev) <= public):
# we have a public predecessor # we have a public predecessor
bumped.add(rev) bumped.add(rev)
break # Next draft! break # Next draft!
return bumped return frozenset(bumped)
@cachefor(b'contentdivergent') @cachefor(b'contentdivergent')
def _computecontentdivergentset(repo): def _computecontentdivergentset(repo):
"""the set of rev that compete to be the final successors of some revision.""" """the set of rev that compete to be the final successors of some revision."""
divergent = set() divergent = set()
obsstore = repo.obsstore obsstore = repo.obsstore
newermap = {} newermap = {}
seen.add(prec) seen.add(prec)
if prec not in newermap: if prec not in newermap:
obsutil.successorssets(repo, prec, cache=newermap) obsutil.successorssets(repo, prec, cache=newermap)
newer = [n for n in newermap[prec] if n] newer = [n for n in newermap[prec] if n]
if len(newer) > 1: if len(newer) > 1:
divergent.add(rev) divergent.add(rev)
break break
toprocess.update(obsstore.predecessors.get(prec, ())) toprocess.update(obsstore.predecessors.get(prec, ()))
return divergent return frozenset(divergent)
def makefoldid(relation, user): def makefoldid(relation, user):
folddigest = hashutil.sha1(user) folddigest = hashutil.sha1(user)
for p in relation[0] + relation[1]: for p in relation[0] + relation[1]:
folddigest.update(b'%d' % p.rev()) folddigest.update(b'%d' % p.rev())
folddigest.update(p.node()) folddigest.update(p.node())