merge: mark .hgsubstate as possibly dirty before submerge for consistency

Before this patch, failure of updating subrepos may cause inconsistent
".hgsubstate". For example:

  1. dirstate entry for ".hgsubstate" of the parent repo is filled
     with valid size/date (via "hg state" or so)

  2. "hg update" is invoked at the parent repo

  3. ".hgsubstate" of the parent repo is updated on the filesystem as
     a part of "g"(et) action in "merge.applyupdates"

  4. it is assumed that size/date of ".hgsubstate" on the filesystem
     aren't changed from ones at (1)

     this is not so difficult condition, because just changing hash
     ids (every ids are same in length) in ".hgsubstate" doesn't
     change the file size of it

  5. "subrepo.submerge()" is invoked to update subrepos

  6. failure of updating in one of subrepos raises exception
     (e.g. "untracked file differs")

  7. "hg update" is aborted without updating dirstate of the parent repo

     dirstate entry for ".hgsubstate" still holds size/date at (1)

Then, ".hgsubstate" of the parent repo is treated as "CLEAN"
unexpectedly, because updating ".hgsubstate" at (3) doesn't change
size/date of it on the filesystem: see assumption at (4).

This inconsistent ".hgsubstate" status causes unexpected behavior, for
example:

  - "hg revert" forgets to revert ".hgsubstate"

  - "hg update" misunderstands that (not yet updated) subrepos diverge
    (then, it shows the prompt to confirm user's decision)

To avoid inconsistent ".hgsubstate" status above, this patch marks
".hgsubstate" as possibly dirty before "submerge" invocation.
"normallookup"-ed (= dirty) dirstate should be written out, even if
processing is aborted by failure.

This patch marks ".hgsubstate" as possibly dirty before "submerge",
also when it is removed or merged while merging, for safety. This
should prevent Mercurial from misunderstanding inconsistent
".hgsubstate" as clean.

To satisfy conditions at (1) and (4) above, this patch uses "hg status
--config debug.dirstate.delaywrite=2" (to fill valid size/date into
dirstate) and "touch" (to fix date of the file).

mercurial/merge.py

