( )⚙ D10290 refactor: prefer checks against nullrev over nullid

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10290

refactor: prefer checks against nullrev over nullid
ClosedPublic

Authored by joerg.sonnenberger on Mar 29 2021, 8:41 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG728d89f6f9b1: refactor: prefer checks against nullrev over nullid
Summary

A common pattern is using a changeset context and obtaining the node to
compare against nullid. Change this to obtain the nullrev instead. In
the future, the nullid becomes a property of the repository and is no
longer a global constant, so using nullrev is much easier to reason
about. Python function call overhead makes the difference moot, but
future changes will result in more dictionary lookups otherwise, so
prefer the simpler pattern.

Diff Detail

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

Revision Contents
Changeset List

Diff 26628

hgext/extdiff.py

import os import os
import re import re
import shutil import shutil
import stat import stat
import subprocess import subprocess
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import ( from mercurial.node import (
nullid, nullrev,
short, short,
) )
from mercurial import ( from mercurial import (
archival, archival,
cmdutil, cmdutil,
encoding, encoding,
error, error,
filemerge, filemerge,
if change: if change:
ctx2 = scmutil.revsingle(repo, change, None) ctx2 = scmutil.revsingle(repo, change, None)
ctx1a, ctx1b = ctx2.p1(), ctx2.p2() ctx1a, ctx1b = ctx2.p1(), ctx2.p2()
elif from_rev or to_rev: elif from_rev or to_rev:
repo = scmutil.unhidehashlikerevs( repo = scmutil.unhidehashlikerevs(
repo, [from_rev] + [to_rev], b'nowarn' repo, [from_rev] + [to_rev], b'nowarn'
) )
ctx1a = scmutil.revsingle(repo, from_rev, None) ctx1a = scmutil.revsingle(repo, from_rev, None)
ctx1b = repo[nullid] ctx1b = repo[nullrev]
ctx2 = scmutil.revsingle(repo, to_rev, None) ctx2 = scmutil.revsingle(repo, to_rev, None)
else: else:
ctx1a, ctx2 = scmutil.revpair(repo, revs) ctx1a, ctx2 = scmutil.revpair(repo, revs)
if not revs: if not revs:
ctx1b = repo[None].p2() ctx1b = repo[None].p2()
else: else:
ctx1b = repo[nullid] ctx1b = repo[nullrev]
# Disable 3-way merge if there is only one parent # Disable 3-way merge if there is only one parent
if do3way: if do3way:
if ctx1b.node() == nullid: if ctx1b.rev() == nullrev:
do3way = False do3way = False
matcher = scmutil.match(ctx2, pats, opts) matcher = scmutil.match(ctx2, pats, opts)
if opts.get(b'patch'): if opts.get(b'patch'):
if opts.get(b'subrepos'): if opts.get(b'subrepos'):
raise error.Abort(_(b'--patch cannot be used with --subrepos')) raise error.Abort(_(b'--patch cannot be used with --subrepos'))
if opts.get(b'per_file'): if opts.get(b'per_file'):

hgext/split.py

# split.py - split a changeset into smaller ones # split.py - split a changeset into smaller ones
# #
# Copyright 2015 Laurent Charignon <lcharignon@fb.com> # Copyright 2015 Laurent Charignon <lcharignon@fb.com>
# Copyright 2017 Facebook, Inc. # Copyright 2017 Facebook, Inc.
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
"""command to split a changeset into smaller ones (EXPERIMENTAL)""" """command to split a changeset into smaller ones (EXPERIMENTAL)"""
from __future__ import absolute_import from __future__ import absolute_import
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import ( from mercurial.node import (
nullid, nullrev,
short, short,
) )
from mercurial import ( from mercurial import (
bookmarks, bookmarks,
cmdutil, cmdutil,
commands, commands,
error, error,
# If the rebase somehow runs into conflicts, make sure # If the rebase somehow runs into conflicts, make sure
# we close the transaction so the user can continue it. # we close the transaction so the user can continue it.
with util.acceptintervention(tr): with util.acceptintervention(tr):
revs = scmutil.revrange(repo, revlist or [b'.']) revs = scmutil.revrange(repo, revlist or [b'.'])
if len(revs) > 1: if len(revs) > 1:
raise error.InputError(_(b'cannot split multiple revisions')) raise error.InputError(_(b'cannot split multiple revisions'))
rev = revs.first() rev = revs.first()
ctx = repo[rev] # Handle nullrev specially here (instead of leaving for precheck()
# Handle nullid specially here (instead of leaving for precheck()
# below) so we get a nicer message and error code. # below) so we get a nicer message and error code.
if rev is None or ctx.node() == nullid: if rev is None or rev == nullrev:
ui.status(_(b'nothing to split\n')) ui.status(_(b'nothing to split\n'))
return 1 return 1
ctx = repo[rev]
if ctx.node() is None: if ctx.node() is None:
raise error.InputError(_(b'cannot split working directory')) raise error.InputError(_(b'cannot split working directory'))
if opts.get(b'rebase'): if opts.get(b'rebase'):
# Skip obsoleted descendants and their descendants so the rebase # Skip obsoleted descendants and their descendants so the rebase
# won't cause conflicts for sure. # won't cause conflicts for sure.
descendants = list(repo.revs(b'(%d::) - (%d)', rev, rev)) descendants = list(repo.revs(b'(%d::) - (%d)', rev, rev))
torebase = list( torebase = list(

mercurial/context.py

@propertycache @propertycache
def _status(self): def _status(self):
"""Calculate exact status from ``files`` specified at construction""" """Calculate exact status from ``files`` specified at construction"""
man1 = self.p1().manifest() man1 = self.p1().manifest()
p2 = self._parents[1] p2 = self._parents[1]
# "1 < len(self._parents)" can't be used for checking # "1 < len(self._parents)" can't be used for checking
# existence of the 2nd parent, because "memctx._parents" is # existence of the 2nd parent, because "memctx._parents" is
# explicitly initialized by the list, of which length is 2. # explicitly initialized by the list, of which length is 2.
if p2.node() != nullid: if p2.rev() != nullrev:
man2 = p2.manifest() man2 = p2.manifest()
managing = lambda f: f in man1 or f in man2 managing = lambda f: f in man1 or f in man2
else: else:
managing = lambda f: f in man1 managing = lambda f: f in man1
modified, added, removed = [], [], [] modified, added, removed = [], [], []
for f in self._files: for f in self._files:
if not managing(f): if not managing(f):
added.append(f) added.append(f)
elif self[f]: elif self[f]:
modified.append(f) modified.append(f)
else: else:
removed.append(f) removed.append(f)
return scmutil.status(modified, added, removed, [], [], [], []) return scmutil.status(modified, added, removed, [], [], [], [])
def parents(self): def parents(self):
if self._parents[1].node() == nullid: if self._parents[1].rev() == nullrev:
return [self._parents[0]] return [self._parents[0]]
return self._parents return self._parents
class memfilectx(committablefilectx): class memfilectx(committablefilectx):
"""memfilectx represents an in-memory file to commit. """memfilectx represents an in-memory file to commit.
See memctx and committablefilectx for more details. See memctx and committablefilectx for more details.
"""Calculate exact status from ``files`` specified in the ``origctx`` """Calculate exact status from ``files`` specified in the ``origctx``
and parents manifests. and parents manifests.
""" """
man1 = self.p1().manifest() man1 = self.p1().manifest()
p2 = self._parents[1] p2 = self._parents[1]
# "1 < len(self._parents)" can't be used for checking # "1 < len(self._parents)" can't be used for checking
# existence of the 2nd parent, because "metadataonlyctx._parents" is # existence of the 2nd parent, because "metadataonlyctx._parents" is
# explicitly initialized by the list, of which length is 2. # explicitly initialized by the list, of which length is 2.
if p2.node() != nullid: if p2.rev() != nullrev:
man2 = p2.manifest() man2 = p2.manifest()
managing = lambda f: f in man1 or f in man2 managing = lambda f: f in man1 or f in man2
else: else:
managing = lambda f: f in man1 managing = lambda f: f in man1
modified, added, removed = [], [], [] modified, added, removed = [], [], []
for f in self._files: for f in self._files:
if not managing(f): if not managing(f):

mercurial/copies.py

# Computing the forward missing is quite expensive on large manifests, since # Computing the forward missing is quite expensive on large manifests, since
# it compares the entire manifests. We can optimize it in the common use # it compares the entire manifests. We can optimize it in the common use
# case of computing what copies are in a commit versus its parent (like # case of computing what copies are in a commit versus its parent (like
# during a rebase or histedit). Note, we exclude merge commits from this # during a rebase or histedit). Note, we exclude merge commits from this
# optimization, since the ctx.files() for a merge commit is not correct for # optimization, since the ctx.files() for a merge commit is not correct for
# this comparison. # this comparison.
forwardmissingmatch = match forwardmissingmatch = match
if b.p1() == a and b.p2().node() == nullid: if b.p1() == a and b.p2().rev() == nullrev:
filesmatcher = matchmod.exact(b.files()) filesmatcher = matchmod.exact(b.files())
forwardmissingmatch = matchmod.intersectmatchers(match, filesmatcher) forwardmissingmatch = matchmod.intersectmatchers(match, filesmatcher)
if repo.ui.configbool(b'devel', b'copy-tracing.trace-all-files'): if repo.ui.configbool(b'devel', b'copy-tracing.trace-all-files'):
missing = list(b.walk(match)) missing = list(b.walk(match))
# _computeforwardmissing(a, b, match=forwardmissingmatch) # _computeforwardmissing(a, b, match=forwardmissingmatch)
if debug: if debug:
dbg(b'debug.copies: searching all files: %d\n' % len(missing)) dbg(b'debug.copies: searching all files: %d\n' % len(missing))
else: else:

mercurial/logcmdutil.py

# logcmdutil.py - utility for log-like commands # logcmdutil.py - utility for log-like commands
# #
# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import itertools import itertools
import os import os
import posixpath import posixpath
from .i18n import _ from .i18n import _
from .node import ( from .node import (
nullid, nullid,
nullrev,
wdirid, wdirid,
wdirrev, wdirrev,
) )
from .thirdparty import attr from .thirdparty import attr
from . import ( from . import (
dagop, dagop,
def diff_parent(ctx): def diff_parent(ctx):
"""get the context object to use as parent when diffing """get the context object to use as parent when diffing
If diff.merge is enabled, an overlayworkingctx of the auto-merged parents will be returned. If diff.merge is enabled, an overlayworkingctx of the auto-merged parents will be returned.
""" """
repo = ctx.repo() repo = ctx.repo()
if repo.ui.configbool(b"diff", b"merge") and ctx.p2().node() != nullid: if repo.ui.configbool(b"diff", b"merge") and ctx.p2().rev() != nullrev:
# avoid cycle context -> subrepo -> cmdutil -> logcmdutil # avoid cycle context -> subrepo -> cmdutil -> logcmdutil
from . import context from . import context
wctx = context.overlayworkingctx(repo) wctx = context.overlayworkingctx(repo)
wctx.setbase(ctx.p1()) wctx.setbase(ctx.p1())
with repo.ui.configoverride( with repo.ui.configoverride(
{ {
( (

mercurial/mergestate.py

from __future__ import absolute_import from __future__ import absolute_import
import collections import collections
import errno import errno
import shutil import shutil
import struct import struct
from .i18n import _ from .i18n import _
from .node import ( from .node import (
bin, bin,
hex, hex,
nullhex, nullhex,
nullid, nullid,
nullrev,
) )
from . import ( from . import (
error, error,
filemerge, filemerge,
pycompat, pycompat,
util, util,
) )
from .utils import hashutil from .utils import hashutil
fcd = _filectxorabsent(localkey, wctx, dfile) fcd = _filectxorabsent(localkey, wctx, dfile)
fco = _filectxorabsent(onode, octx, ofile) fco = _filectxorabsent(onode, octx, ofile)
# TODO: move this to filectxorabsent # TODO: move this to filectxorabsent
fca = self._repo.filectx(afile, fileid=anode, changectx=actx) fca = self._repo.filectx(afile, fileid=anode, changectx=actx)
# "premerge" x flags # "premerge" x flags
flo = fco.flags() flo = fco.flags()
fla = fca.flags() fla = fca.flags()
if b'x' in flags + flo + fla and b'l' not in flags + flo + fla: if b'x' in flags + flo + fla and b'l' not in flags + flo + fla:
if fca.node() == nullid and flags != flo: if fca.rev() == nullrev and flags != flo:
if preresolve: if preresolve:
self._repo.ui.warn( self._repo.ui.warn(
_( _(
b'warning: cannot merge flags for %s ' b'warning: cannot merge flags for %s '
b'without common ancestor - keeping local flags\n' b'without common ancestor - keeping local flags\n'
) )
% afile % afile
) )

mercurial/shelve.py

def _docreatecmd(ui, repo, pats, opts): def _docreatecmd(ui, repo, pats, opts):
wctx = repo[None] wctx = repo[None]
parents = wctx.parents() parents = wctx.parents()
parent = parents[0] parent = parents[0]
origbranch = wctx.branch() origbranch = wctx.branch()
if parent.node() != nullid: if parent.rev() != nullrev:
desc = b"changes to: %s" % parent.description().split(b'\n', 1)[0] desc = b"changes to: %s" % parent.description().split(b'\n', 1)[0]
else: else:
desc = b'(changes in empty repository)' desc = b'(changes in empty repository)'
if not opts.get(b'message'): if not opts.get(b'message'):
opts[b'message'] = desc opts[b'message'] = desc
lock = tr = activebookmark = None lock = tr = activebookmark = None

mercurial/simplemerge.py

# along with this program; if not, see <http://www.gnu.org/licenses/>. # along with this program; if not, see <http://www.gnu.org/licenses/>.
# mbp: "you know that thing where cvs gives you conflict markers?" # mbp: "you know that thing where cvs gives you conflict markers?"
# s: "i hate that." # s: "i hate that."
from __future__ import absolute_import from __future__ import absolute_import
from .i18n import _ from .i18n import _
from .node import nullid from .node import nullrev
from . import ( from . import (
error, error,
mdiff, mdiff,
pycompat, pycompat,
util, util,
) )
from .utils import stringutil from .utils import stringutil
for i, override in enumerate(overrides): for i, override in enumerate(overrides):
result[i] = override result[i] = override
return result return result
def is_not_null(ctx): def is_not_null(ctx):
if not util.safehasattr(ctx, "node"): if not util.safehasattr(ctx, "node"):
return False return False
return ctx.node() != nullid return ctx.rev() != nullrev
def _mergediff(m3, name_a, name_b, name_base): def _mergediff(m3, name_a, name_b, name_base):
lines = [] lines = []
conflicts = False conflicts = False
for group in m3.merge_groups(): for group in m3.merge_groups():
if group[0] == b'conflict': if group[0] == b'conflict':
base_lines, a_lines, b_lines = group[1:] base_lines, a_lines, b_lines = group[1:]