11 import shutil

    18     bin,

    19     hex,

    21     nullhex,

    25 from .pycompat import delattr

    41 from .utils import hashutil

    45 

    46 

    47 def _droponode(data):

    48     # used for compatibility for v1

    49     bits = data.split(b'\0')

    50     bits = bits[:-2] + bits[-1:]

    51     return b'\0'.join(bits)

    52 

    53 

    54 # Merge state record types. See ``mergestate`` docs for more.

    55 RECORD_LOCAL = b'L'

    56 RECORD_OTHER = b'O'

    57 RECORD_MERGED = b'F'

    58 RECORD_CHANGEDELETE_CONFLICT = b'C'

    59 RECORD_MERGE_DRIVER_MERGE = b'D'

    60 RECORD_PATH_CONFLICT = b'P'

    61 RECORD_MERGE_DRIVER_STATE = b'm'

    62 RECORD_FILE_VALUES = b'f'

    63 RECORD_LABELS = b'l'

    64 RECORD_OVERRIDE = b't'

    65 RECORD_UNSUPPORTED_MANDATORY = b'X'

    66 RECORD_UNSUPPORTED_ADVISORY = b'x'

    67 RECORD_RESOLVED_OTHER = b'R'

    68 

    69 MERGE_DRIVER_STATE_UNMARKED = b'u'

    70 MERGE_DRIVER_STATE_MARKED = b'm'

    71 MERGE_DRIVER_STATE_SUCCESS = b's'

    72 

    73 MERGE_RECORD_UNRESOLVED = b'u'

    74 MERGE_RECORD_RESOLVED = b'r'

    75 MERGE_RECORD_UNRESOLVED_PATH = b'pu'

    76 MERGE_RECORD_RESOLVED_PATH = b'pr'

    77 MERGE_RECORD_DRIVER_RESOLVED = b'd'

    78 # represents that the file was automatically merged in favor

    79 # of other version. This info is used on commit.

    80 MERGE_RECORD_MERGED_OTHER = b'o'

    81 

    82 ACTION_FORGET = b'f'

    83 ACTION_REMOVE = b'r'

    84 ACTION_ADD = b'a'

    85 ACTION_GET = b'g'

    86 ACTION_PATH_CONFLICT = b'p'

    87 ACTION_PATH_CONFLICT_RESOLVE = b'pr'

    88 ACTION_ADD_MODIFIED = b'am'

    89 ACTION_CREATED = b'c'

    90 ACTION_DELETED_CHANGED = b'dc'

    91 ACTION_CHANGED_DELETED = b'cd'

    92 ACTION_MERGE = b'm'

    93 ACTION_LOCAL_DIR_RENAME_GET = b'dg'

    94 ACTION_DIR_RENAME_MOVE_LOCAL = b'dm'

    95 ACTION_KEEP = b'k'

    96 ACTION_EXEC = b'e'

    97 ACTION_CREATED_MERGE = b'cm'

    98 # GET the other/remote side and store this info in mergestate

    99 ACTION_GET_OTHER_AND_STORE = b'gs'

   100 

   101 

   102 class mergestate(object):

   103     '''track 3-way merge state of individual files

   104 

   105     The merge state is stored on disk when needed. Two files are used: one with

   106     an old format (version 1), and one with a new format (version 2). Version 2

   107     stores a superset of the data in version 1, including new kinds of records

   108     in the future. For more about the new format, see the documentation for

   109     `_readrecordsv2`.

   110 

   111     Each record can contain arbitrary content, and has an associated type. This

   112     `type` should be a letter. If `type` is uppercase, the record is mandatory:

   113     versions of Mercurial that don't support it should abort. If `type` is

   114     lowercase, the record can be safely ignored.

   115 

   116     Currently known records:

   117 

   118     L: the node of the "local" part of the merge (hexified version)

   119     O: the node of the "other" part of the merge (hexified version)

   120     F: a file to be merged entry

   121     C: a change/delete or delete/change conflict

   122     D: a file that the external merge driver will merge internally

   123        (experimental)

   124     P: a path conflict (file vs directory)

   125     m: the external merge driver defined for this merge plus its run state

   126        (experimental)

   127     f: a (filename, dictionary) tuple of optional values for a given file

   128     X: unsupported mandatory record type (used in tests)

   129     x: unsupported advisory record type (used in tests)

   130     l: the labels for the parts of the merge.

   131 

   132     Merge driver run states (experimental):

   133     u: driver-resolved files unmarked -- needs to be run next time we're about

   134        to resolve or commit

   135     m: driver-resolved files marked -- only needs to be run before commit

   136     s: success/skipped -- does not need to be run any more

   137 

   138     Merge record states (stored in self._state, indexed by filename):

   139     u: unresolved conflict

   140     r: resolved conflict

   141     pu: unresolved path conflict (file conflicts with directory)

   142     pr: resolved path conflict

   143     d: driver-resolved conflict

   144 

   145     The resolve command transitions between 'u' and 'r' for conflicts and

   146     'pu' and 'pr' for path conflicts.

   147     '''

   148 

   149     statepathv1 = b'merge/state'

   150     statepathv2 = b'merge/state2'

   151 

   152     @staticmethod

   153     def clean(repo, node=None, other=None, labels=None):

   154         """Initialize a brand new merge state, removing any existing state on

   155         disk."""

   156         ms = mergestate(repo)

   157         ms.reset(node, other, labels)

   158         return ms

   159 

   160     @staticmethod

   161     def read(repo):

   162         """Initialize the merge state, reading it from disk."""

   163         ms = mergestate(repo)

   164         ms._read()

   165         return ms

   166 

   167     def __init__(self, repo):

   168         """Initialize the merge state.

   169 

   170         Do not use this directly! Instead call read() or clean()."""

   171         self._repo = repo

   172         self._dirty = False

   173         self._labels = None

   174 

   175     def reset(self, node=None, other=None, labels=None):

   176         self._state = {}

   177         self._stateextras = {}

   178         self._local = None

   179         self._other = None

   180         self._labels = labels

   181         for var in ('localctx', 'otherctx'):

   182             if var in vars(self):

   183                 delattr(self, var)

   184         if node:

   185             self._local = node

   186             self._other = other

   187         self._readmergedriver = None

   188         if self.mergedriver:

   189             self._mdstate = MERGE_DRIVER_STATE_SUCCESS

   190         else:

   191             self._mdstate = MERGE_DRIVER_STATE_UNMARKED

   192         shutil.rmtree(self._repo.vfs.join(b'merge'), True)

   193         self._results = {}

   194         self._dirty = False

   195 

   196     def _read(self):

   197         """Analyse each record content to restore a serialized state from disk

   198 

   199         This function process "record" entry produced by the de-serialization

   200         of on disk file.

   201         """

   202         self._state = {}

   203         self._stateextras = {}

   204         self._local = None

   205         self._other = None

   206         for var in ('localctx', 'otherctx'):

   207             if var in vars(self):

   208                 delattr(self, var)

   209         self._readmergedriver = None

   210         self._mdstate = MERGE_DRIVER_STATE_SUCCESS

   211         unsupported = set()

   212         records = self._readrecords()

   213         for rtype, record in records:

   214             if rtype == RECORD_LOCAL:

   215                 self._local = bin(record)

   216             elif rtype == RECORD_OTHER:

   217                 self._other = bin(record)

   218             elif rtype == RECORD_MERGE_DRIVER_STATE:

   219                 bits = record.split(b'\0', 1)

   220                 mdstate = bits[1]

   221                 if len(mdstate) != 1 or mdstate not in (

   222                     MERGE_DRIVER_STATE_UNMARKED,

   223                     MERGE_DRIVER_STATE_MARKED,

   224                     MERGE_DRIVER_STATE_SUCCESS,

   225                 ):

   226                     # the merge driver should be idempotent, so just rerun it

   227                     mdstate = MERGE_DRIVER_STATE_UNMARKED

   228 

   229                 self._readmergedriver = bits[0]

   230                 self._mdstate = mdstate

   231             elif rtype in (

   232                 RECORD_MERGED,

   233                 RECORD_CHANGEDELETE_CONFLICT,

   234                 RECORD_PATH_CONFLICT,

   235                 RECORD_MERGE_DRIVER_MERGE,

   236                 RECORD_RESOLVED_OTHER,

   237             ):

   238                 bits = record.split(b'\0')

   239                 self._state[bits[0]] = bits[1:]

   240             elif rtype == RECORD_FILE_VALUES:

   241                 filename, rawextras = record.split(b'\0', 1)

   242                 extraparts = rawextras.split(b'\0')

   243                 extras = {}

   244                 i = 0

   245                 while i < len(extraparts):

   246                     extras[extraparts[i]] = extraparts[i + 1]

   247                     i += 2

   248 

   249                 self._stateextras[filename] = extras

   250             elif rtype == RECORD_LABELS:

   251                 labels = record.split(b'\0', 2)

   252                 self._labels = [l for l in labels if len(l) > 0]

   253             elif not rtype.islower():

   254                 unsupported.add(rtype)

   255         self._results = {}

   256         self._dirty = False

   257 

   258         if unsupported:

   259             raise error.UnsupportedMergeRecords(unsupported)

   260 

   261     def _readrecords(self):

   262         """Read merge state from disk and return a list of record (TYPE, data)

   263 

   264         We read data from both v1 and v2 files and decide which one to use.

   265 

   266         V1 has been used by version prior to 2.9.1 and contains less data than

   267         v2. We read both versions and check if no data in v2 contradicts

   268         v1. If there is not contradiction we can safely assume that both v1

   269         and v2 were written at the same time and use the extract data in v2. If

   270         there is contradiction we ignore v2 content as we assume an old version

   271         of Mercurial has overwritten the mergestate file and left an old v2

   272         file around.

   273 

   274         returns list of record [(TYPE, data), ...]"""

   275         v1records = self._readrecordsv1()

   276         v2records = self._readrecordsv2()

   277         if self._v1v2match(v1records, v2records):

   278             return v2records

   279         else:

   280             # v1 file is newer than v2 file, use it

   281             # we have to infer the "other" changeset of the merge

   282             # we cannot do better than that with v1 of the format

   283             mctx = self._repo[None].parents()[-1]

   284             v1records.append((RECORD_OTHER, mctx.hex()))

   285             # add place holder "other" file node information

   286             # nobody is using it yet so we do no need to fetch the data

   287             # if mctx was wrong `mctx[bits[-2]]` may fails.

   288             for idx, r in enumerate(v1records):

   289                 if r[0] == RECORD_MERGED:

   290                     bits = r[1].split(b'\0')

   291                     bits.insert(-2, b'')

   292                     v1records[idx] = (r[0], b'\0'.join(bits))

   293             return v1records

   294 

   295     def _v1v2match(self, v1records, v2records):

   296         oldv2 = set()  # old format version of v2 record

   297         for rec in v2records:

   298             if rec[0] == RECORD_LOCAL:

   299                 oldv2.add(rec)

   300             elif rec[0] == RECORD_MERGED:

   301                 # drop the onode data (not contained in v1)

   302                 oldv2.add((RECORD_MERGED, _droponode(rec[1])))

   303         for rec in v1records:

   304             if rec not in oldv2:

   305                 return False

   306         else:

   307             return True

   308 

   309     def _readrecordsv1(self):

   310         """read on disk merge state for version 1 file

   311 

   312         returns list of record [(TYPE, data), ...]

   313 

   314         Note: the "F" data from this file are one entry short

   315               (no "other file node" entry)

   316         """

   317         records = []

   318         try:

   319             f = self._repo.vfs(self.statepathv1)

   320             for i, l in enumerate(f):

   321                 if i == 0:

   322                     records.append((RECORD_LOCAL, l[:-1]))

   323                 else:

   324                     records.append((RECORD_MERGED, l[:-1]))

   325             f.close()

   326         except IOError as err:

   327             if err.errno != errno.ENOENT:

   328                 raise

   329         return records

   330 

   331     def _readrecordsv2(self):

   332         """read on disk merge state for version 2 file

   333 

   334         This format is a list of arbitrary records of the form:

   335 

   336           [type][length][content]

   337 

   338         `type` is a single character, `length` is a 4 byte integer, and

   339         `content` is an arbitrary byte sequence of length `length`.

   340 

   341         Mercurial versions prior to 3.7 have a bug where if there are

   342         unsupported mandatory merge records, attempting to clear out the merge

   343         state with hg update --clean or similar aborts. The 't' record type

   344         works around that by writing out what those versions treat as an

   345         advisory record, but later versions interpret as special: the first

   346         character is the 'real' record type and everything onwards is the data.

   347 

   348         Returns list of records [(TYPE, data), ...]."""

   349         records = []

   350         try:

   351             f = self._repo.vfs(self.statepathv2)

   352             data = f.read()

   353             off = 0

   354             end = len(data)

   355             while off < end:

   356                 rtype = data[off : off + 1]

   357                 off += 1

   358                 length = _unpack(b'>I', data[off : (off + 4)])[0]

   359                 off += 4

   360                 record = data[off : (off + length)]

   361                 off += length

   362                 if rtype == RECORD_OVERRIDE:

   363                     rtype, record = record[0:1], record[1:]

   364                 records.append((rtype, record))

   365             f.close()

   366         except IOError as err:

   367             if err.errno != errno.ENOENT:

   368                 raise

   369         return records

   370 

   371     @util.propertycache

   372     def mergedriver(self):

   373         # protect against the following:

   374         # - A configures a malicious merge driver in their hgrc, then

   375         #   pauses the merge

   376         # - A edits their hgrc to remove references to the merge driver

   377         # - A gives a copy of their entire repo, including .hg, to B

   378         # - B inspects .hgrc and finds it to be clean

   379         # - B then continues the merge and the malicious merge driver

   380         #  gets invoked

   381         configmergedriver = self._repo.ui.config(

   382             b'experimental', b'mergedriver'

   383         )

   384         if (

   385             self._readmergedriver is not None

   386             and self._readmergedriver != configmergedriver

   387         ):

   388             raise error.ConfigError(

   389                 _(b"merge driver changed since merge started"),

   390                 hint=_(b"revert merge driver change or abort merge"),

   391             )

   392 

   393         return configmergedriver

   394 

   395     @util.propertycache

   396     def local(self):

   397         if self._local is None:

   398             msg = b"local accessed but self._local isn't set"

   399             raise error.ProgrammingError(msg)

   400         return self._local

   401 

   402     @util.propertycache

   403     def localctx(self):

   404         return self._repo[self.local]

   405 

   406     @util.propertycache

   407     def other(self):

   408         if self._other is None:

   409             msg = b"other accessed but self._other isn't set"

   410             raise error.ProgrammingError(msg)

   411         return self._other

   412 

   413     @util.propertycache

   414     def otherctx(self):

   415         return self._repo[self.other]

   416 

   417     def active(self):

   418         """Whether mergestate is active.

   419 

   420         Returns True if there appears to be mergestate. This is a rough proxy

   421         for "is a merge in progress."

   422         """

   423         return bool(self._local) or bool(self._state)

   424 

   425     def commit(self):

   426         """Write current state on disk (if necessary)"""

   427         if self._dirty:

   428             records = self._makerecords()

   429             self._writerecords(records)

   430             self._dirty = False

   431 

   432     def _makerecords(self):

   433         records = []

   434         records.append((RECORD_LOCAL, hex(self._local)))

   435         records.append((RECORD_OTHER, hex(self._other)))

   436         if self.mergedriver:

   437             records.append(

   438                 (

   439                     RECORD_MERGE_DRIVER_STATE,

   440                     b'\0'.join([self.mergedriver, self._mdstate]),

   441                 )

   442             )

   443         # Write out state items. In all cases, the value of the state map entry

   444         # is written as the contents of the record. The record type depends on

   445         # the type of state that is stored, and capital-letter records are used

   446         # to prevent older versions of Mercurial that do not support the feature

   447         # from loading them.

   448         for filename, v in pycompat.iteritems(self._state):

   449             if v[0] == MERGE_RECORD_DRIVER_RESOLVED:

   450                 # Driver-resolved merge. These are stored in 'D' records.

   451                 records.append(

   452                     (RECORD_MERGE_DRIVER_MERGE, b'\0'.join([filename] + v))

   453                 )

   454             elif v[0] in (

   455                 MERGE_RECORD_UNRESOLVED_PATH,

   456                 MERGE_RECORD_RESOLVED_PATH,

   457             ):

   458                 # Path conflicts. These are stored in 'P' records.  The current

   459                 # resolution state ('pu' or 'pr') is stored within the record.

   460                 records.append(

   461                     (RECORD_PATH_CONFLICT, b'\0'.join([filename] + v))

   462                 )

   463             elif v[0] == MERGE_RECORD_MERGED_OTHER:

   464                 records.append(

   465                     (RECORD_RESOLVED_OTHER, b'\0'.join([filename] + v))

   466                 )

   467             elif v[1] == nullhex or v[6] == nullhex:

   468                 # Change/Delete or Delete/Change conflicts. These are stored in

   469                 # 'C' records. v[1] is the local file, and is nullhex when the

   470                 # file is deleted locally ('dc'). v[6] is the remote file, and

   471                 # is nullhex when the file is deleted remotely ('cd').

   472                 records.append(

   473                     (RECORD_CHANGEDELETE_CONFLICT, b'\0'.join([filename] + v))

   474                 )

   475             else:

   476                 # Normal files.  These are stored in 'F' records.

   477                 records.append((RECORD_MERGED, b'\0'.join([filename] + v)))

   478         for filename, extras in sorted(pycompat.iteritems(self._stateextras)):

   479             rawextras = b'\0'.join(

   480                 b'%s\0%s' % (k, v) for k, v in pycompat.iteritems(extras)

   481             )

   482             records.append(

   483                 (RECORD_FILE_VALUES, b'%s\0%s' % (filename, rawextras))

   484             )

   485         if self._labels is not None:

   486             labels = b'\0'.join(self._labels)

   487             records.append((RECORD_LABELS, labels))

   488         return records

   489 

   490     def _writerecords(self, records):

   491         """Write current state on disk (both v1 and v2)"""

   492         self._writerecordsv1(records)

   493         self._writerecordsv2(records)

   494 

   495     def _writerecordsv1(self, records):

   496         """Write current state on disk in a version 1 file"""

   497         f = self._repo.vfs(self.statepathv1, b'wb')

   498         irecords = iter(records)

   499         lrecords = next(irecords)

   500         assert lrecords[0] == RECORD_LOCAL

   501         f.write(hex(self._local) + b'\n')

   502         for rtype, data in irecords:

   503             if rtype == RECORD_MERGED:

   504                 f.write(b'%s\n' % _droponode(data))

   505         f.close()

   506 

   507     def _writerecordsv2(self, records):

   508         """Write current state on disk in a version 2 file

   509 

   510         See the docstring for _readrecordsv2 for why we use 't'."""

   511         # these are the records that all version 2 clients can read

   512         allowlist = (RECORD_LOCAL, RECORD_OTHER, RECORD_MERGED)

   513         f = self._repo.vfs(self.statepathv2, b'wb')

   514         for key, data in records:

   515             assert len(key) == 1

   516             if key not in allowlist:

   517                 key, data = RECORD_OVERRIDE, b'%s%s' % (key, data)

   518             format = b'>sI%is' % len(data)

   519             f.write(_pack(format, key, len(data), data))

   520         f.close()

   521 

   522     @staticmethod

   523     def getlocalkey(path):

   524         """hash the path of a local file context for storage in the .hg/merge

   525         directory."""

   526 

   527         return hex(hashutil.sha1(path).digest())

   528 

   529     def add(self, fcl, fco, fca, fd):

   530         """add a new (potentially?) conflicting file the merge state

   531         fcl: file context for local,

   532         fco: file context for remote,

   533         fca: file context for ancestors,

   534         fd:  file path of the resulting merge.

   535 

   536         note: also write the local version to the `.hg/merge` directory.

   537         """

   538         if fcl.isabsent():

   539             localkey = nullhex

   540         else:

   541             localkey = mergestate.getlocalkey(fcl.path())

   542             self._repo.vfs.write(b'merge/' + localkey, fcl.data())

   543         self._state[fd] = [

   544             MERGE_RECORD_UNRESOLVED,

   545             localkey,

   546             fcl.path(),

   547             fca.path(),

   548             hex(fca.filenode()),

   549             fco.path(),

   550             hex(fco.filenode()),

   551             fcl.flags(),

   552         ]

   553         self._stateextras[fd] = {b'ancestorlinknode': hex(fca.node())}

   554         self._dirty = True

   555 

   556     def addpath(self, path, frename, forigin):

   557         """add a new conflicting path to the merge state

   558         path:    the path that conflicts

   559         frename: the filename the conflicting file was renamed to

   560         forigin: origin of the file ('l' or 'r' for local/remote)

   561         """

   562         self._state[path] = [MERGE_RECORD_UNRESOLVED_PATH, frename, forigin]

   563         self._dirty = True

   564 

   565     def addmergedother(self, path):

   566         self._state[path] = [MERGE_RECORD_MERGED_OTHER, nullhex, nullhex]

   567         self._dirty = True

   568 

   569     def __contains__(self, dfile):

   570         return dfile in self._state

   571 

   572     def __getitem__(self, dfile):

   573         return self._state[dfile][0]

   574 

   575     def __iter__(self):

   576         return iter(sorted(self._state))

   577 

   578     def files(self):

   579         return self._state.keys()

   580 

   581     def mark(self, dfile, state):

   582         self._state[dfile][0] = state

   583         self._dirty = True

   584 

   585     def mdstate(self):

   586         return self._mdstate

   587 

   588     def unresolved(self):

   589         """Obtain the paths of unresolved files."""

   590 

   591         for f, entry in pycompat.iteritems(self._state):

   592             if entry[0] in (

   593                 MERGE_RECORD_UNRESOLVED,

   594                 MERGE_RECORD_UNRESOLVED_PATH,

   595             ):

   596                 yield f

   597 

   598     def driverresolved(self):

   599         """Obtain the paths of driver-resolved files."""

   600 

   601         for f, entry in self._state.items():

   602             if entry[0] == MERGE_RECORD_DRIVER_RESOLVED:

   603                 yield f

   604 

   605     def extras(self, filename):

   606         return self._stateextras.setdefault(filename, {})

   607 

   608     def _resolve(self, preresolve, dfile, wctx):

   609         """rerun merge process for file path `dfile`"""

   610         if self[dfile] in (MERGE_RECORD_RESOLVED, MERGE_RECORD_DRIVER_RESOLVED):

   611             return True, 0

   612         if self._state[dfile][0] == MERGE_RECORD_MERGED_OTHER:

   613             return True, 0

   614         stateentry = self._state[dfile]

   615         state, localkey, lfile, afile, anode, ofile, onode, flags = stateentry

   616         octx = self._repo[self._other]

   617         extras = self.extras(dfile)

   618         anccommitnode = extras.get(b'ancestorlinknode')

   619         if anccommitnode:

   620             actx = self._repo[anccommitnode]

   621         else:

   622             actx = None

   623         fcd = self._filectxorabsent(localkey, wctx, dfile)

   624         fco = self._filectxorabsent(onode, octx, ofile)

   625         # TODO: move this to filectxorabsent

   626         fca = self._repo.filectx(afile, fileid=anode, changectx=actx)

   627         # "premerge" x flags

   628         flo = fco.flags()

   629         fla = fca.flags()

   630         if b'x' in flags + flo + fla and b'l' not in flags + flo + fla:

   631             if fca.node() == nullid and flags != flo:

   632                 if preresolve:

   633                     self._repo.ui.warn(

   634                         _(

   635                             b'warning: cannot merge flags for %s '

   636                             b'without common ancestor - keeping local flags\n'

   637                         )

   638                         % afile

   639                     )

   640             elif flags == fla:

   641                 flags = flo

   642         if preresolve:

   643             # restore local

   644             if localkey != nullhex:

   645                 f = self._repo.vfs(b'merge/' + localkey)

   646                 wctx[dfile].write(f.read(), flags)

   647                 f.close()

   648             else:

   649                 wctx[dfile].remove(ignoremissing=True)

   650             complete, r, deleted = filemerge.premerge(

   651                 self._repo,

   652                 wctx,

   653                 self._local,

   654                 lfile,

   655                 fcd,

   656                 fco,

   657                 fca,

   658                 labels=self._labels,

   659             )

   660         else:

   661             complete, r, deleted = filemerge.filemerge(

   662                 self._repo,

   663                 wctx,

   664                 self._local,

   665                 lfile,

   666                 fcd,

   667                 fco,

   668                 fca,

   669                 labels=self._labels,

   670             )

   671         if r is None:

   672             # no real conflict

   673             del self._state[dfile]

   674             self._stateextras.pop(dfile, None)

   675             self._dirty = True

   676         elif not r:

   677             self.mark(dfile, MERGE_RECORD_RESOLVED)

   678 

   679         if complete:

   680             action = None

   681             if deleted:

   682                 if fcd.isabsent():

   683                     # dc: local picked. Need to drop if present, which may

   684                     # happen on re-resolves.

   685                     action = ACTION_FORGET

   686                 else:

   687                     # cd: remote picked (or otherwise deleted)

   688                     action = ACTION_REMOVE

   689             else:

   690                 if fcd.isabsent():  # dc: remote picked

   691                     action = ACTION_GET

   692                 elif fco.isabsent():  # cd: local picked

   693                     if dfile in self.localctx:

   694                         action = ACTION_ADD_MODIFIED

   695                     else:

   696                         action = ACTION_ADD

   697                 # else: regular merges (no action necessary)

   698             self._results[dfile] = r, action

   699 

   700         return complete, r

   701 

   702     def _filectxorabsent(self, hexnode, ctx, f):

   703         if hexnode == nullhex:

   704             return filemerge.absentfilectx(ctx, f)

   705         else:

   706             return ctx[f]

   707 

   708     def preresolve(self, dfile, wctx):

   709         """run premerge process for dfile

   710 

   711         Returns whether the merge is complete, and the exit code."""

   712         return self._resolve(True, dfile, wctx)

   713 

   714     def resolve(self, dfile, wctx):

   715         """run merge process (assuming premerge was run) for dfile

   716 

   717         Returns the exit code of the merge."""

   718         return self._resolve(False, dfile, wctx)[1]

   719 

   720     def counts(self):

   721         """return counts for updated, merged and removed files in this

   722         session"""

   723         updated, merged, removed = 0, 0, 0

   724         for r, action in pycompat.itervalues(self._results):

   725             if r is None:

   726                 updated += 1

   727             elif r == 0:

   728                 if action == ACTION_REMOVE:

   729                     removed += 1

   730                 else:

   731                     merged += 1

   732         return updated, merged, removed

   733 

   734     def unresolvedcount(self):

   735         """get unresolved count for this merge (persistent)"""

   736         return len(list(self.unresolved()))

   737 

   738     def actions(self):

   739         """return lists of actions to perform on the dirstate"""

   740         actions = {

   741             ACTION_REMOVE: [],

   742             ACTION_FORGET: [],

   743             ACTION_ADD: [],

   744             ACTION_ADD_MODIFIED: [],

   745             ACTION_GET: [],

   746         }

   747         for f, (r, action) in pycompat.iteritems(self._results):

   748             if action is not None:

   749                 actions[action].append((f, None, b"merge result"))

   750         return actions

   751 

   752     def recordactions(self):

   753         """record remove/add/get actions in the dirstate"""

   754         branchmerge = self._repo.dirstate.p2() != nullid

   755         recordupdates(self._repo, self.actions(), branchmerge, None)

   756 

   757     def queueremove(self, f):

   758         """queues a file to be removed from the dirstate

   759 

   760         Meant for use by custom merge drivers."""

   761         self._results[f] = 0, ACTION_REMOVE

   762 

   763     def queueadd(self, f):

   764         """queues a file to be added to the dirstate

   765 

   766         Meant for use by custom merge drivers."""

   767         self._results[f] = 0, ACTION_ADD

   768 

   769     def queueget(self, f):

   770         """queues a file to be marked modified in the dirstate

   771 

   772         Meant for use by custom merge drivers."""

   773         self._results[f] = 0, ACTION_GET