@@ -1,1189 +1,1199 b''
 # merge.py - directory-level update/merge handling for Mercurial
 #
 # Copyright 2006, 2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 import struct
 
 from node import nullid, nullrev, hex, bin
 from i18n import _
 from mercurial import obsolete
 import error as errormod, util, filemerge, copies, subrepo, worker
 import errno, os, shutil
 
 _pack = struct.pack
 _unpack = struct.unpack
 
 def _droponode(data):
     # used for compatibility for v1
     bits = data.split('\0')
     bits = bits[:-2] + bits[-1:]
     return '\0'.join(bits)
 
 class mergestate(object):
     '''track 3-way merge state of individual files
 
     it is stored on disk when needed. Two file are used, one with an old
     format, one with a new format. Both contains similar data, but the new
     format can store new kind of field.
 
     Current new format is a list of arbitrary record of the form:
 
         [type][length][content]
 
     Type is a single character, length is a 4 bytes integer, content is an
     arbitrary suites of bytes of length `length`.
 
     Type should be a letter. Capital letter are mandatory record, Mercurial
     should abort if they are unknown. lower case record can be safely ignored.
 
     Currently known record:
 
     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
     '''
     statepathv1 = 'merge/state'
     statepathv2 = 'merge/state2'
 
     def __init__(self, repo):
         self._repo = repo
         self._dirty = False
         self._read()
 
     def reset(self, node=None, other=None):
         self._state = {}
         self._local = None
         self._other = None
         if node:
             self._local = node
             self._other = other
         shutil.rmtree(self._repo.join('merge'), True)
         self._dirty = False
 
     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.
         """
         self._state = {}
         self._local = None
         self._other = None
         records = self._readrecords()
         for rtype, record in records:
             if rtype == 'L':
                 self._local = bin(record)
             elif rtype == 'O':
                 self._other = bin(record)
             elif rtype == 'F':
                 bits = record.split('\0')
                 self._state[bits[0]] = bits[1:]
             elif not rtype.islower():
                 raise util.Abort(_('unsupported merge state record: %s')
                                    % rtype)
         self._dirty = False
 
     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()
         oldv2 = set() # old format version of v2 record
         for rec in v2records:
             if rec[0] == 'L':
                 oldv2.add(rec)
             elif rec[0] == 'F':
                 # drop the onode data (not contained in v1)
                 oldv2.add(('F', _droponode(rec[1])))
         for rec in v1records:
             if rec not in oldv2:
                 # 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(('O', 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] == 'F':
                         bits = r[1].split('\0')
                         bits.insert(-2, '')
                         v1records[idx] = (r[0], '\0'.join(bits))
                 return v1records
         else:
             return v2records
 
     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(('L', l[:-1]))
                 else:
                     records.append(('F', l[:-1]))
             f.close()
         except IOError, err:
             if err.errno != errno.ENOENT:
                 raise
         return records
 
     def _readrecordsv2(self):
         """read on disk merge state for version 2 file
 
         returns list of record [(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
                 length = _unpack('>I', data[off:(off + 4)])[0]
                 off += 4
                 record = data[off:(off + length)]
                 off += length
                 records.append((rtype, record))
             f.close()
         except IOError, err:
             if err.errno != errno.ENOENT:
                 raise
         return records
 
     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."
         """
         # Check local variables before looking at filesystem for performance
         # reasons.
         return bool(self._local) or bool(self._state) or \
                self._repo.vfs.exists(self.statepathv1) or \
                self._repo.vfs.exists(self.statepathv2)
 
     def commit(self):
         """Write current state on disk (if necessary)"""
         if self._dirty:
             records = []
             records.append(('L', hex(self._local)))
             records.append(('O', hex(self._other)))
             for d, v in self._state.iteritems():
                 records.append(('F', '\0'.join([d] + v)))
             self._writerecords(records)
             self._dirty = False
 
     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, 'w')
         irecords = iter(records)
         lrecords = irecords.next()
         assert lrecords[0] == 'L'
         f.write(hex(self._local) + '\n')
         for rtype, data in irecords:
             if rtype == 'F':
                 f.write('%s\n' % _droponode(data))
         f.close()
 
     def _writerecordsv2(self, records):
         """Write current state on disk in a version 2 file"""
         f = self._repo.vfs(self.statepathv2, 'w')
         for key, data in records:
             assert len(key) == 1
             format = '>sI%is' % len(data)
             f.write(_pack(format, key, len(data), data))
         f.close()
 
     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.
         """
         hash = util.sha1(fcl.path()).hexdigest()
         self._repo.vfs.write('merge/' + hash, fcl.data())
         self._state[fd] = ['u', hash, fcl.path(),
                            fca.path(), hex(fca.filenode()),
                            fco.path(), hex(fco.filenode()),
                            fcl.flags()]
         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] == 'u':
                 yield f
 
     def resolve(self, dfile, wctx, labels=None):
         """rerun merge process for file path `dfile`"""
         if self[dfile] == 'r':
             return 0
         stateentry = self._state[dfile]
         state, hash, lfile, afile, anode, ofile, onode, flags = stateentry
         octx = self._repo[self._other]
         fcd = wctx[dfile]
         fco = octx[ofile]
         fca = self._repo.filectx(afile, fileid=anode)
         # "premerge" x flags
         flo = fco.flags()
         fla = fca.flags()
         if 'x' in flags + flo + fla and 'l' not in flags + flo + fla:
             if fca.node() == nullid:
                 self._repo.ui.warn(_('warning: cannot merge flags for %s\n') %
                                    afile)
             elif flags == fla:
                 flags = flo
         # restore local
         f = self._repo.vfs('merge/' + hash)
         self._repo.wwrite(dfile, f.read(), flags)
         f.close()
         r = filemerge.filemerge(self._repo, self._local, lfile, fcd, fco, fca,
                                 labels=labels)
         if r is None:
             # no real conflict
             del self._state[dfile]
             self._dirty = True
         elif not r:
             self.mark(dfile, 'r')
         return r
 
 def _checkunknownfile(repo, wctx, mctx, f, f2=None):
     if f2 is None:
         f2 = f
     return (os.path.isfile(repo.wjoin(f))
         and repo.wvfs.audit.check(f)
         and repo.dirstate.normalize(f) not in repo.dirstate
         and mctx[f2].cmp(wctx[f]))
 
 def _checkunknownfiles(repo, wctx, mctx, force, actions):
     """
     Considers any actions that care about the presence of conflicting unknown
     files. For some actions, the result is to abort; for others, it is to
     choose a different action.
     """
     aborts = []
     if not force:
         for f, (m, args, msg) in actions.iteritems():
             if m in ('c', 'dc'):
                 if _checkunknownfile(repo, wctx, mctx, f):
                     aborts.append(f)
             elif m == 'dg':
                 if _checkunknownfile(repo, wctx, mctx, f, args[0]):
                     aborts.append(f)
 
     for f in sorted(aborts):
         repo.ui.warn(_("%s: untracked file differs\n") % f)
     if aborts:
         raise util.Abort(_("untracked files in working directory differ "
                            "from files in requested revision"))
 
     for f, (m, args, msg) in actions.iteritems():
         if m == 'c':
             actions[f] = ('g', args, msg)
         elif m == 'cm':
             fl2, anc = args
             different = _checkunknownfile(repo, wctx, mctx, f)
             if different:
                 actions[f] = ('m', (f, f, None, False, anc),
                               "remote differs from untracked local")
             else:
                 actions[f] = ('g', (fl2,), "remote created")
 
 def _forgetremoved(wctx, mctx, branchmerge):
     """
     Forget removed files
 
     If we're jumping between revisions (as opposed to merging), and if
     neither the working directory nor the target rev has the file,
     then we need to remove it from the dirstate, to prevent the
     dirstate from listing the file when it is no longer in the
     manifest.
 
     If we're merging, and the other revision has removed a file
     that is not present in the working directory, we need to mark it
     as removed.
     """
 
     actions = {}
     m = 'f'
     if branchmerge:
         m = 'r'
     for f in wctx.deleted():
         if f not in mctx:
             actions[f] = m, None, "forget deleted"
 
     if not branchmerge:
         for f in wctx.removed():
             if f not in mctx:
                 actions[f] = 'f', None, "forget removed"
 
     return actions
 
 def _checkcollision(repo, wmf, actions):
     # build provisional merged manifest up
     pmmf = set(wmf)
 
     if actions:
         # k, dr, e and rd are no-op
         for m in 'a', 'f', 'g', 'cd', 'dc':
             for f, args, msg in actions[m]:
                 pmmf.add(f)
         for f, args, msg in actions['r']:
             pmmf.discard(f)
         for f, args, msg in actions['dm']:
             f2, flags = args
             pmmf.discard(f2)
             pmmf.add(f)
         for f, args, msg in actions['dg']:
             pmmf.add(f)
         for f, args, msg in actions['m']:
             f1, f2, fa, move, anc = args
             if move:
                 pmmf.discard(f1)
             pmmf.add(f)
 
     # check case-folding collision in provisional merged manifest
     foldmap = {}
     for f in sorted(pmmf):
         fold = util.normcase(f)
         if fold in foldmap:
             raise util.Abort(_("case-folding collision between %s and %s")
                              % (f, foldmap[fold]))
         foldmap[fold] = f
 
 def manifestmerge(repo, wctx, p2, pa, branchmerge, force, partial,
                   acceptremote, followcopies):
     """
     Merge p1 and p2 with ancestor pa and generate merge action list
 
     branchmerge and force are as passed in to update
     partial = function to filter file lists
     acceptremote = accept the incoming changes without prompting
     """
 
     copy, movewithdir, diverge, renamedelete = {}, {}, {}, {}
 
     # manifests fetched in order are going to be faster, so prime the caches
     [x.manifest() for x in
      sorted(wctx.parents() + [p2, pa], key=lambda x: x.rev())]
 
     if followcopies:
         ret = copies.mergecopies(repo, wctx, p2, pa)
         copy, movewithdir, diverge, renamedelete = ret
 
     repo.ui.note(_("resolving manifests\n"))
     repo.ui.debug(" branchmerge: %s, force: %s, partial: %s\n"
                   % (bool(branchmerge), bool(force), bool(partial)))
     repo.ui.debug(" ancestor: %s, local: %s, remote: %s\n" % (pa, wctx, p2))
 
     m1, m2, ma = wctx.manifest(), p2.manifest(), pa.manifest()
     copied = set(copy.values())
     copied.update(movewithdir.values())
 
     if '.hgsubstate' in m1:
         # check whether sub state is modified
         for s in sorted(wctx.substate):
             if wctx.sub(s).dirty():
                 m1['.hgsubstate'] += '+'
                 break
 
     # Compare manifests
     diff = m1.diff(m2)
 
     actions = {}
     for f, ((n1, fl1), (n2, fl2)) in diff.iteritems():
         if partial and not partial(f):
             continue
         if n1 and n2: # file exists on both local and remote side
             if f not in ma:
                 fa = copy.get(f, None)
                 if fa is not None:
                     actions[f] = ('m', (f, f, fa, False, pa.node()),
                                   "both renamed from " + fa)
                 else:
                     actions[f] = ('m', (f, f, None, False, pa.node()),
                                   "both created")
             else:
                 a = ma[f]
                 fla = ma.flags(f)
                 nol = 'l' not in fl1 + fl2 + fla
                 if n2 == a and fl2 == fla:
                     actions[f] = ('k' , (), "remote unchanged")
                 elif n1 == a and fl1 == fla: # local unchanged - use remote
                     if n1 == n2: # optimization: keep local content
                         actions[f] = ('e', (fl2,), "update permissions")
                     else:
                         actions[f] = ('g', (fl2,), "remote is newer")
                 elif nol and n2 == a: # remote only changed 'x'
                     actions[f] = ('e', (fl2,), "update permissions")
                 elif nol and n1 == a: # local only changed 'x'
                     actions[f] = ('g', (fl1,), "remote is newer")
                 else: # both changed something
                     actions[f] = ('m', (f, f, f, False, pa.node()),
                                    "versions differ")
         elif n1: # file exists only on local side
             if f in copied:
                 pass # we'll deal with it on m2 side
             elif f in movewithdir: # directory rename, move local
                 f2 = movewithdir[f]
                 if f2 in m2:
                     actions[f2] = ('m', (f, f2, None, True, pa.node()),
                                    "remote directory rename, both created")
                 else:
                     actions[f2] = ('dm', (f, fl1),
                                    "remote directory rename - move from " + f)
             elif f in copy:
                 f2 = copy[f]
                 actions[f] = ('m', (f, f2, f2, False, pa.node()),
                               "local copied/moved from " + f2)
             elif f in ma: # clean, a different, no remote
                 if n1 != ma[f]:
                     if acceptremote:
                         actions[f] = ('r', None, "remote delete")
                     else:
                         actions[f] = ('cd', None,  "prompt changed/deleted")
                 elif n1[20:] == 'a':
                     # This extra 'a' is added by working copy manifest to mark
                     # the file as locally added. We should forget it instead of
                     # deleting it.
                     actions[f] = ('f', None, "remote deleted")
                 else:
                     actions[f] = ('r', None, "other deleted")
         elif n2: # file exists only on remote side
             if f in copied:
                 pass # we'll deal with it on m1 side
             elif f in movewithdir:
                 f2 = movewithdir[f]
                 if f2 in m1:
                     actions[f2] = ('m', (f2, f, None, False, pa.node()),
                                    "local directory rename, both created")
                 else:
                     actions[f2] = ('dg', (f, fl2),
                                    "local directory rename - get from " + f)
             elif f in copy:
                 f2 = copy[f]
                 if f2 in m2:
                     actions[f] = ('m', (f2, f, f2, False, pa.node()),
                                   "remote copied from " + f2)
                 else:
                     actions[f] = ('m', (f2, f, f2, True, pa.node()),
                                   "remote moved from " + f2)
             elif f not in ma:
                 # local unknown, remote created: the logic is described by the
                 # following table:
                 #
                 # force  branchmerge  different  |  action
                 #   n         *           *      |   create
                 #   y         n           *      |   create
                 #   y         y           n      |   create
                 #   y         y           y      |   merge
                 #
                 # Checking whether the files are different is expensive, so we
                 # don't do that when we can avoid it.
                 if not force:
                     actions[f] = ('c', (fl2,), "remote created")
                 elif not branchmerge:
                     actions[f] = ('c', (fl2,), "remote created")
                 else:
                     actions[f] = ('cm', (fl2, pa.node()),
                                   "remote created, get or merge")
             elif n2 != ma[f]:
                 if acceptremote:
                     actions[f] = ('c', (fl2,), "remote recreating")
                 else:
                     actions[f] = ('dc', (fl2,), "prompt deleted/changed")
 
     return actions, diverge, renamedelete
 
 def _resolvetrivial(repo, wctx, mctx, ancestor, actions):
     """Resolves false conflicts where the nodeid changed but the content
        remained the same."""
 
     for f, (m, args, msg) in actions.items():
         if m == 'cd' and f in ancestor and not wctx[f].cmp(ancestor[f]):
             # local did change but ended up with same content
             actions[f] = 'r', None, "prompt same"
         elif m == 'dc' and f in ancestor and not mctx[f].cmp(ancestor[f]):
             # remote did change but ended up with same content
             del actions[f] # don't get = keep local deleted
 
 def calculateupdates(repo, wctx, mctx, ancestors, branchmerge, force, partial,
                      acceptremote, followcopies):
     "Calculate the actions needed to merge mctx into wctx using ancestors"
 
     if len(ancestors) == 1: # default
         actions, diverge, renamedelete = manifestmerge(
             repo, wctx, mctx, ancestors[0], branchmerge, force, partial,
             acceptremote, followcopies)
         _checkunknownfiles(repo, wctx, mctx, force, actions)
 
     else: # only when merge.preferancestor=* - the default
         repo.ui.note(
             _("note: merging %s and %s using bids from ancestors %s\n") %
             (wctx, mctx, _(' and ').join(str(anc) for anc in ancestors)))
 
         # Call for bids
         fbids = {} # mapping filename to bids (action method to list af actions)
         diverge, renamedelete = None, None
         for ancestor in ancestors:
             repo.ui.note(_('\ncalculating bids for ancestor %s\n') % ancestor)
             actions, diverge1, renamedelete1 = manifestmerge(
                 repo, wctx, mctx, ancestor, branchmerge, force, partial,
                 acceptremote, followcopies)
             _checkunknownfiles(repo, wctx, mctx, force, actions)
             if diverge is None: # and renamedelete is None.
                 # Arbitrarily pick warnings from first iteration
                 diverge = diverge1
                 renamedelete = renamedelete1
             for f, a in sorted(actions.iteritems()):
                 m, args, msg = a
                 repo.ui.debug(' %s: %s -> %s\n' % (f, msg, m))
                 if f in fbids:
                     d = fbids[f]
                     if m in d:
                         d[m].append(a)
                     else:
                         d[m] = [a]
                 else:
                     fbids[f] = {m: [a]}
 
         # Pick the best bid for each file
         repo.ui.note(_('\nauction for merging merge bids\n'))
         actions = {}
         for f, bids in sorted(fbids.items()):
             # bids is a mapping from action method to list af actions
             # Consensus?
             if len(bids) == 1: # all bids are the same kind of method
                 m, l = bids.items()[0]
                 if util.all(a == l[0] for a in l[1:]): # len(bids) is > 1
                     repo.ui.note(" %s: consensus for %s\n" % (f, m))
                     actions[f] = l[0]
                     continue
             # If keep is an option, just do it.
             if 'k' in bids:
                 repo.ui.note(" %s: picking 'keep' action\n" % f)
                 actions[f] = bids['k'][0]
                 continue
             # If there are gets and they all agree [how could they not?], do it.
             if 'g' in bids:
                 ga0 = bids['g'][0]
                 if util.all(a == ga0 for a in bids['g'][1:]):
                     repo.ui.note(" %s: picking 'get' action\n" % f)
                     actions[f] = ga0
                     continue
             # TODO: Consider other simple actions such as mode changes
             # Handle inefficient democrazy.
             repo.ui.note(_(' %s: multiple bids for merge action:\n') % f)
             for m, l in sorted(bids.items()):
                 for _f, args, msg in l:
                     repo.ui.note('  %s -> %s\n' % (msg, m))
             # Pick random action. TODO: Instead, prompt user when resolving
             m, l = bids.items()[0]
             repo.ui.warn(_(' %s: ambiguous merge - picked %s action\n') %
                          (f, m))
             actions[f] = l[0]
             continue
         repo.ui.note(_('end of auction\n\n'))
 
     _resolvetrivial(repo, wctx, mctx, ancestors[0], actions)
 
     if wctx.rev() is None:
         fractions = _forgetremoved(wctx, mctx, branchmerge)
         actions.update(fractions)
 
     return actions, diverge, renamedelete
 
 def batchremove(repo, actions):
     """apply removes to the working directory
 
     yields tuples for progress updates
     """
     verbose = repo.ui.verbose
     unlink = util.unlinkpath
     wjoin = repo.wjoin
     audit = repo.wvfs.audit
     i = 0
     for f, args, msg in actions:
         repo.ui.debug(" %s: %s -> r\n" % (f, msg))
         if verbose:
             repo.ui.note(_("removing %s\n") % f)
         audit(f)
         try:
             unlink(wjoin(f), ignoremissing=True)
         except OSError, inst:
             repo.ui.warn(_("update failed to remove %s: %s!\n") %
                          (f, inst.strerror))
         if i == 100:
             yield i, f
             i = 0
         i += 1
     if i > 0:
         yield i, f
 
 def batchget(repo, mctx, actions):
     """apply gets to the working directory
 
     mctx is the context to get from
 
     yields tuples for progress updates
     """
     verbose = repo.ui.verbose
     fctx = mctx.filectx
     wwrite = repo.wwrite
     i = 0
     for f, args, msg in actions:
         repo.ui.debug(" %s: %s -> g\n" % (f, msg))
         if verbose:
             repo.ui.note(_("getting %s\n") % f)
         wwrite(f, fctx(f).data(), args[0])
         if i == 100:
             yield i, f
             i = 0
         i += 1
     if i > 0:
         yield i, f
 
 def applyupdates(repo, actions, wctx, mctx, overwrite, labels=None):
     """apply the merge action list to the working directory
 
     wctx is the working copy context
     mctx is the context to be merged into the working copy
 
     Return a tuple of counts (updated, merged, removed, unresolved) that
     describes how many files were affected by the update.
     """
 
     updated, merged, removed, unresolved = 0, 0, 0, 0
     ms = mergestate(repo)
     ms.reset(wctx.p1().node(), mctx.node())
     moves = []
     for m, l in actions.items():
         l.sort()
 
     # prescan for merges
     for f, args, msg in actions['m']:
         f1, f2, fa, move, anc = args
         if f == '.hgsubstate': # merged internally
             continue
         repo.ui.debug(" preserving %s for resolve of %s\n" % (f1, f))
         fcl = wctx[f1]
         fco = mctx[f2]
         actx = repo[anc]
         if fa in actx:
             fca = actx[fa]
         else:
             fca = repo.filectx(f1, fileid=nullrev)
         ms.add(fcl, fco, fca, f)
         if f1 != f and move:
             moves.append(f1)
 
     audit = repo.wvfs.audit
     _updating = _('updating')
     _files = _('files')
     progress = repo.ui.progress
 
     # remove renamed files after safely stored
     for f in moves:
         if os.path.lexists(repo.wjoin(f)):
             repo.ui.debug("removing %s\n" % f)
             audit(f)
             util.unlinkpath(repo.wjoin(f))
 
     numupdates = sum(len(l) for m, l in actions.items() if m != 'k')
 
+    def dirtysubstate():
+        # mark '.hgsubstate' as possibly dirty forcibly, because
+        # modified '.hgsubstate' is misunderstood as clean,
+        # when both st_size/st_mtime of '.hgsubstate' aren't changed,
+        # even if "submerge" fails and '.hgsubstate' is inconsistent
+        repo.dirstate.normallookup('.hgsubstate')
+
     if [a for a in actions['r'] if a[0] == '.hgsubstate']:
+        dirtysubstate()
         subrepo.submerge(repo, wctx, mctx, wctx, overwrite)
 
     # remove in parallel (must come first)
     z = 0
     prog = worker.worker(repo.ui, 0.001, batchremove, (repo,), actions['r'])
     for i, item in prog:
         z += i
         progress(_updating, z, item=item, total=numupdates, unit=_files)
     removed = len(actions['r'])
 
     # get in parallel
     prog = worker.worker(repo.ui, 0.001, batchget, (repo, mctx), actions['g'])
     for i, item in prog:
         z += i
         progress(_updating, z, item=item, total=numupdates, unit=_files)
     updated = len(actions['g'])
 
     if [a for a in actions['g'] if a[0] == '.hgsubstate']:
+        dirtysubstate()
         subrepo.submerge(repo, wctx, mctx, wctx, overwrite)
 
     # forget (manifest only, just log it) (must come first)
     for f, args, msg in actions['f']:
         repo.ui.debug(" %s: %s -> f\n" % (f, msg))
         z += 1
         progress(_updating, z, item=f, total=numupdates, unit=_files)
 
     # re-add (manifest only, just log it)
     for f, args, msg in actions['a']:
         repo.ui.debug(" %s: %s -> a\n" % (f, msg))
         z += 1
         progress(_updating, z, item=f, total=numupdates, unit=_files)
 
     # keep (noop, just log it)
     for f, args, msg in actions['k']:
         repo.ui.debug(" %s: %s -> k\n" % (f, msg))
         # no progress
 
     # merge
     for f, args, msg in actions['m']:
         repo.ui.debug(" %s: %s -> m\n" % (f, msg))
         z += 1
         progress(_updating, z, item=f, total=numupdates, unit=_files)
         if f == '.hgsubstate': # subrepo states need updating
+            dirtysubstate()
             subrepo.submerge(repo, wctx, mctx, wctx.ancestor(mctx),
                              overwrite)
             continue
         audit(f)
         r = ms.resolve(f, wctx, labels=labels)
         if r is not None and r > 0:
             unresolved += 1
         else:
             if r is None:
                 updated += 1
             else:
                 merged += 1
 
     # directory rename, move local
     for f, args, msg in actions['dm']:
         repo.ui.debug(" %s: %s -> dm\n" % (f, msg))
         z += 1
         progress(_updating, z, item=f, total=numupdates, unit=_files)
         f0, flags = args
         repo.ui.note(_("moving %s to %s\n") % (f0, f))
         audit(f)
         repo.wwrite(f, wctx.filectx(f0).data(), flags)
         util.unlinkpath(repo.wjoin(f0))
         updated += 1
 
     # local directory rename, get
     for f, args, msg in actions['dg']:
         repo.ui.debug(" %s: %s -> dg\n" % (f, msg))
         z += 1
         progress(_updating, z, item=f, total=numupdates, unit=_files)
         f0, flags = args
         repo.ui.note(_("getting %s to %s\n") % (f0, f))
         repo.wwrite(f, mctx.filectx(f0).data(), flags)
         updated += 1
 
     # exec
     for f, args, msg in actions['e']:
         repo.ui.debug(" %s: %s -> e\n" % (f, msg))
         z += 1
         progress(_updating, z, item=f, total=numupdates, unit=_files)
         flags, = args
         audit(f)
         util.setflags(repo.wjoin(f), 'l' in flags, 'x' in flags)
         updated += 1
 
     ms.commit()
     progress(_updating, None, total=numupdates, unit=_files)
 
     return updated, merged, removed, unresolved
 
 def recordupdates(repo, actions, branchmerge):
     "record merge actions to the dirstate"
     # remove (must come first)
     for f, args, msg in actions['r']:
         if branchmerge:
             repo.dirstate.remove(f)
         else:
             repo.dirstate.drop(f)
 
     # forget (must come first)
     for f, args, msg in actions['f']:
         repo.dirstate.drop(f)
 
     # re-add
     for f, args, msg in actions['a']:
         if not branchmerge:
             repo.dirstate.add(f)
 
     # exec change
     for f, args, msg in actions['e']:
         repo.dirstate.normallookup(f)
 
     # keep
     for f, args, msg in actions['k']:
         pass
 
     # get
     for f, args, msg in actions['g']:
         if branchmerge:
             repo.dirstate.otherparent(f)
         else:
             repo.dirstate.normal(f)
 
     # merge
     for f, args, msg in actions['m']:
         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
             repo.dirstate.merge(f)
             if f1 != f2: # copy/rename
                 if move:
                     repo.dirstate.remove(f1)
                 if f1 != f:
                     repo.dirstate.copy(f1, f)
                 else:
                     repo.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
                 repo.dirstate.normallookup(f)
             if move:
                 repo.dirstate.drop(f1)
 
     # directory rename, move local
     for f, args, msg in actions['dm']:
         f0, flag = args
         if branchmerge:
             repo.dirstate.add(f)
             repo.dirstate.remove(f0)
             repo.dirstate.copy(f0, f)
         else:
             repo.dirstate.normal(f)
             repo.dirstate.drop(f0)
 
     # directory rename, get
     for f, args, msg in actions['dg']:
         f0, flag = args
         if branchmerge:
             repo.dirstate.add(f)
             repo.dirstate.copy(f0, f)
         else:
             repo.dirstate.normal(f)
 
 def update(repo, node, branchmerge, force, partial, ancestor=None,
            mergeancestor=False, labels=None):
     """
     Perform a merge between the working directory and the given node
 
     node = the node to update to, or None if unspecified
     branchmerge = whether to merge between branches
     force = whether to force branch merging or file overwriting
     partial = a function to filter file lists (dirstate not updated)
     mergeancestor = whether it is merging with an ancestor. If true,
       we should accept the incoming changes for any prompts that occur.
       If false, merging with an ancestor (fast-forward) is only allowed
       between different named branches. This flag is used by rebase extension
       as a temporary fix and should be avoided in general.
 
     The table below shows all the behaviors of the update command
     given the -c and -C or no options, whether the working directory
     is dirty, whether a revision is specified, and the relationship of
     the parent rev to the target rev (linear, on the same named
     branch, or on another named branch).
 
     This logic is tested by test-update-branches.t.
 
     -c  -C  dirty  rev  |  linear   same  cross
      n   n    n     n   |    ok     (1)     x
      n   n    n     y   |    ok     ok     ok
      n   n    y     n   |   merge   (2)    (2)
      n   n    y     y   |   merge   (3)    (3)
      n   y    *     *   |    ---  discard  ---
      y   n    y     *   |    ---    (4)    ---
      y   n    n     *   |    ---    ok     ---
      y   y    *     *   |    ---    (5)    ---
 
     x = can't happen
     * = don't-care
     1 = abort: not a linear update (merge or update --check to force update)
     2 = abort: uncommitted changes (commit and merge, or update --clean to
                  discard changes)
     3 = abort: uncommitted changes (commit or update --clean to discard changes)
     4 = abort: uncommitted changes (checked in commands.py)
     5 = incompatible options (checked in commands.py)
 
     Return the same tuple as applyupdates().
     """
 
     onode = node
     wlock = repo.wlock()
     try:
         wc = repo[None]
         pl = wc.parents()
         p1 = pl[0]
         pas = [None]
         if ancestor is not None:
             pas = [repo[ancestor]]
 
         if node is None:
             # Here is where we should consider bookmarks, divergent bookmarks,
             # foreground changesets (successors), and tip of current branch;
             # but currently we are only checking the branch tips.
             try:
                 node = repo.branchtip(wc.branch())
             except errormod.RepoLookupError:
                 if wc.branch() == 'default': # no default branch!
                     node = repo.lookup('tip') # update to tip
                 else:
                     raise util.Abort(_("branch %s not found") % wc.branch())
 
             if p1.obsolete() and not p1.children():
                 # allow updating to successors
                 successors = obsolete.successorssets(repo, p1.node())
 
                 # behavior of certain cases is as follows,
                 #
                 # divergent changesets: update to highest rev, similar to what
                 #     is currently done when there are more than one head
                 #     (i.e. 'tip')
                 #
                 # replaced changesets: same as divergent except we know there
                 # is no conflict
                 #
                 # pruned changeset: no update is done; though, we could
                 #     consider updating to the first non-obsolete parent,
                 #     similar to what is current done for 'hg prune'
 
                 if successors:
                     # flatten the list here handles both divergent (len > 1)
                     # and the usual case (len = 1)
                     successors = [n for sub in successors for n in sub]
 
                     # get the max revision for the given successors set,
                     # i.e. the 'tip' of a set
                     node = repo.revs('max(%ln)', successors).first()
                     pas = [p1]
 
         overwrite = force and not branchmerge
 
         p2 = repo[node]
         if pas[0] is None:
             if repo.ui.config('merge', 'preferancestor', '*') == '*':
                 cahs = repo.changelog.commonancestorsheads(p1.node(), p2.node())
                 pas = [repo[anc] for anc in (sorted(cahs) or [nullid])]
             else:
                 pas = [p1.ancestor(p2, warn=branchmerge)]
 
         fp1, fp2, xp1, xp2 = p1.node(), p2.node(), str(p1), str(p2)
 
         ### check phase
         if not overwrite and len(pl) > 1:
             raise util.Abort(_("outstanding uncommitted merge"))
         if branchmerge:
             if pas == [p2]:
                 raise util.Abort(_("merging with a working directory ancestor"
                                    " has no effect"))
             elif pas == [p1]:
                 if not mergeancestor and p1.branch() == p2.branch():
                     raise util.Abort(_("nothing to merge"),
                                      hint=_("use 'hg update' "
                                             "or check 'hg heads'"))
             if not force and (wc.files() or wc.deleted()):
                 raise util.Abort(_("uncommitted changes"),
                                  hint=_("use 'hg status' to list changes"))
             for s in sorted(wc.substate):
                 if wc.sub(s).dirty():
                     raise util.Abort(_("uncommitted changes in "
                                        "subrepository '%s'") % s)
 
         elif not overwrite:
             if p1 == p2: # no-op update
                 # call the hooks and exit early
                 repo.hook('preupdate', throw=True, parent1=xp2, parent2='')
                 repo.hook('update', parent1=xp2, parent2='', error=0)
                 return 0, 0, 0, 0
 
             if pas not in ([p1], [p2]):  # nonlinear
                 dirty = wc.dirty(missing=True)
                 if dirty or onode is None:
                     # Branching is a bit strange to ensure we do the minimal
                     # amount of call to obsolete.background.
                     foreground = obsolete.foreground(repo, [p1.node()])
                     # note: the <node> variable contains a random identifier
                     if repo[node].node() in foreground:
                         pas = [p1]  # allow updating to successors
                     elif dirty:
                         msg = _("uncommitted changes")
                         if onode is None:
                             hint = _("commit and merge, or update --clean to"
                                      " discard changes")
                         else:
                             hint = _("commit or update --clean to discard"
                                      " changes")
                         raise util.Abort(msg, hint=hint)
                     else:  # node is none
                         msg = _("not a linear update")
                         hint = _("merge or update --check to force update")
                         raise util.Abort(msg, hint=hint)
                 else:
                     # Allow jumping branches if clean and specific rev given
                     pas = [p1]
 
         followcopies = False
         if overwrite:
             pas = [wc]
         elif pas == [p2]: # backwards
             pas = [wc.p1()]
         elif not branchmerge and not wc.dirty(missing=True):
             pass
         elif pas[0] and repo.ui.configbool('merge', 'followcopies', True):
             followcopies = True
 
         ### calculate phase
         actionbyfile, diverge, renamedelete = calculateupdates(
             repo, wc, p2, pas, branchmerge, force, partial, mergeancestor,
             followcopies)
         # Convert to dictionary-of-lists format
         actions = dict((m, []) for m in 'a f g cd dc r dm dg m e k'.split())
         for f, (m, args, msg) in actionbyfile.iteritems():
             if m not in actions:
                 actions[m] = []
             actions[m].append((f, args, msg))
 
         if not util.checkcase(repo.path):
             # check collision between files only in p2 for clean update
             if (not branchmerge and
                 (force or not wc.dirty(missing=True, branch=False))):
                 _checkcollision(repo, p2.manifest(), None)
             else:
                 _checkcollision(repo, wc.manifest(), actions)
 
         # Prompt and create actions. TODO: Move this towards resolve phase.
         for f, args, msg in sorted(actions['cd']):
             if repo.ui.promptchoice(
                 _("local changed %s which remote deleted\n"
                   "use (c)hanged version or (d)elete?"
                   "$$ &Changed $$ &Delete") % f, 0):
                 actions['r'].append((f, None, "prompt delete"))
             else:
                 actions['a'].append((f, None, "prompt keep"))
         del actions['cd'][:]
 
         for f, args, msg in sorted(actions['dc']):
             flags, = args
             if repo.ui.promptchoice(
                 _("remote changed %s which local deleted\n"
                   "use (c)hanged version or leave (d)eleted?"
                   "$$ &Changed $$ &Deleted") % f, 0) == 0:
                 actions['g'].append((f, (flags,), "prompt recreating"))
         del actions['dc'][:]
 
         ### apply phase
         if not branchmerge: # just jump to the new rev
             fp1, fp2, xp1, xp2 = fp2, nullid, xp2, ''
         if not partial:
             repo.hook('preupdate', throw=True, parent1=xp1, parent2=xp2)
             # note that we're in the middle of an update
             repo.vfs.write('updatestate', p2.hex())
 
         stats = applyupdates(repo, actions, wc, p2, overwrite, labels=labels)
 
         # divergent renames
         for f, fl in sorted(diverge.iteritems()):
             repo.ui.warn(_("note: possible conflict - %s was renamed "
                            "multiple times to:\n") % f)
             for nf in fl:
                 repo.ui.warn(" %s\n" % nf)
 
         # rename and delete
         for f, fl in sorted(renamedelete.iteritems()):
             repo.ui.warn(_("note: possible conflict - %s was deleted "
                            "and renamed to:\n") % f)
             for nf in fl:
                 repo.ui.warn(" %s\n" % nf)
 
         if not partial:
             repo.dirstate.beginparentchange()
             repo.setparents(fp1, fp2)
             recordupdates(repo, actions, branchmerge)
             # update completed, clear state
             util.unlink(repo.join('updatestate'))
 
             if not branchmerge:
                 repo.dirstate.setbranch(p2.branch())
             repo.dirstate.endparentchange()
     finally:
         wlock.release()
 
     if not partial:
         repo.hook('update', parent1=xp1, parent2=xp2, error=stats[3])
     return stats
 
 def graft(repo, ctx, pctx, labels):
     """Do a graft-like merge.
 
     This is a merge where the merge ancestor is chosen such that one
     or more changesets are grafted onto the current changeset. In
     addition to the merge, this fixes up the dirstate to include only
     a single parent and tries to duplicate any renames/copies
     appropriately.
 
     ctx - changeset to rebase
     pctx - merge base, usually ctx.p1()
     labels - merge labels eg ['local', 'graft']
 
     """
 
     stats = update(repo, ctx.node(), True, True, False, pctx.node(),
                    labels=labels)
     # drop the second merge parent
     repo.dirstate.beginparentchange()
     repo.setparents(repo['.'].node(), nullid)
     repo.dirstate.write()
     # fix up dirstate for copies and renames
     copies.duplicatecopies(repo, ctx.rev(), pctx.rev())
     repo.dirstate.endparentchange()
     return stats

tests/test-subrepo.t

@@ -1,1471 +1,1474 b''
 Let commit recurse into subrepos by default to match pre-2.0 behavior:
 
   $ echo "[ui]" >> $HGRCPATH
   $ echo "commitsubrepos = Yes" >> $HGRCPATH
 
   $ hg init t
   $ cd t
 
 first revision, no sub
 
   $ echo a > a
   $ hg ci -Am0
   adding a
 
 add first sub
 
   $ echo s = s > .hgsub
   $ hg add .hgsub
   $ hg init s
   $ echo a > s/a
 
 Issue2232: committing a subrepo without .hgsub
 
   $ hg ci -mbad s
   abort: can't commit subrepos without .hgsub
   [255]
 
   $ hg -R s ci -Ams0
   adding a
   $ hg sum
   parent: 0:f7b1eb17ad24 tip
    0
   branch: default
   commit: 1 added, 1 subrepos
   update: (current)
   $ hg ci -m1
 
 test handling .hgsubstate "added" explicitly.
 
   $ hg parents --template '{node}\n{files}\n'
   7cf8cfea66e410e8e3336508dfeec07b3192de51
   .hgsub .hgsubstate
   $ hg rollback -q
   $ hg add .hgsubstate
   $ hg ci -m1
   $ hg parents --template '{node}\n{files}\n'
   7cf8cfea66e410e8e3336508dfeec07b3192de51
   .hgsub .hgsubstate
 
 Revert subrepo and test subrepo fileset keyword:
 
   $ echo b > s/a
   $ hg revert "set:subrepo('glob:s*')"
   reverting subrepo s
   reverting s/a (glob)
   $ rm s/a.orig
 
 Revert subrepo with no backup. The "reverting s/a" line is gone since
 we're really running 'hg update' in the subrepo:
 
   $ echo b > s/a
   $ hg revert --no-backup s
   reverting subrepo s
 
 Issue2022: update -C
 
   $ echo b > s/a
   $ hg sum
   parent: 1:7cf8cfea66e4 tip
    1
   branch: default
   commit: 1 subrepos
   update: (current)
   $ hg co -C 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg sum
   parent: 1:7cf8cfea66e4 tip
    1
   branch: default
   commit: (clean)
   update: (current)
 
 commands that require a clean repo should respect subrepos
 
   $ echo b >> s/a
   $ hg backout tip
   abort: uncommitted changes in subrepo s
   [255]
   $ hg revert -C -R s s/a
 
 add sub sub
 
   $ echo ss = ss > s/.hgsub
   $ hg init s/ss
   $ echo a > s/ss/a
   $ hg -R s add s/.hgsub
   $ hg -R s/ss add s/ss/a
   $ hg sum
   parent: 1:7cf8cfea66e4 tip
    1
   branch: default
   commit: 1 subrepos
   update: (current)
   $ hg ci -m2
   committing subrepository s
   committing subrepository s/ss (glob)
   $ hg sum
   parent: 2:df30734270ae tip
    2
   branch: default
   commit: (clean)
   update: (current)
 
 test handling .hgsubstate "modified" explicitly.
 
   $ hg parents --template '{node}\n{files}\n'
   df30734270ae757feb35e643b7018e818e78a9aa
   .hgsubstate
   $ hg rollback -q
   $ hg status -A .hgsubstate
   M .hgsubstate
   $ hg ci -m2
   $ hg parents --template '{node}\n{files}\n'
   df30734270ae757feb35e643b7018e818e78a9aa
   .hgsubstate
 
 bump sub rev (and check it is ignored by ui.commitsubrepos)
 
   $ echo b > s/a
   $ hg -R s ci -ms1
   $ hg --config ui.commitsubrepos=no ci -m3
 
 leave sub dirty (and check ui.commitsubrepos=no aborts the commit)
 
   $ echo c > s/a
   $ hg --config ui.commitsubrepos=no ci -m4
   abort: uncommitted changes in subrepo s
   (use --subrepos for recursive commit)
   [255]
   $ hg id
   f6affe3fbfaa+ tip
   $ hg -R s ci -mc
   $ hg id
   f6affe3fbfaa+ tip
   $ echo d > s/a
   $ hg ci -m4
   committing subrepository s
   $ hg tip -R s
   changeset:   4:02dcf1d70411
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     4
   
 
 check caching
 
   $ hg co 0
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg debugsub
 
 restore
 
   $ hg co
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg debugsub
   path s
    source   s
    revision 02dcf1d704118aee3ee306ccfa1910850d5b05ef
 
 new branch for merge tests
 
   $ hg co 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo t = t >> .hgsub
   $ hg init t
   $ echo t > t/t
   $ hg -R t add t
   adding t/t (glob)
 
 5
 
   $ hg ci -m5 # add sub
   committing subrepository t
   created new head
   $ echo t2 > t/t
 
 6
 
   $ hg st -R s
   $ hg ci -m6 # change sub
   committing subrepository t
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   path t
    source   t
    revision 6747d179aa9a688023c4b0cad32e4c92bb7f34ad
   $ echo t3 > t/t
 
 7
 
   $ hg ci -m7 # change sub again for conflict test
   committing subrepository t
   $ hg rm .hgsub
 
 8
 
   $ hg ci -m8 # remove sub
 
 test handling .hgsubstate "removed" explicitly.
 
   $ hg parents --template '{node}\n{files}\n'
   96615c1dad2dc8e3796d7332c77ce69156f7b78e
   .hgsub .hgsubstate
   $ hg rollback -q
   $ hg remove .hgsubstate
   $ hg ci -m8
   $ hg parents --template '{node}\n{files}\n'
   96615c1dad2dc8e3796d7332c77ce69156f7b78e
   .hgsub .hgsubstate
 
 merge tests
 
   $ hg co -C 3
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 5 # test adding
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg debugsub
   path s
    source   s
    revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
   path t
    source   t
    revision 60ca1237c19474e7a3978b0dc1ca4e6f36d51382
   $ hg ci -m9
   created new head
   $ hg merge 6 --debug # test change
     searching for copies back to rev 2
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 1f14a2e2d3ec, local: f0d2028bf86d+, remote: 1831e14459c4
    .hgsubstate: versions differ -> m
   updating: .hgsubstate 1/1 files (100.00%)
   subrepo merge f0d2028bf86d+ 1831e14459c4 1f14a2e2d3ec
     subrepo t: other changed, get t:6747d179aa9a688023c4b0cad32e4c92bb7f34ad:hg
   getting subrepo t
   resolving manifests
    branchmerge: False, force: False, partial: False
    ancestor: 60ca1237c194, local: 60ca1237c194+, remote: 6747d179aa9a
    t: remote is newer -> g
   getting t
   updating: t 1/1 files (100.00%)
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg debugsub
   path s
    source   s
    revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
   path t
    source   t
    revision 6747d179aa9a688023c4b0cad32e4c92bb7f34ad
   $ echo conflict > t/t
   $ hg ci -m10
   committing subrepository t
   $ HGMERGE=internal:merge hg merge --debug 7 # test conflict
     searching for copies back to rev 2
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 1831e14459c4, local: e45c8b14af55+, remote: f94576341bcf
    .hgsubstate: versions differ -> m
   updating: .hgsubstate 1/1 files (100.00%)
   subrepo merge e45c8b14af55+ f94576341bcf 1831e14459c4
     subrepo t: both sides changed 
    subrepository t diverged (local revision: 20a0db6fbf6c, remote revision: 7af322bc1198)
   (M)erge, keep (l)ocal or keep (r)emote? m
   merging subrepo t
     searching for copies back to rev 2
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 6747d179aa9a, local: 20a0db6fbf6c+, remote: 7af322bc1198
    preserving t for resolve of t
    t: versions differ -> m
   updating: t 1/1 files (100.00%)
   picked tool 'internal:merge' for t (binary False symlink False)
   merging t
   my t@20a0db6fbf6c+ other t@7af322bc1198 ancestor t@6747d179aa9a
   warning: conflicts during merge.
   merging t incomplete! (edit conflicts, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
     subrepo t: merge with t:7af322bc1198a32402fe903e0b7ebcfc5c9bf8f4:hg
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 should conflict
 
   $ cat t/t
   <<<<<<< local: 20a0db6fbf6c - test: 10
   conflict
   =======
   t3
   >>>>>>> other: 7af322bc1198  - test: 7
 
 clone
 
   $ cd ..
   $ hg clone t tc
   updating to branch default
   cloning subrepo s from $TESTTMP/t/s
   cloning subrepo s/ss from $TESTTMP/t/s/ss (glob)
   cloning subrepo t from $TESTTMP/t/t
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd tc
   $ hg debugsub
   path s
    source   s
    revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
   path t
    source   t
    revision 20a0db6fbf6c3d2836e6519a642ae929bfc67c0e
 
 push
 
   $ echo bah > t/t
   $ hg ci -m11
   committing subrepository t
   $ hg push
   pushing to $TESTTMP/t (glob)
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   no changes made to subrepo s since last push to $TESTTMP/t/s
   pushing subrepo t to $TESTTMP/t/t
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 push -f
 
   $ echo bah > s/a
   $ hg ci -m12
   committing subrepository s
   $ hg push
   pushing to $TESTTMP/t (glob)
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   pushing subrepo s to $TESTTMP/t/s
   searching for changes
   abort: push creates new remote head 12a213df6fa9! (in subrepo s)
   (merge or see "hg help push" for details about pushing new heads)
   [255]
   $ hg push -f
   pushing to $TESTTMP/t (glob)
   pushing subrepo s/ss to $TESTTMP/t/s/ss (glob)
   searching for changes
   no changes found
   pushing subrepo s to $TESTTMP/t/s
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   pushing subrepo t to $TESTTMP/t/t
   searching for changes
   no changes found
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 check that unmodified subrepos are not pushed
 
   $ hg clone . ../tcc
   updating to branch default
   cloning subrepo s from $TESTTMP/tc/s
   cloning subrepo s/ss from $TESTTMP/tc/s/ss (glob)
   cloning subrepo t from $TESTTMP/tc/t
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 the subrepos on the new clone have nothing to push to its source
 
   $ hg push -R ../tcc .
   pushing to .
   no changes made to subrepo s/ss since last push to s/ss (glob)
   no changes made to subrepo s since last push to s
   no changes made to subrepo t since last push to t
   searching for changes
   no changes found
   [1]
 
 the subrepos on the source do not have a clean store versus the clone target
 because they were never explicitly pushed to the source
 
   $ hg push ../tcc
   pushing to ../tcc
   pushing subrepo s/ss to ../tcc/s/ss (glob)
   searching for changes
   no changes found
   pushing subrepo s to ../tcc/s
   searching for changes
   no changes found
   pushing subrepo t to ../tcc/t
   searching for changes
   no changes found
   searching for changes
   no changes found
   [1]
 
 after push their stores become clean
 
   $ hg push ../tcc
   pushing to ../tcc
   no changes made to subrepo s/ss since last push to ../tcc/s/ss (glob)
   no changes made to subrepo s since last push to ../tcc/s
   no changes made to subrepo t since last push to ../tcc/t
   searching for changes
   no changes found
   [1]
 
 updating a subrepo to a different revision or changing
 its working directory does not make its store dirty
 
   $ hg -R s update '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg push
   pushing to $TESTTMP/t (glob)
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
   $ echo foo >> s/a
   $ hg push
   pushing to $TESTTMP/t (glob)
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
   $ hg -R s update -C tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 committing into a subrepo makes its store (but not its parent's store) dirty
 
   $ echo foo >> s/ss/a
   $ hg -R s/ss commit -m 'test dirty store detection'
   $ hg push
   pushing to $TESTTMP/t (glob)
   pushing subrepo s/ss to $TESTTMP/t/s/ss (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
 
 a subrepo store may be clean versus one repo but not versus another
 
   $ hg push
   pushing to $TESTTMP/t (glob)
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
   $ hg push ../tcc
   pushing to ../tcc
   pushing subrepo s/ss to ../tcc/s/ss (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   no changes made to subrepo s since last push to ../tcc/s
   no changes made to subrepo t since last push to ../tcc/t
   searching for changes
   no changes found
   [1]
 
 update
 
   $ cd ../t
   $ hg up -C # discard our earlier merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo blah > t/t
   $ hg ci -m13
   committing subrepository t
 
 backout calls revert internally with minimal opts, which should not raise
 KeyError
 
   $ hg backout ".^"
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   changeset c373c8102e68 backed out, don't forget to commit.
 
   $ hg up -C # discard changes
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 pull
 
   $ cd ../tc
   $ hg pull
   pulling from $TESTTMP/t (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   (run 'hg update' to get a working copy)
 
 should pull t
 
   $ hg up
   pulling subrepo t from $TESTTMP/t/t
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat t/t
   blah
 
 bogus subrepo path aborts
 
   $ echo 'bogus=[boguspath' >> .hgsub
   $ hg ci -m 'bogus subrepo path'
   abort: missing ] in subrepo source
   [255]
 
 Issue1986: merge aborts when trying to merge a subrepo that
 shouldn't need merging
 
 # subrepo layout
 #
 #   o   5 br
 #  /|
 # o |   4 default
 # | |
 # | o   3 br
 # |/|
 # o |   2 default
 # | |
 # | o   1 br
 # |/
 # o     0 default
 
   $ cd ..
   $ rm -rf sub
   $ hg init main
   $ cd main
   $ hg init s
   $ cd s
   $ echo a > a
   $ hg ci -Am1
   adding a
   $ hg branch br
   marked working directory as branch br
   (branches are permanent and global, did you want a bookmark?)
   $ echo a >> a
   $ hg ci -m1
   $ hg up default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo b > b
   $ hg ci -Am1
   adding b
   $ hg up br
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m1
   $ hg up 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -Am1
   adding c
   $ hg up 3
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m1
 
 # main repo layout:
 #
 #   * <-- try to merge default into br again
 # .`|
 # . o   5 br      --> substate = 5
 # . |
 # o |   4 default --> substate = 4
 # | |
 # | o   3 br      --> substate = 2
 # |/|
 # o |   2 default --> substate = 2
 # | |
 # | o   1 br      --> substate = 3
 # |/
 # o     0 default --> substate = 2
 
   $ cd ..
   $ echo 's = s' > .hgsub
   $ hg -R s up 2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg ci -Am1
   adding .hgsub
   $ hg branch br
   marked working directory as branch br
   (branches are permanent and global, did you want a bookmark?)
   $ echo b > b
   $ hg -R s up 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg ci -Am1
   adding b
   $ hg up default
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -Am1
   adding c
   $ hg up 1
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m1
   $ hg up 2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg -R s up 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo d > d
   $ hg ci -Am1
   adding d
   $ hg up 3
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg -R s up 5
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo e > e
   $ hg ci -Am1
   adding e
 
   $ hg up 5
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 4    # try to merge default into br again
    subrepository s diverged (local revision: f8f13b33206e, remote revision: a3f9062a4f88)
   (M)erge, keep (l)ocal or keep (r)emote? m
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cd ..
 
 test subrepo delete from .hgsubstate
 
   $ hg init testdelete
   $ mkdir testdelete/nested testdelete/nested2
   $ hg init testdelete/nested
   $ hg init testdelete/nested2
   $ echo test > testdelete/nested/foo
   $ echo test > testdelete/nested2/foo
   $ hg -R testdelete/nested add
   adding testdelete/nested/foo (glob)
   $ hg -R testdelete/nested2 add
   adding testdelete/nested2/foo (glob)
   $ hg -R testdelete/nested ci -m test
   $ hg -R testdelete/nested2 ci -m test
   $ echo nested = nested > testdelete/.hgsub
   $ echo nested2 = nested2 >> testdelete/.hgsub
   $ hg -R testdelete add
   adding testdelete/.hgsub (glob)
   $ hg -R testdelete ci -m "nested 1 & 2 added"
   $ echo nested = nested > testdelete/.hgsub
   $ hg -R testdelete ci -m "nested 2 deleted"
   $ cat testdelete/.hgsubstate
   bdf5c9a3103743d900b12ae0db3ffdcfd7b0d878 nested
   $ hg -R testdelete remove testdelete/.hgsub
   $ hg -R testdelete ci -m ".hgsub deleted"
   $ cat testdelete/.hgsubstate
   bdf5c9a3103743d900b12ae0db3ffdcfd7b0d878 nested
 
 test repository cloning
 
   $ mkdir mercurial mercurial2
   $ hg init nested_absolute
   $ echo test > nested_absolute/foo
   $ hg -R nested_absolute add
   adding nested_absolute/foo (glob)
   $ hg -R nested_absolute ci -mtest
   $ cd mercurial
   $ hg init nested_relative
   $ echo test2 > nested_relative/foo2
   $ hg -R nested_relative add
   adding nested_relative/foo2 (glob)
   $ hg -R nested_relative ci -mtest2
   $ hg init main
   $ echo "nested_relative = ../nested_relative" > main/.hgsub
   $ echo "nested_absolute = `pwd`/nested_absolute" >> main/.hgsub
   $ hg -R main add
   adding main/.hgsub (glob)
   $ hg -R main ci -m "add subrepos"
   $ cd ..
   $ hg clone mercurial/main mercurial2/main
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat mercurial2/main/nested_absolute/.hg/hgrc \
   >     mercurial2/main/nested_relative/.hg/hgrc
   [paths]
   default = $TESTTMP/mercurial/nested_absolute
   [paths]
   default = $TESTTMP/mercurial/nested_relative
   $ rm -rf mercurial mercurial2
 
 Issue1977: multirepo push should fail if subrepo push fails
 
   $ hg init repo
   $ hg init repo/s
   $ echo a > repo/s/a
   $ hg -R repo/s ci -Am0
   adding a
   $ echo s = s > repo/.hgsub
   $ hg -R repo ci -Am1
   adding .hgsub
   $ hg clone repo repo2
   updating to branch default
   cloning subrepo s from $TESTTMP/repo/s
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -q -R repo2 pull -u
   $ echo 1 > repo2/s/a
   $ hg -R repo2/s ci -m2
   $ hg -q -R repo2/s push
   $ hg -R repo2/s up -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 2 > repo2/s/b
   $ hg -R repo2/s ci -m3 -A
   adding b
   created new head
   $ hg -R repo2 ci -m3
   $ hg -q -R repo2 push
   abort: push creates new remote head cc505f09a8b2! (in subrepo s)
   (merge or see "hg help push" for details about pushing new heads)
   [255]
   $ hg -R repo update
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 test if untracked file is not overwritten
 
   $ echo issue3276_ok > repo/s/b
   $ hg -R repo2 push -f -q
+  $ touch -t 200001010000 repo/.hgsubstate
+  $ hg -R repo status --config debug.dirstate.delaywrite=2 repo/.hgsubstate
   $ hg -R repo update
   b: untracked file differs
   abort: untracked files in working directory differ from files in requested revision (in subrepo s)
   [255]
 
   $ cat repo/s/b
   issue3276_ok
   $ rm repo/s/b
+  $ touch -t 200001010000 repo/.hgsubstate
   $ hg -R repo revert --all
   reverting repo/.hgsubstate (glob)
   reverting subrepo s
   $ hg -R repo update
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat repo/s/b
   2
   $ rm -rf repo2 repo
 
 
 Issue1852 subrepos with relative paths always push/pull relative to default
 
 Prepare a repo with subrepo
 
   $ hg init issue1852a
   $ cd issue1852a
   $ hg init sub/repo
   $ echo test > sub/repo/foo
   $ hg -R sub/repo add sub/repo/foo
   $ echo sub/repo = sub/repo > .hgsub
   $ hg add .hgsub
   $ hg ci -mtest
   committing subrepository sub/repo (glob)
   $ echo test >> sub/repo/foo
   $ hg ci -mtest
   committing subrepository sub/repo (glob)
   $ hg cat sub/repo/foo
   test
   test
   $ mkdir -p tmp/sub/repo
   $ hg cat -r 0 --output tmp/%p_p sub/repo/foo
   $ cat tmp/sub/repo/foo_p
   test
   $ mv sub/repo sub_
   $ hg cat sub/repo/baz
   skipping missing subrepository: sub/repo
   [1]
   $ rm -rf sub/repo
   $ mv sub_ sub/repo
   $ cd ..
 
 Create repo without default path, pull top repo, and see what happens on update
 
   $ hg init issue1852b
   $ hg -R issue1852b pull issue1852a
   pulling from issue1852a
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 3 changes to 2 files
   (run 'hg update' to get a working copy)
   $ hg -R issue1852b update
   abort: default path for subrepository not found (in subrepo sub/repo) (glob)
   [255]
 
 Ensure a full traceback, not just the SubrepoAbort part
 
   $ hg -R issue1852b update --traceback 2>&1 | grep 'raise util\.Abort'
       raise util.Abort(_("default path for subrepository not found"))
 
 Pull -u now doesn't help
 
   $ hg -R issue1852b pull -u issue1852a
   pulling from issue1852a
   searching for changes
   no changes found
 
 Try the same, but with pull -u
 
   $ hg init issue1852c
   $ hg -R issue1852c pull -r0 -u issue1852a
   pulling from issue1852a
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   cloning subrepo sub/repo from issue1852a/sub/repo (glob)
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Try to push from the other side
 
   $ hg -R issue1852a push `pwd`/issue1852c
   pushing to $TESTTMP/issue1852c (glob)
   pushing subrepo sub/repo to $TESTTMP/issue1852c/sub/repo (glob)
   searching for changes
   no changes found
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 Incoming and outgoing should not use the default path:
 
   $ hg clone -q issue1852a issue1852d
   $ hg -R issue1852d outgoing --subrepos issue1852c
   comparing with issue1852c
   searching for changes
   no changes found
   comparing with issue1852c/sub/repo
   searching for changes
   no changes found
   [1]
   $ hg -R issue1852d incoming --subrepos issue1852c
   comparing with issue1852c
   searching for changes
   no changes found
   comparing with issue1852c/sub/repo
   searching for changes
   no changes found
   [1]
 
 Check status of files when none of them belong to the first
 subrepository:
 
   $ hg init subrepo-status
   $ cd subrepo-status
   $ hg init subrepo-1
   $ hg init subrepo-2
   $ cd subrepo-2
   $ touch file
   $ hg add file
   $ cd ..
   $ echo subrepo-1 = subrepo-1 > .hgsub
   $ echo subrepo-2 = subrepo-2 >> .hgsub
   $ hg add .hgsub
   $ hg ci -m 'Added subrepos'
   committing subrepository subrepo-2
   $ hg st subrepo-2/file
 
 Check that share works with subrepo
   $ hg --config extensions.share= share . ../shared
   updating working directory
   cloning subrepo subrepo-2 from $TESTTMP/subrepo-status/subrepo-2
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ test -f ../shared/subrepo-1/.hg/sharedpath
   [1]
   $ hg -R ../shared in
   abort: repository default not found!
   [255]
   $ hg -R ../shared/subrepo-2 showconfig paths
   paths.default=$TESTTMP/subrepo-status/subrepo-2
   $ hg -R ../shared/subrepo-1 sum --remote
   parent: -1:000000000000 tip (empty repository)
   branch: default
   commit: (clean)
   update: (current)
   remote: (synced)
 
 Check hg update --clean
   $ cd $TESTTMP/t
   $ rm -r t/t.orig
   $ hg status -S --all
   C .hgsub
   C .hgsubstate
   C a
   C s/.hgsub
   C s/.hgsubstate
   C s/a
   C s/ss/a
   C t/t
   $ echo c1 > s/a
   $ cd s
   $ echo c1 > b
   $ echo c1 > c
   $ hg add b
   $ cd ..
   $ hg status -S
   M s/a
   A s/b
   ? s/c
   $ hg update -C
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status -S
   ? s/b
   ? s/c
 
 Sticky subrepositories, no changes
   $ cd $TESTTMP/t
   $ hg id
   925c17564ef8 tip
   $ hg -R s id
   12a213df6fa9 tip
   $ hg -R t id
   52c0adc0515a tip
   $ hg update 11
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   365661e5936a
   $ hg -R s id
   fc627a69481f
   $ hg -R t id
   e95bcfa18a35
 
 Sticky subrepositories, file changes
   $ touch s/f1
   $ touch t/f1
   $ hg add -S s/f1
   $ hg add -S t/f1
   $ hg id
   365661e5936a+
   $ hg -R s id
   fc627a69481f+
   $ hg -R t id
   e95bcfa18a35+
   $ hg update tip
    subrepository s diverged (local revision: fc627a69481f, remote revision: 12a213df6fa9)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for s differ
   use (l)ocal source (fc627a69481f) or (r)emote source (12a213df6fa9)? l
    subrepository t diverged (local revision: e95bcfa18a35, remote revision: 52c0adc0515a)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for t differ
   use (l)ocal source (e95bcfa18a35) or (r)emote source (52c0adc0515a)? l
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   925c17564ef8+ tip
   $ hg -R s id
   fc627a69481f+
   $ hg -R t id
   e95bcfa18a35+
   $ hg update --clean tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Sticky subrepository, revision updates
   $ hg id
   925c17564ef8 tip
   $ hg -R s id
   12a213df6fa9 tip
   $ hg -R t id
   52c0adc0515a tip
   $ cd s
   $ hg update -r -2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../t
   $ hg update -r 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
   $ hg update 10
    subrepository s diverged (local revision: 12a213df6fa9, remote revision: fc627a69481f)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository t diverged (local revision: 52c0adc0515a, remote revision: 20a0db6fbf6c)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for t differ (in checked out version)
   use (l)ocal source (7af322bc1198) or (r)emote source (20a0db6fbf6c)? l
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   e45c8b14af55+
   $ hg -R s id
   02dcf1d70411
   $ hg -R t id
   7af322bc1198
 
 Sticky subrepository, file changes and revision updates
   $ touch s/f1
   $ touch t/f1
   $ hg add -S s/f1
   $ hg add -S t/f1
   $ hg id
   e45c8b14af55+
   $ hg -R s id
   02dcf1d70411+
   $ hg -R t id
   7af322bc1198+
   $ hg update tip
    subrepository s diverged (local revision: 12a213df6fa9, remote revision: 12a213df6fa9)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for s differ
   use (l)ocal source (02dcf1d70411) or (r)emote source (12a213df6fa9)? l
    subrepository t diverged (local revision: 52c0adc0515a, remote revision: 52c0adc0515a)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for t differ
   use (l)ocal source (7af322bc1198) or (r)emote source (52c0adc0515a)? l
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   925c17564ef8+ tip
   $ hg -R s id
   02dcf1d70411+
   $ hg -R t id
   7af322bc1198+
 
 Sticky repository, update --clean
   $ hg update --clean tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   925c17564ef8 tip
   $ hg -R s id
   12a213df6fa9 tip
   $ hg -R t id
   52c0adc0515a tip
 
 Test subrepo already at intended revision:
   $ cd s
   $ hg update fc627a69481f
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
   $ hg update 11
    subrepository s diverged (local revision: 12a213df6fa9, remote revision: fc627a69481f)
   (M)erge, keep (l)ocal or keep (r)emote? m
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -n
   11+
   $ hg -R s id
   fc627a69481f
   $ hg -R t id
   e95bcfa18a35
 
 Test that removing .hgsubstate doesn't break anything:
 
   $ hg rm -f .hgsubstate
   $ hg ci -mrm
   nothing changed
   [1]
   $ hg log -vr tip
   changeset:   13:925c17564ef8
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       .hgsubstate
   description:
   13
   
   
 
 Test that removing .hgsub removes .hgsubstate:
 
   $ hg rm .hgsub
   $ hg ci -mrm2
   created new head
   $ hg log -vr tip
   changeset:   14:2400bccd50af
   tag:         tip
   parent:      11:365661e5936a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       .hgsub .hgsubstate
   description:
   rm2
   
   
 Test issue3153: diff -S with deleted subrepos
 
   $ hg diff --nodates -S -c .
   diff -r 365661e5936a -r 2400bccd50af .hgsub
   --- a/.hgsub
   +++ /dev/null
   @@ -1,2 +0,0 @@
   -s = s
   -t = t
   diff -r 365661e5936a -r 2400bccd50af .hgsubstate
   --- a/.hgsubstate
   +++ /dev/null
   @@ -1,2 +0,0 @@
   -fc627a69481fcbe5f1135069e8a3881c023e4cf5 s
   -e95bcfa18a358dc4936da981ebf4147b4cad1362 t
 
 Test behavior of add for explicit path in subrepo:
   $ cd ..
   $ hg init explicit
   $ cd explicit
   $ echo s = s > .hgsub
   $ hg add .hgsub
   $ hg init s
   $ hg ci -m0
 Adding with an explicit path in a subrepo adds the file
   $ echo c1 > f1
   $ echo c2 > s/f2
   $ hg st -S
   ? f1
   ? s/f2
   $ hg add s/f2
   $ hg st -S
   A s/f2
   ? f1
   $ hg ci -R s -m0
   $ hg ci -Am1
   adding f1
 Adding with an explicit path in a subrepo with -S has the same behavior
   $ echo c3 > f3
   $ echo c4 > s/f4
   $ hg st -S
   ? f3
   ? s/f4
   $ hg add -S s/f4
   $ hg st -S
   A s/f4
   ? f3
   $ hg ci -R s -m1
   $ hg ci -Ama2
   adding f3
 Adding without a path or pattern silently ignores subrepos
   $ echo c5 > f5
   $ echo c6 > s/f6
   $ echo c7 > s/f7
   $ hg st -S
   ? f5
   ? s/f6
   ? s/f7
   $ hg add
   adding f5
   $ hg st -S
   A f5
   ? s/f6
   ? s/f7
   $ hg ci -R s -Am2
   adding f6
   adding f7
   $ hg ci -m3
 Adding without a path or pattern with -S also adds files in subrepos
   $ echo c8 > f8
   $ echo c9 > s/f9
   $ echo c10 > s/f10
   $ hg st -S
   ? f8
   ? s/f10
   ? s/f9
   $ hg add -S
   adding f8
   adding s/f10 (glob)
   adding s/f9 (glob)
   $ hg st -S
   A f8
   A s/f10
   A s/f9
   $ hg ci -R s -m3
   $ hg ci -m4
 Adding with a pattern silently ignores subrepos
   $ echo c11 > fm11
   $ echo c12 > fn12
   $ echo c13 > s/fm13
   $ echo c14 > s/fn14
   $ hg st -S
   ? fm11
   ? fn12
   ? s/fm13
   ? s/fn14
   $ hg add 'glob:**fm*'
   adding fm11
   $ hg st -S
   A fm11
   ? fn12
   ? s/fm13
   ? s/fn14
   $ hg ci -R s -Am4
   adding fm13
   adding fn14
   $ hg ci -Am5
   adding fn12
 Adding with a pattern with -S also adds matches in subrepos
   $ echo c15 > fm15
   $ echo c16 > fn16
   $ echo c17 > s/fm17
   $ echo c18 > s/fn18
   $ hg st -S
   ? fm15
   ? fn16
   ? s/fm17
   ? s/fn18
   $ hg add -S 'glob:**fm*'
   adding fm15
   adding s/fm17 (glob)
   $ hg st -S
   A fm15
   A s/fm17
   ? fn16
   ? s/fn18
   $ hg ci -R s -Am5
   adding fn18
   $ hg ci -Am6
   adding fn16
 
 Test behavior of forget for explicit path in subrepo:
 Forgetting an explicit path in a subrepo untracks the file
   $ echo c19 > s/f19
   $ hg add s/f19
   $ hg st -S
   A s/f19
   $ hg forget s/f19
   $ hg st -S
   ? s/f19
   $ rm s/f19
   $ cd ..
 
 Courtesy phases synchronisation to publishing server does not block the push
 (issue3781)
 
   $ cp -r main issue3781
   $ cp -r main issue3781-dest
   $ cd issue3781-dest/s
   $ hg phase tip # show we have draft changeset
   5: draft
   $ chmod a-w .hg/store/phaseroots # prevent phase push
   $ cd ../../issue3781
   $ cat >> .hg/hgrc << EOF
   > [paths]
   > default=../issue3781-dest/
   > EOF
   $ hg push
   pushing to $TESTTMP/issue3781-dest (glob)
   pushing subrepo s to $TESTTMP/issue3781-dest/s
   searching for changes
   no changes found
   searching for changes
   no changes found
   [1]
   $ cd ..
 
 Test phase choice for newly created commit with "phases.subrepochecks"
 configuration
 
   $ cd t
   $ hg update -q -r 12
 
   $ cat >> s/ss/.hg/hgrc <<EOF
   > [phases]
   > new-commit = secret
   > EOF
   $ cat >> s/.hg/hgrc <<EOF
   > [phases]
   > new-commit = draft
   > EOF
   $ echo phasecheck1 >> s/ss/a
   $ hg -R s commit -S --config phases.checksubrepos=abort -m phasecheck1
   committing subrepository ss
   transaction abort!
   rollback completed
   abort: can't commit in draft phase conflicting secret from subrepository ss
   [255]
   $ echo phasecheck2 >> s/ss/a
   $ hg -R s commit -S --config phases.checksubrepos=ignore -m phasecheck2
   committing subrepository ss
   $ hg -R s/ss phase tip
   3: secret
   $ hg -R s phase tip
   6: draft
   $ echo phasecheck3 >> s/ss/a
   $ hg -R s commit -S -m phasecheck3
   committing subrepository ss
   warning: changes are committed in secret phase from subrepository ss
   $ hg -R s/ss phase tip
   4: secret
   $ hg -R s phase tip
   7: secret
 
   $ cat >> t/.hg/hgrc <<EOF
   > [phases]
   > new-commit = draft
   > EOF
   $ cat >> .hg/hgrc <<EOF
   > [phases]
   > new-commit = public
   > EOF
   $ echo phasecheck4 >>   s/ss/a
   $ echo phasecheck4 >>   t/t
   $ hg commit -S -m phasecheck4
   committing subrepository s
   committing subrepository s/ss (glob)
   warning: changes are committed in secret phase from subrepository ss
   committing subrepository t
   warning: changes are committed in secret phase from subrepository s
   created new head
   $ hg -R s/ss phase tip
   5: secret
   $ hg -R s phase tip
   8: secret
   $ hg -R t phase tip
   6: draft
   $ hg phase tip
   15: secret
 
   $ cd ..
 
 
 Test that commit --secret works on both repo and subrepo (issue4182)
 
   $ cd main
   $ echo secret >> b
   $ echo secret >> s/b
   $ hg commit --secret --subrepo -m "secret"
   committing subrepository s
   $ hg phase -r .
   6: secret
   $ cd s
   $ hg phase -r .
   6: secret
   $ cd ../../
 
 Test "subrepos" template keyword
 
   $ cd t
   $ hg update -q 15
   $ cat > .hgsub <<EOF
   > s = s
   > EOF
   $ hg commit -m "16"
   warning: changes are committed in secret phase from subrepository s
 
 (addition of ".hgsub" itself)
 
   $ hg diff --nodates -c 1 .hgsubstate
   diff -r f7b1eb17ad24 -r 7cf8cfea66e4 .hgsubstate
   --- /dev/null
   +++ b/.hgsubstate
   @@ -0,0 +1,1 @@
   +e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ hg log -r 1 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   f7b1eb17ad24 000000000000
   s
 
 (modification of existing entry)
 
   $ hg diff --nodates -c 2 .hgsubstate
   diff -r 7cf8cfea66e4 -r df30734270ae .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,1 @@
   -e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   +dc73e2e6d2675eb2e41e33c205f4bdab4ea5111d s
   $ hg log -r 2 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   7cf8cfea66e4 000000000000
   s
 
 (addition of entry)
 
   $ hg diff --nodates -c 5 .hgsubstate
   diff -r 7cf8cfea66e4 -r 1f14a2e2d3ec .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,2 @@
    e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   +60ca1237c19474e7a3978b0dc1ca4e6f36d51382 t
   $ hg log -r 5 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   7cf8cfea66e4 000000000000
   t
 
 (removal of existing entry)
 
   $ hg diff --nodates -c 16 .hgsubstate
   diff -r 8bec38d2bd0b -r f2f70bc3d3c9 .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,2 +1,1 @@
    0731af8ca9423976d3743119d0865097c07bdc1b s
   -e202dc79b04c88a636ea8913d9182a1346d9b3dc t
   $ hg log -r 16 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   8bec38d2bd0b 000000000000
   t
 
 (merging)
 
   $ hg diff --nodates -c 9 .hgsubstate
   diff -r f6affe3fbfaa -r f0d2028bf86d .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,2 @@
    fc627a69481fcbe5f1135069e8a3881c023e4cf5 s
   +60ca1237c19474e7a3978b0dc1ca4e6f36d51382 t
   $ hg log -r 9 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   f6affe3fbfaa 1f14a2e2d3ec
   t
 
 (removal of ".hgsub" itself)
 
   $ hg diff --nodates -c 8 .hgsubstate
   diff -r f94576341bcf -r 96615c1dad2d .hgsubstate
   --- a/.hgsubstate
   +++ /dev/null
   @@ -1,2 +0,0 @@
   -e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   -7af322bc1198a32402fe903e0b7ebcfc5c9bf8f4 t
   $ hg log -r 8 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   f94576341bcf 000000000000
 
 Test that '[paths]' is configured correctly at subrepo creation
 
   $ cd $TESTTMP/tc
   $ cat > .hgsub <<EOF
   > # to clear bogus subrepo path 'bogus=[boguspath'
   > s = s
   > t = t
   > EOF
   $ hg update -q --clean null
   $ rm -rf s t
   $ cat >> .hg/hgrc <<EOF
   > [paths]
   > default-push = /foo/bar
   > EOF
   $ hg update -q
   $ cat s/.hg/hgrc
   [paths]
   default = $TESTTMP/t/s
   default-push = /foo/bar/s
   $ cat s/ss/.hg/hgrc
   [paths]
   default = $TESTTMP/t/s/ss
   default-push = /foo/bar/s/ss
   $ cat t/.hg/hgrc
   [paths]
   default = $TESTTMP/t/t
   default-push = /foo/bar/t
   $ cd ..