packaging: explain why we purge while building wheels
We also make is a bit narrower so that it is less surprising.
from __future__ import annotations
import collections
import shutil
import struct
import weakref
from .i18n import _
from .node import (
bin,
hex,
nullrev,
)
from . import (
error,
filemerge,
util,
)
from .utils import hashutil
_pack = struct.pack
_unpack = struct.unpack
def _droponode(data):
# used for compatibility for v1
bits = data.split(b'\0')
bits = bits[:-2] + bits[-1:]
return b'\0'.join(bits)
def _filectxorabsent(hexnode, ctx, f):
if hexnode == ctx.repo().nodeconstants.nullhex:
return filemerge.absentfilectx(ctx, f)
else:
return ctx[f]
# Merge state record types. See ``mergestate`` docs for more.
####
# merge records which records metadata about a current merge
# exists only once in a mergestate
#####
RECORD_LOCAL = b'L'
RECORD_OTHER = b'O'
# record merge labels
RECORD_LABELS = b'l'
#####
# record extra information about files, with one entry containing info about one
# file. Hence, multiple of them can exists
#####
RECORD_FILE_VALUES = b'f'
#####
# merge records which represents state of individual merges of files/folders
# These are top level records for each entry containing merge related info.
# Each record of these has info about one file. Hence multiple of them can
# exists
#####
RECORD_MERGED = b'F'
RECORD_CHANGEDELETE_CONFLICT = b'C'
# the path was dir on one side of merge and file on another
RECORD_PATH_CONFLICT = b'P'
#####
# possible state which a merge entry can have. These are stored inside top-level
# merge records mentioned just above.
#####
MERGE_RECORD_UNRESOLVED = b'u'
MERGE_RECORD_RESOLVED = b'r'
MERGE_RECORD_UNRESOLVED_PATH = b'pu'
MERGE_RECORD_RESOLVED_PATH = b'pr'
# represents that the file was automatically merged in favor
# of other version. This info is used on commit.
# This is now deprecated and commit related information is now
# stored in RECORD_FILE_VALUES
MERGE_RECORD_MERGED_OTHER = b'o'
#####
# top level record which stores other unknown records. Multiple of these can
# exists
#####
RECORD_OVERRIDE = b't'
#####
# legacy records which are no longer used but kept to prevent breaking BC
#####
# This record was release in 5.4 and usage was removed in 5.5
LEGACY_RECORD_RESOLVED_OTHER = b'R'
# This record was release in 3.7 and usage was removed in 5.6
LEGACY_RECORD_DRIVER_RESOLVED = b'd'
# This record was release in 3.7 and usage was removed in 5.6
LEGACY_MERGE_DRIVER_STATE = b'm'
# This record was release in 3.7 and usage was removed in 5.6
LEGACY_MERGE_DRIVER_MERGE = b'D'
CHANGE_ADDED = b'added'
CHANGE_REMOVED = b'removed'
CHANGE_MODIFIED = b'modified'
class MergeAction:
"""represent an "action" merge need to take for a given file
Attributes:
_short: internal representation used to identify each action
no_op: True if the action does affect the file content or tracking status
narrow_safe:
True if the action can be safely used for a file outside of the narrow
set
changes:
The types of changes that this actions involves. This is a work in
progress and not all actions have one yet. In addition, some requires
user changes and cannot be fully decided. The value currently available
are:
- ADDED: the files is new in both parents
- REMOVED: the files existed in one parent and is getting removed
- MODIFIED: the files existed in at least one parent and is getting changed
"""
ALL_ACTIONS = weakref.WeakSet()
NO_OP_ACTIONS = weakref.WeakSet()
def __init__(self, short, no_op=False, narrow_safe=False, changes=None):
self._short = short
self.ALL_ACTIONS.add(self)
self.no_op = no_op
if self.no_op:
self.NO_OP_ACTIONS.add(self)
self.narrow_safe = narrow_safe
self.changes = changes
def __hash__(self):
return hash(self._short)
def __repr__(self):
return 'MergeAction<%s>' % self._short.decode('ascii')
def __bytes__(self):
return self._short
def __eq__(self, other):
if other is None:
return False
assert isinstance(other, MergeAction)
return self._short == other._short
def __lt__(self, other):
return self._short < other._short
ACTION_FORGET = MergeAction(b'f', narrow_safe=True, changes=CHANGE_REMOVED)
ACTION_REMOVE = MergeAction(b'r', narrow_safe=True, changes=CHANGE_REMOVED)
ACTION_ADD = MergeAction(b'a', narrow_safe=True, changes=CHANGE_ADDED)
ACTION_GET = MergeAction(b'g', narrow_safe=True, changes=CHANGE_MODIFIED)
ACTION_PATH_CONFLICT = MergeAction(b'p')
ACTION_PATH_CONFLICT_RESOLVE = MergeAction(b'pr')
ACTION_ADD_MODIFIED = MergeAction(
b'am', narrow_safe=True, changes=CHANGE_ADDED
) # not 100% about the changes value here
ACTION_CREATED = MergeAction(b'c', narrow_safe=True, changes=CHANGE_ADDED)
ACTION_DELETED_CHANGED = MergeAction(b'dc')
ACTION_CHANGED_DELETED = MergeAction(b'cd')
ACTION_MERGE = MergeAction(b'm')
ACTION_LOCAL_DIR_RENAME_GET = MergeAction(b'dg')
ACTION_DIR_RENAME_MOVE_LOCAL = MergeAction(b'dm')
ACTION_KEEP = MergeAction(b'k', no_op=True)
# the file was absent on local side before merge and we should
# keep it absent (absent means file not present, it can be a result
# of file deletion, rename etc.)
ACTION_KEEP_ABSENT = MergeAction(b'ka', no_op=True)
# the file is absent on the ancestor and remote side of the merge
# hence this file is new and we should keep it
ACTION_KEEP_NEW = MergeAction(b'kn', no_op=True)
ACTION_EXEC = MergeAction(b'e', narrow_safe=True, changes=CHANGE_MODIFIED)
ACTION_CREATED_MERGE = MergeAction(
b'cm', narrow_safe=True, changes=CHANGE_ADDED
)
# Used by concert to detect situation it does not like, not sure what the exact
# criteria is
CONVERT_MERGE_ACTIONS = (
ACTION_MERGE,
ACTION_DIR_RENAME_MOVE_LOCAL,
ACTION_CHANGED_DELETED,
ACTION_DELETED_CHANGED,
)
class _mergestate_base:
"""track 3-way merge state of individual files
The merge state is stored on disk when needed. Two files are used: one with
an old format (version 1), and one with a new format (version 2). Version 2
stores a superset of the data in version 1, including new kinds of records
in the future. For more about the new format, see the documentation for
`_readrecordsv2`.
Each record can contain arbitrary content, and has an associated type. This
`type` should be a letter. If `type` is uppercase, the record is mandatory:
versions of Mercurial that don't support it should abort. If `type` is
lowercase, the record can be safely ignored.
Currently known records:
L: the node of the "local" part of the merge (hexified version)
O: the node of the "other" part of the merge (hexified version)
F: a file to be merged entry
C: a change/delete or delete/change conflict
P: a path conflict (file vs directory)
f: a (filename, dictionary) tuple of optional values for a given file
l: the labels for the parts of the merge.
Merge record states (stored in self._state, indexed by filename):
u: unresolved conflict
r: resolved conflict
pu: unresolved path conflict (file conflicts with directory)
pr: resolved path conflict
o: file was merged in favor of other parent of merge (DEPRECATED)
The resolve command transitions between 'u' and 'r' for conflicts and
'pu' and 'pr' for path conflicts.
"""
def __init__(self, repo):
"""Initialize the merge state.
Do not use this directly! Instead call read() or clean()."""
self._repo = repo
self._state = {}
self._stateextras = collections.defaultdict(dict)
self._local = None
self._other = None
self._labels = None
# contains a mapping of form:
# {filename : (merge_return_value, action_to_be_performed}
# these are results of re-running merge process
# this dict is used to perform actions on dirstate caused by re-running
# the merge
self._results = {}
self._dirty = False
def reset(self):
pass
def start(self, node, other, labels=None):
self._local = node
self._other = other
self._labels = labels
@util.propertycache
def local(self):
if self._local is None:
msg = b"local accessed but self._local isn't set"
raise error.ProgrammingError(msg)
return self._local
@util.propertycache
def localctx(self):
return self._repo[self.local]
@util.propertycache
def other(self):
if self._other is None:
msg = b"other accessed but self._other isn't set"
raise error.ProgrammingError(msg)
return self._other
@util.propertycache
def otherctx(self):
return self._repo[self.other]
def active(self):
"""Whether mergestate is active.
Returns True if there appears to be mergestate. This is a rough proxy
for "is a merge in progress."
"""
return bool(self._local) or bool(self._state)
def commit(self):
"""Write current state on disk (if necessary)"""
@staticmethod
def getlocalkey(path):
"""hash the path of a local file context for storage in the .hg/merge
directory."""
return hex(hashutil.sha1(path).digest())
def _make_backup(self, fctx, localkey):
raise NotImplementedError()
def _restore_backup(self, fctx, localkey, flags):
raise NotImplementedError()
def add(self, fcl, fco, fca, fd):
"""add a new (potentially?) conflicting file the merge state
fcl: file context for local,
fco: file context for remote,
fca: file context for ancestors,
fd: file path of the resulting merge.
note: also write the local version to the `.hg/merge` directory.
"""
if fcl.isabsent():
localkey = self._repo.nodeconstants.nullhex
else:
localkey = mergestate.getlocalkey(fcl.path())
self._make_backup(fcl, localkey)
self._state[fd] = [
MERGE_RECORD_UNRESOLVED,
localkey,
fcl.path(),
fca.path(),
hex(fca.filenode()),
fco.path(),
hex(fco.filenode()),
fcl.flags(),
]
self._stateextras[fd][b'ancestorlinknode'] = hex(fca.node())
self._dirty = True
def addpathconflict(self, path, frename, forigin):
"""add a new conflicting path to the merge state
path: the path that conflicts
frename: the filename the conflicting file was renamed to
forigin: origin of the file ('l' or 'r' for local/remote)
"""
self._state[path] = [MERGE_RECORD_UNRESOLVED_PATH, frename, forigin]
self._dirty = True
def addcommitinfo(self, path, data):
"""stores information which is required at commit
into _stateextras"""
self._stateextras[path].update(data)
self._dirty = True
def __contains__(self, dfile):
return dfile in self._state
def __getitem__(self, dfile):
return self._state[dfile][0]
def __iter__(self):
return iter(sorted(self._state))
def files(self):
return self._state.keys()
def mark(self, dfile, state):
self._state[dfile][0] = state
self._dirty = True
def unresolved(self):
"""Obtain the paths of unresolved files."""
for f, entry in self._state.items():
if entry[0] in (
MERGE_RECORD_UNRESOLVED,
MERGE_RECORD_UNRESOLVED_PATH,
):
yield f
def allextras(self):
"""return all extras information stored with the mergestate"""
return self._stateextras
def extras(self, filename):
"""return extras stored with the mergestate for the given filename"""
return self._stateextras[filename]
def resolve(self, dfile, wctx):
"""run merge process for dfile
Returns the exit code of the merge."""
if self[dfile] in (
MERGE_RECORD_RESOLVED,
LEGACY_RECORD_DRIVER_RESOLVED,
):
return 0
stateentry = self._state[dfile]
state, localkey, lfile, afile, anode, ofile, onode, flags = stateentry
octx = self._repo[self._other]
extras = self.extras(dfile)
anccommitnode = extras.get(b'ancestorlinknode')
if anccommitnode:
actx = self._repo[anccommitnode]
else:
actx = None
fcd = _filectxorabsent(localkey, wctx, dfile)
fco = _filectxorabsent(onode, octx, ofile)
# TODO: move this to filectxorabsent
fca = self._repo.filectx(afile, fileid=anode, changectx=actx)
# "premerge" x flags
flo = fco.flags()
fla = fca.flags()
if b'x' in flags + flo + fla and b'l' not in flags + flo + fla:
if fca.rev() == nullrev and flags != flo:
self._repo.ui.warn(
_(
b'warning: cannot merge flags for %s '
b'without common ancestor - keeping local flags\n'
)
% afile
)
elif flags == fla:
flags = flo
# restore local
if localkey != self._repo.nodeconstants.nullhex:
self._restore_backup(wctx[dfile], localkey, flags)
else:
wctx[dfile].remove(ignoremissing=True)
if not fco.cmp(fcd): # files identical?
# If return value of merge is None, then there are no real conflict
del self._state[dfile]
self._results[dfile] = None, None
self._dirty = True
return None
merge_ret, deleted = filemerge.filemerge(
self._repo,
wctx,
self._local,
lfile,
fcd,
fco,
fca,
labels=self._labels,
)
if not merge_ret:
self.mark(dfile, MERGE_RECORD_RESOLVED)
action = None
if deleted:
if fcd.isabsent():
# dc: local picked. Need to drop if present, which may
# happen on re-resolves.
action = ACTION_FORGET
else:
# cd: remote picked (or otherwise deleted)
action = ACTION_REMOVE
else:
if fcd.isabsent(): # dc: remote picked
action = ACTION_GET
elif fco.isabsent(): # cd: local picked
if dfile in self.localctx:
action = ACTION_ADD_MODIFIED
else:
action = ACTION_ADD
# else: regular merges (no action necessary)
self._results[dfile] = merge_ret, action
return merge_ret
def counts(self):
"""return counts for updated, merged and removed files in this
session"""
updated, merged, removed = 0, 0, 0
for r, action in self._results.values():
if r is None:
updated += 1
elif r == 0:
if action == ACTION_REMOVE:
removed += 1
else:
merged += 1
return updated, merged, removed
def unresolvedcount(self):
"""get unresolved count for this merge (persistent)"""
return len(list(self.unresolved()))
def actions(self):
"""return lists of actions to perform on the dirstate"""
actions = {
ACTION_REMOVE: [],
ACTION_FORGET: [],
ACTION_ADD: [],
ACTION_ADD_MODIFIED: [],
ACTION_GET: [],
}
for f, (r, action) in self._results.items():
if action is not None:
actions[action].append((f, None, b"merge result"))
return actions
class mergestate(_mergestate_base):
statepathv1 = b'merge/state'
statepathv2 = b'merge/state2'
@staticmethod
def clean(repo):
"""Initialize a brand new merge state, removing any existing state on
disk."""
ms = mergestate(repo)
ms.reset()
return ms
@staticmethod
def read(repo):
"""Initialize the merge state, reading it from disk."""
ms = mergestate(repo)
ms._read()
return ms
def _read(self):
"""Analyse each record content to restore a serialized state from disk
This function process "record" entry produced by the de-serialization
of on disk file.
"""
unsupported = set()
records = self._readrecords()
for rtype, record in records:
if rtype == RECORD_LOCAL:
self._local = bin(record)
elif rtype == RECORD_OTHER:
self._other = bin(record)
elif rtype == LEGACY_MERGE_DRIVER_STATE:
pass
elif rtype in (
RECORD_MERGED,
RECORD_CHANGEDELETE_CONFLICT,
RECORD_PATH_CONFLICT,
LEGACY_MERGE_DRIVER_MERGE,
LEGACY_RECORD_RESOLVED_OTHER,
):
bits = record.split(b'\0')
# merge entry type MERGE_RECORD_MERGED_OTHER is deprecated
# and we now store related information in _stateextras, so
# lets write to _stateextras directly
if bits[1] == MERGE_RECORD_MERGED_OTHER:
self._stateextras[bits[0]][b'filenode-source'] = b'other'
else:
self._state[bits[0]] = bits[1:]
elif rtype == RECORD_FILE_VALUES:
filename, rawextras = record.split(b'\0', 1)
extraparts = rawextras.split(b'\0')
extras = {}
i = 0
while i < len(extraparts):
extras[extraparts[i]] = extraparts[i + 1]
i += 2
self._stateextras[filename] = extras
elif rtype == RECORD_LABELS:
labels = record.split(b'\0', 2)
self._labels = [l for l in labels if len(l) > 0]
elif not rtype.islower():
unsupported.add(rtype)
if unsupported:
raise error.UnsupportedMergeRecords(unsupported)
def _readrecords(self):
"""Read merge state from disk and return a list of record (TYPE, data)
We read data from both v1 and v2 files and decide which one to use.
V1 has been used by version prior to 2.9.1 and contains less data than
v2. We read both versions and check if no data in v2 contradicts
v1. If there is not contradiction we can safely assume that both v1
and v2 were written at the same time and use the extract data in v2. If
there is contradiction we ignore v2 content as we assume an old version
of Mercurial has overwritten the mergestate file and left an old v2
file around.
returns list of record [(TYPE, data), ...]"""
v1records = self._readrecordsv1()
v2records = self._readrecordsv2()
if self._v1v2match(v1records, v2records):
return v2records
else:
# v1 file is newer than v2 file, use it
# we have to infer the "other" changeset of the merge
# we cannot do better than that with v1 of the format
mctx = self._repo[None].parents()[-1]
v1records.append((RECORD_OTHER, mctx.hex()))
# add place holder "other" file node information
# nobody is using it yet so we do no need to fetch the data
# if mctx was wrong `mctx[bits[-2]]` may fails.
for idx, r in enumerate(v1records):
if r[0] == RECORD_MERGED:
bits = r[1].split(b'\0')
bits.insert(-2, b'')
v1records[idx] = (r[0], b'\0'.join(bits))
return v1records
def _v1v2match(self, v1records, v2records):
oldv2 = set() # old format version of v2 record
for rec in v2records:
if rec[0] == RECORD_LOCAL:
oldv2.add(rec)
elif rec[0] == RECORD_MERGED:
# drop the onode data (not contained in v1)
oldv2.add((RECORD_MERGED, _droponode(rec[1])))
for rec in v1records:
if rec not in oldv2:
return False
else:
return True
def _readrecordsv1(self):
"""read on disk merge state for version 1 file
returns list of record [(TYPE, data), ...]
Note: the "F" data from this file are one entry short
(no "other file node" entry)
"""
records = []
try:
f = self._repo.vfs(self.statepathv1)
for i, l in enumerate(f):
if i == 0:
records.append((RECORD_LOCAL, l[:-1]))
else:
records.append((RECORD_MERGED, l[:-1]))
f.close()
except FileNotFoundError:
pass
return records
def _readrecordsv2(self):
"""read on disk merge state for version 2 file
This format is a list of arbitrary records of the form:
[type][length][content]
`type` is a single character, `length` is a 4 byte integer, and
`content` is an arbitrary byte sequence of length `length`.
Mercurial versions prior to 3.7 have a bug where if there are
unsupported mandatory merge records, attempting to clear out the merge
state with hg update --clean or similar aborts. The 't' record type
works around that by writing out what those versions treat as an
advisory record, but later versions interpret as special: the first
character is the 'real' record type and everything onwards is the data.
Returns list of records [(TYPE, data), ...]."""
records = []
try:
f = self._repo.vfs(self.statepathv2)
data = f.read()
off = 0
end = len(data)
while off < end:
rtype = data[off : off + 1]
off += 1
length = _unpack(b'>I', data[off : (off + 4)])[0]
off += 4
record = data[off : (off + length)]
off += length
if rtype == RECORD_OVERRIDE:
rtype, record = record[0:1], record[1:]
records.append((rtype, record))
f.close()
except FileNotFoundError:
pass
return records
def commit(self):
if self._dirty:
records = self._makerecords()
self._writerecords(records)
self._dirty = False
def _makerecords(self):
records = []
records.append((RECORD_LOCAL, hex(self._local)))
records.append((RECORD_OTHER, hex(self._other)))
# Write out state items. In all cases, the value of the state map entry
# is written as the contents of the record. The record type depends on
# the type of state that is stored, and capital-letter records are used
# to prevent older versions of Mercurial that do not support the feature
# from loading them.
for filename, v in self._state.items():
if v[0] in (
MERGE_RECORD_UNRESOLVED_PATH,
MERGE_RECORD_RESOLVED_PATH,
):
# Path conflicts. These are stored in 'P' records. The current
# resolution state ('pu' or 'pr') is stored within the record.
records.append(
(RECORD_PATH_CONFLICT, b'\0'.join([filename] + v))
)
elif (
v[1] == self._repo.nodeconstants.nullhex
or v[6] == self._repo.nodeconstants.nullhex
):
# Change/Delete or Delete/Change conflicts. These are stored in
# 'C' records. v[1] is the local file, and is nullhex when the
# file is deleted locally ('dc'). v[6] is the remote file, and
# is nullhex when the file is deleted remotely ('cd').
records.append(
(RECORD_CHANGEDELETE_CONFLICT, b'\0'.join([filename] + v))
)
else:
# Normal files. These are stored in 'F' records.
records.append((RECORD_MERGED, b'\0'.join([filename] + v)))
for filename, extras in sorted(self._stateextras.items()):
rawextras = b'\0'.join(
b'%s\0%s' % (k, v) for k, v in extras.items()
)
records.append(
(RECORD_FILE_VALUES, b'%s\0%s' % (filename, rawextras))
)
if self._labels is not None:
labels = b'\0'.join(self._labels)
records.append((RECORD_LABELS, labels))
return records
def _writerecords(self, records):
"""Write current state on disk (both v1 and v2)"""
self._writerecordsv1(records)
self._writerecordsv2(records)
def _writerecordsv1(self, records):
"""Write current state on disk in a version 1 file"""
f = self._repo.vfs(self.statepathv1, b'wb')
irecords = iter(records)
lrecords = next(irecords)
assert lrecords[0] == RECORD_LOCAL
f.write(hex(self._local) + b'\n')
for rtype, data in irecords:
if rtype == RECORD_MERGED:
f.write(b'%s\n' % _droponode(data))
f.close()
def _writerecordsv2(self, records):
"""Write current state on disk in a version 2 file
See the docstring for _readrecordsv2 for why we use 't'."""
# these are the records that all version 2 clients can read
allowlist = (RECORD_LOCAL, RECORD_OTHER, RECORD_MERGED)
f = self._repo.vfs(self.statepathv2, b'wb')
for key, data in records:
assert len(key) == 1
if key not in allowlist:
key, data = RECORD_OVERRIDE, b'%s%s' % (key, data)
format = b'>sI%is' % len(data)
f.write(_pack(format, key, len(data), data))
f.close()
def _make_backup(self, fctx, localkey):
self._repo.vfs.write(b'merge/' + localkey, fctx.data())
def _restore_backup(self, fctx, localkey, flags):
with self._repo.vfs(b'merge/' + localkey) as f:
fctx.write(f.read(), flags)
def reset(self):
shutil.rmtree(self._repo.vfs.join(b'merge'), True)
class memmergestate(_mergestate_base):
def __init__(self, repo):
super(memmergestate, self).__init__(repo)
self._backups = {}
def _make_backup(self, fctx, localkey):
self._backups[localkey] = fctx.data()
def _restore_backup(self, fctx, localkey, flags):
fctx.write(self._backups[localkey], flags)
def recordupdates(repo, actions, branchmerge, getfiledata):
"""record merge actions to the dirstate"""
dirstate = repo.dirstate
update_file = dirstate.update_file
# remove (must come first)
for f, args, msg in actions.get(ACTION_REMOVE, []):
if branchmerge:
update_file(f, p1_tracked=True, wc_tracked=False)
else:
update_file(f, p1_tracked=False, wc_tracked=False)
# forget (must come first)
for f, args, msg in actions.get(ACTION_FORGET, []):
update_file(f, p1_tracked=False, wc_tracked=False)
# resolve path conflicts
for f, args, msg in actions.get(ACTION_PATH_CONFLICT_RESOLVE, []):
(f0, origf0) = args
update_file(f, p1_tracked=False, wc_tracked=True)
dirstate.copy(origf0, f)
if f0 == origf0:
update_file(f0, p1_tracked=True, wc_tracked=False)
else:
update_file(f0, p1_tracked=False, wc_tracked=False)
# re-add
for f, args, msg in actions.get(ACTION_ADD, []):
update_file(f, p1_tracked=False, wc_tracked=True)
# re-add/mark as modified
for f, args, msg in actions.get(ACTION_ADD_MODIFIED, []):
if branchmerge:
update_file(
f, p1_tracked=True, wc_tracked=True, possibly_dirty=True
)
else:
update_file(f, p1_tracked=False, wc_tracked=True)
# exec change
for f, args, msg in actions.get(ACTION_EXEC, []):
update_file(f, p1_tracked=True, wc_tracked=True, possibly_dirty=True)
# keep
for f, args, msg in actions.get(ACTION_KEEP, []):
pass
# keep deleted
for f, args, msg in actions.get(ACTION_KEEP_ABSENT, []):
pass
# keep new
for f, args, msg in actions.get(ACTION_KEEP_NEW, []):
pass
# get
for f, args, msg in actions.get(ACTION_GET, []):
if branchmerge:
# tracked in p1 can be True also but update_file should not care
old_entry = dirstate.get_entry(f)
p1_tracked = old_entry.any_tracked and not old_entry.added
update_file(
f,
p1_tracked=p1_tracked,
wc_tracked=True,
p2_info=True,
)
else:
parentfiledata = getfiledata[f] if getfiledata else None
update_file(
f,
p1_tracked=True,
wc_tracked=True,
parentfiledata=parentfiledata,
)
# merge
for f, args, msg in actions.get(ACTION_MERGE, []):
f1, f2, fa, move, anc = args
if branchmerge:
# We've done a branch merge, mark this file as merged
# so that we properly record the merger later
p1_tracked = f1 == f
update_file(
f,
p1_tracked=p1_tracked,
wc_tracked=True,
p2_info=True,
)
if f1 != f2: # copy/rename
if move:
update_file(f1, p1_tracked=True, wc_tracked=False)
if f1 != f:
dirstate.copy(f1, f)
else:
dirstate.copy(f2, f)
else:
# We've update-merged a locally modified file, so
# we set the dirstate to emulate a normal checkout
# of that file some time in the past. Thus our
# merge will appear as a normal local file
# modification.
if f2 == f: # file not locally copied/moved
update_file(
f, p1_tracked=True, wc_tracked=True, possibly_dirty=True
)
if move:
update_file(f1, p1_tracked=False, wc_tracked=False)
# directory rename, move local
for f, args, msg in actions.get(ACTION_DIR_RENAME_MOVE_LOCAL, []):
f0, flag = args
if branchmerge:
update_file(f, p1_tracked=False, wc_tracked=True)
update_file(f0, p1_tracked=True, wc_tracked=False)
dirstate.copy(f0, f)
else:
update_file(f, p1_tracked=True, wc_tracked=True)
update_file(f0, p1_tracked=False, wc_tracked=False)
# directory rename, get
for f, args, msg in actions.get(ACTION_LOCAL_DIR_RENAME_GET, []):
f0, flag = args
if branchmerge:
update_file(f, p1_tracked=False, wc_tracked=True)
dirstate.copy(f0, f)
else:
update_file(f, p1_tracked=True, wc_tracked=True)