This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11877

filemerge: stop passing around 3 unused `None` values in `files` argument
ClosedPublic

Authored by martinvonz on Dec 7 2021, 12:02 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGba34141f8dbb: filemerge: stop passing around 3 unused `None` values in `files` argument
Summary

Since 67cfffbfb6a0 (filemerge: eliminate most uses of tempfiles,
2017-08-31), we have used only the last entry in the files tuple
that gets passed around to various functions. That commit said
"Emphasize that they're unused so we can more easily remove them
later.". It's now "later".

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.

Revision Contents
Changeset List

PathPackages
Mmercurial/filemerge.py (61 lines)

Diff 31543

mercurial/filemerge.py

underyling workingfilectx in that case. underyling workingfilectx in that case.
""" """
if filectx.isabsent(): if filectx.isabsent():
return filectx.changectx()[filectx.path()] return filectx.changectx()[filectx.path()]
else: else:
return filectx return filectx
def _premerge(repo, fcd, fco, fca, toolconf, files, labels=None): def _premerge(repo, fcd, fco, fca, toolconf, backup, labels=None):
tool, toolpath, binary, symlink, scriptfn = toolconf tool, toolpath, binary, symlink, scriptfn = toolconf
if symlink or fcd.isabsent() or fco.isabsent(): if symlink or fcd.isabsent() or fco.isabsent():
return 1 return 1
unused, unused, unused, backup = files
ui = repo.ui ui = repo.ui
validkeep = [b'keep', b'keep-merge3', b'keep-mergediff'] validkeep = [b'keep', b'keep-merge3', b'keep-mergediff']
# do we attempt to simplemerge first? # do we attempt to simplemerge first?
try: try:
premerge = _toolbool(ui, tool, b"premerge", not binary) premerge = _toolbool(ui, tool, b"premerge", not binary)
b'conflict for %s\n' b'conflict for %s\n'
) )
% (tool, uipathfn(fcd.path())) % (tool, uipathfn(fcd.path()))
) )
return False return False
return True return True
def _merge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels, mode): def _merge(repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels, mode):
""" """
Uses the internal non-interactive simple merge algorithm for merging Uses the internal non-interactive simple merge algorithm for merging
files. It will fail if there are any conflicts and leave markers in files. It will fail if there are any conflicts and leave markers in
the partially merged file. Markers will have two sections, one for each side the partially merged file. Markers will have two sections, one for each side
of merge, unless mode equals 'union' which suppresses the markers.""" of merge, unless mode equals 'union' which suppresses the markers."""
ui = repo.ui ui = repo.ui
r = simplemerge.simplemerge(ui, fcd, fca, fco, label=labels, mode=mode) r = simplemerge.simplemerge(ui, fcd, fca, fco, label=labels, mode=mode)
return True, r, False return True, r, False
@internaltool( @internaltool(
b'union', b'union',
fullmerge, fullmerge,
_( _(
b"warning: conflicts while merging %s! " b"warning: conflicts while merging %s! "
b"(edit, then use 'hg resolve --mark')\n" b"(edit, then use 'hg resolve --mark')\n"
), ),
precheck=_mergecheck, precheck=_mergecheck,
) )
def _iunion(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None): def _iunion(repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None):
""" """
Uses the internal non-interactive simple merge algorithm for merging Uses the internal non-interactive simple merge algorithm for merging
files. It will use both left and right sides for conflict regions. files. It will use both left and right sides for conflict regions.
No markers are inserted.""" No markers are inserted."""
return _merge( return _merge(
repo, mynode, orig, fcd, fco, fca, toolconf, files, labels, b'union' repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels, b'union'
) )
@internaltool( @internaltool(
b'merge', b'merge',
fullmerge, fullmerge,
_( _(
b"warning: conflicts while merging %s! " b"warning: conflicts while merging %s! "
b"(edit, then use 'hg resolve --mark')\n" b"(edit, then use 'hg resolve --mark')\n"
), ),
precheck=_mergecheck, precheck=_mergecheck,
) )
def _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None): def _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None):
""" """
Uses the internal non-interactive simple merge algorithm for merging Uses the internal non-interactive simple merge algorithm for merging
files. It will fail if there are any conflicts and leave markers in files. It will fail if there are any conflicts and leave markers in
the partially merged file. Markers will have two sections, one for each side the partially merged file. Markers will have two sections, one for each side
of merge.""" of merge."""
return _merge( return _merge(
repo, mynode, orig, fcd, fco, fca, toolconf, files, labels, b'merge' repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels, b'merge'
) )
@internaltool( @internaltool(
b'merge3', b'merge3',
fullmerge, fullmerge,
_( _(
b"warning: conflicts while merging %s! " b"warning: conflicts while merging %s! "
b"(edit, then use 'hg resolve --mark')\n" b"(edit, then use 'hg resolve --mark')\n"
), ),
precheck=_mergecheck, precheck=_mergecheck,
) )
def _imerge3(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None): def _imerge3(repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None):
""" """
Uses the internal non-interactive simple merge algorithm for merging Uses the internal non-interactive simple merge algorithm for merging
files. It will fail if there are any conflicts and leave markers in files. It will fail if there are any conflicts and leave markers in
the partially merged file. Marker will have three sections, one from each the partially merged file. Marker will have three sections, one from each
side of the merge and one for the base content.""" side of the merge and one for the base content."""
if not labels: if not labels:
labels = _defaultconflictlabels labels = _defaultconflictlabels
if len(labels) < 3: if len(labels) < 3:
labels.append(b'base') labels.append(b'base')
return _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels) return _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels)
@internaltool( @internaltool(
b'merge3-lie-about-conflicts', b'merge3-lie-about-conflicts',
fullmerge, fullmerge,
b'', b'',
precheck=_mergecheck, precheck=_mergecheck,
) )
fullmerge, fullmerge,
_( _(
b"warning: conflicts while merging %s! " b"warning: conflicts while merging %s! "
b"(edit, then use 'hg resolve --mark')\n" b"(edit, then use 'hg resolve --mark')\n"
), ),
precheck=_mergecheck, precheck=_mergecheck,
) )
def _imerge_diff( def _imerge_diff(
repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None
): ):
""" """
Uses the internal non-interactive simple merge algorithm for merging Uses the internal non-interactive simple merge algorithm for merging
files. It will fail if there are any conflicts and leave markers in files. It will fail if there are any conflicts and leave markers in
the partially merged file. The marker will have two sections, one with the the partially merged file. The marker will have two sections, one with the
content from one side of the merge, and one with a diff from the base content from one side of the merge, and one with a diff from the base
content to the content on the other side. (experimental)""" content to the content on the other side. (experimental)"""
if not labels: if not labels:
labels = _defaultconflictlabels labels = _defaultconflictlabels
if len(labels) < 3: if len(labels) < 3:
labels.append(b'base') labels.append(b'base')
return _merge( return _merge(
repo, mynode, orig, fcd, fco, fca, toolconf, files, labels, b'mergediff' repo,
mynode,
orig,
fcd,
fco,
fca,
toolconf,
backup,
labels,
b'mergediff',
) )
def _imergeauto( def _imergeauto(
repo, repo,
mynode, mynode,
orig, orig,
fcd, fcd,
fco, fco,
fca, fca,
toolconf, toolconf,
files, backup,
labels=None, labels=None,
localorother=None, localorother=None,
): ):
""" """
Generic driver for _imergelocal and _imergeother Generic driver for _imergelocal and _imergeother
""" """
assert localorother is not None assert localorother is not None
r = simplemerge.simplemerge( r = simplemerge.simplemerge(
b'tagmerge', b'tagmerge',
mergeonly, mergeonly,
_( _(
b"automatic tag merging of %s failed! " b"automatic tag merging of %s failed! "
b"(use 'hg resolve --tool :merge' or another merge " b"(use 'hg resolve --tool :merge' or another merge "
b"tool of your choice)\n" b"tool of your choice)\n"
), ),
) )
def _itagmerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None): def _itagmerge(
repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None
):
""" """
Uses the internal tag merge algorithm (experimental). Uses the internal tag merge algorithm (experimental).
""" """
success, status = tagmerge.merge(repo, fcd, fco, fca) success, status = tagmerge.merge(repo, fcd, fco, fca)
return success, status, False return success, status, False
@internaltool(b'dump', fullmerge, binary=True, symlink=True) @internaltool(b'dump', fullmerge, binary=True, symlink=True)
def _idump(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None): def _idump(repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None):
""" """
Creates three versions of the files to merge, containing the Creates three versions of the files to merge, containing the
contents of local, other and base. These files can then be used to contents of local, other and base. These files can then be used to
perform a merge manually. If the file to be merged is named perform a merge manually. If the file to be merged is named
``a.txt``, these files will accordingly be named ``a.txt.local``, ``a.txt``, these files will accordingly be named ``a.txt.local``,
``a.txt.other`` and ``a.txt.base`` and they will be placed in the ``a.txt.other`` and ``a.txt.base`` and they will be placed in the
same directory as ``a.txt``. same directory as ``a.txt``.
util.writefile(a + b".local", fcd.decodeddata()) util.writefile(a + b".local", fcd.decodeddata())
repo.wwrite(fd + b".other", fco.data(), fco.flags()) repo.wwrite(fd + b".other", fco.data(), fco.flags())
repo.wwrite(fd + b".base", fca.data(), fca.flags()) repo.wwrite(fd + b".base", fca.data(), fca.flags())
return False, 1, False return False, 1, False
@internaltool(b'forcedump', mergeonly, binary=True, symlink=True) @internaltool(b'forcedump', mergeonly, binary=True, symlink=True)
def _forcedump(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None): def _forcedump(
repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None
):
""" """
Creates three versions of the files as same as :dump, but omits premerge. Creates three versions of the files as same as :dump, but omits premerge.
""" """
return _idump( return _idump(
repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=labels repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=labels
) )
def _xmergeimm(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None): def _xmergeimm(
repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None
):
# In-memory merge simply raises an exception on all external merge tools, # In-memory merge simply raises an exception on all external merge tools,
# for now. # for now.
# #
# It would be possible to run most tools with temporary files, but this # It would be possible to run most tools with temporary files, but this
# raises the question of what to do if the user only partially resolves the # raises the question of what to do if the user only partially resolves the
# file -- we can't leave a merge state. (Copy to somewhere in the .hg/ # file -- we can't leave a merge state. (Copy to somewhere in the .hg/
# directory and tell the user how to get it is my best idea, but it's # directory and tell the user how to get it is my best idea, but it's
# clunky.) # clunky.)
# things for us to import cmdutil. # things for us to import cmdutil.
tres = formatter.templateresources(ui, repo) tres = formatter.templateresources(ui, repo)
t = formatter.maketemplater( t = formatter.maketemplater(
ui, tmpl, defaults=templatekw.keywords, resources=tres ui, tmpl, defaults=templatekw.keywords, resources=tres
) )
ui.status(t.renderdefault(props)) ui.status(t.renderdefault(props))
def _xmerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels): def _xmerge(repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels):
tool, toolpath, binary, symlink, scriptfn = toolconf tool, toolpath, binary, symlink, scriptfn = toolconf
uipathfn = scmutil.getuipathfn(repo) uipathfn = scmutil.getuipathfn(repo)
if fcd.isabsent() or fco.isabsent(): if fcd.isabsent() or fco.isabsent():
repo.ui.warn( repo.ui.warn(
_(b'warning: %s cannot merge change/delete conflict for %s\n') _(b'warning: %s cannot merge change/delete conflict for %s\n')
% (tool, uipathfn(fcd.path())) % (tool, uipathfn(fcd.path()))
) )
return False, 1, None return False, 1, None
unused, unused, unused, backup = files
localpath = _workingpath(repo, fcd) localpath = _workingpath(repo, fcd)
args = _toolstr(repo.ui, tool, b"args") args = _toolstr(repo.ui, tool, b"args")
with _maketempfiles( with _maketempfiles(
repo, fco, fca, repo.wvfs.join(backup.path()), b"$output" in args repo, fco, fca, repo.wvfs.join(backup.path()), b"$output" in args
) as temppaths: ) as temppaths:
basepath, otherpath, localoutputpath = temppaths basepath, otherpath, localoutputpath = temppaths
outpath = b"" outpath = b""
if wctx.isinmemory(): if wctx.isinmemory():
raise error.InMemoryMergeConflictsError( raise error.InMemoryMergeConflictsError(
b'in-memory merge does not support merge conflicts' b'in-memory merge does not support merge conflicts'
) )
ui.warn(onfailure % fduipath) ui.warn(onfailure % fduipath)
return True, 1, False return True, 1, False
backup = _makebackup(repo, ui, wctx, fcd) backup = _makebackup(repo, ui, wctx, fcd)
files = (None, None, None, backup)
r = 1 r = 1
try: try:
internalmarkerstyle = ui.config(b'ui', b'mergemarkers') internalmarkerstyle = ui.config(b'ui', b'mergemarkers')
if isexternal: if isexternal:
markerstyle = _toolstr(ui, tool, b'mergemarkers') markerstyle = _toolstr(ui, tool, b'mergemarkers')
else: else:
markerstyle = internalmarkerstyle markerstyle = internalmarkerstyle
# command-templates.mergemarker) # command-templates.mergemarker)
labeltool = tool labeltool = tool
if internalmarkerstyle != b'basic' or markerstyle != b'basic': if internalmarkerstyle != b'basic' or markerstyle != b'basic':
premergelabels = _formatlabels( premergelabels = _formatlabels(
repo, fcd, fco, fca, premergelabels, tool=labeltool repo, fcd, fco, fca, premergelabels, tool=labeltool
) )
r = _premerge( r = _premerge(
repo, fcd, fco, fca, toolconf, files, labels=premergelabels repo, fcd, fco, fca, toolconf, backup, labels=premergelabels
) )
# we're done if premerge was successful (r is 0) # we're done if premerge was successful (r is 0)
if not r: if not r:
return not r, r, False return not r, r, False
needcheck, r, deleted = func( needcheck, r, deleted = func(
repo, repo,
mynode, mynode,
orig, orig,
fcd, fcd,
fco, fco,
fca, fca,
toolconf, toolconf,
files, backup,
labels=formattedlabels, labels=formattedlabels,
) )
if needcheck: if needcheck:
r = _check(repo, r, ui, tool, fcd, files) r = _check(repo, r, ui, tool, fcd, backup)
if r: if r:
if onfailure: if onfailure:
if wctx.isinmemory(): if wctx.isinmemory():
raise error.InMemoryMergeConflictsError( raise error.InMemoryMergeConflictsError(
b'in-memory merge ' b'in-memory merge '
b'does not support ' b'does not support '
b'merge conflicts' b'merge conflicts'
re.search( re.search(
br"^([<>=+|-])\1{6}( .*)$", br"^([<>=+|-])\1{6}( .*)$",
data, data,
re.MULTILINE, re.MULTILINE,
) )
) )
def _check(repo, r, ui, tool, fcd, files): def _check(repo, r, ui, tool, fcd, backup):
fd = fcd.path() fd = fcd.path()
uipathfn = scmutil.getuipathfn(repo) uipathfn = scmutil.getuipathfn(repo)
unused, unused, unused, backup = files
if not r and ( if not r and (
_toolbool(ui, tool, b"checkconflicts") _toolbool(ui, tool, b"checkconflicts")
or b'conflicts' in _toollist(ui, tool, b"check") or b'conflicts' in _toollist(ui, tool, b"check")
): ):
if hasconflictmarkers(fcd.data()): if hasconflictmarkers(fcd.data()):
r = 1 r = 1