state: support validated declaration of nested unfinished ops

This enables extensions to define commands that delgate to rebase, evolve, etc. one or more times to also have their own unfinished states for the full sequence of operations without monkey-patching _unfinishedstates.

Differential Revision: https://phab.mercurial-scm.org/D8714

tests/test-state-extension.t

@@ -0,0 +1,136 b''
+Test extension of unfinished states support.
+  $ mkdir chainify
+  $ cd chainify
+  $ cat >> chainify.py <<EOF
+  > from mercurial import cmdutil, error, extensions, exthelper, node, scmutil, state
+  > from hgext import rebase
+  > 
+  > eh = exthelper.exthelper()
+  > 
+  > extsetup = eh.finalextsetup
+  > cmdtable = eh.cmdtable
+  > 
+  > # Rebase calls addunfinished in uisetup, so we have to call it in extsetup.
+  > # Ideally there'd by an 'extensions.afteruisetup()' just like
+  > # 'extensions.afterloaded()' to allow nesting multiple commands.
+  > @eh.extsetup
+  > def _extsetup(ui):
+  >     state.addunfinished(
+  >         b'chainify',
+  >         b'chainify.state',
+  >         continueflag=True,
+  >         childopnames=[b'rebase'])
+  > 
+  > def _node(repo, arg):
+  >     return node.hex(scmutil.revsingle(repo, arg).node())
+  > 
+  > @eh.command(
+  >     b'chainify',
+  >     [(b'r', b'revs', [], b'revs to chain', b'REV'),
+  >      (b'', b'continue', False, b'continue op')],
+  >     b'chainify [-r REV] +',
+  >     inferrepo=True)
+  > def chainify(ui, repo, **opts):
+  >     """Rebases r1, r2, r3, etc. into a chain."""
+  >     with repo.wlock(), repo.lock():
+  >         cmdstate = state.cmdstate(repo, b'chainify.state')
+  >         if opts['continue']:
+  >             if not cmdstate.exists():
+  >                 raise error.Abort(b'no chainify in progress')
+  >         else:
+  >             cmdutil.checkunfinished(repo)
+  >             data = {
+  >                 b'tip': _node(repo, opts['revs'][0]),
+  >                 b'revs': b','.join(_node(repo, r) for r in opts['revs'][1:]),
+  >             }
+  >             cmdstate.save(1, data)
+  > 
+  >         data = cmdstate.read()
+  >         while data[b'revs']:
+  >             tip = data[b'tip']
+  >             revs = data[b'revs'].split(b',')
+  >             with state.delegating(repo, b'chainify', b'rebase'):
+  >                 ui.status(b'rebasing %s onto %s\n' % (revs[0][:12], tip[:12]))
+  >                 if state.ischildunfinished(repo, b'chainify', b'rebase'):
+  >                     rc = state.continuechild(ui, repo, b'chainify', b'rebase')
+  >                 else:
+  >                     rc = rebase.rebase(ui, repo, rev=[revs[0]], dest=tip)
+  >                 if rc and rc != 0:
+  >                     raise error.Abort(b'rebase failed (rc: %d)' % rc)
+  >             data[b'tip'] = _node(repo, b'tip')
+  >             data[b'revs'] = b','.join(revs[1:])
+  >             cmdstate.save(1, data)
+  >         cmdstate.delete()
+  >         ui.status(b'done chainifying\n')
+  > EOF
+
+  $ chainifypath=`pwd`/chainify.py
+  $ echo '[extensions]' >> $HGRCPATH
+  $ echo "chainify = $chainifypath" >> $HGRCPATH
+  $ echo "rebase =" >> $HGRCPATH
+
+  $ cd $TESTTMP
+  $ hg init a
+  $ cd a
+  $ echo base > base.txt
+  $ hg commit -Aqm 'base commit'
+  $ echo foo > file1
+  $ hg commit -Aqm 'add file'
+  $ hg co -q ".^"
+  $ echo bar > file2
+  $ hg commit -Aqm 'add other file'
+  $ hg co -q ".^"
+  $ echo foo2 > file1
+  $ hg commit -Aqm 'add conflicting file'
+  $ hg co -q ".^"
+  $ hg log --graph --template '{rev} {files}'
+  o  3 file1
+  |
+  | o  2 file2
+  |/
+  | o  1 file1
+  |/
+  @  0 base.txt
+  
+  $ hg chainify -r 8430cfdf77c2 -r f8596309dff8 -r a858b338b3e9
+  rebasing f8596309dff8 onto 8430cfdf77c2
+  rebasing 2:f8596309dff8 "add other file"
+  saved backup bundle to $TESTTMP/* (glob)
+  rebasing a858b338b3e9 onto 83c722183a8e
+  rebasing 2:a858b338b3e9 "add conflicting file"
+  merging file1
+  warning: conflicts while merging file1! (edit, then use 'hg resolve --mark')
+  unresolved conflicts (see 'hg resolve', then 'hg chainify --continue')
+  [1]
+  $ hg status --config commands.status.verbose=True
+  M file1
+  ? file1.orig
+  # The repository is in an unfinished *chainify* state.
+  
+  # Unresolved merge conflicts:
+  # 
+  #     file1
+  # 
+  # To mark files as resolved:  hg resolve --mark FILE
+  
+  # To continue:    hg chainify --continue
+  # To abort:       hg chainify --abort
+  
+  $ echo foo3 > file1
+  $ hg resolve --mark file1
+  (no more unresolved files)
+  continue: hg chainify --continue
+  $ hg chainify --continue
+  rebasing a858b338b3e9 onto 83c722183a8e
+  rebasing 2:a858b338b3e9 "add conflicting file"
+  saved backup bundle to $TESTTMP/* (glob)
+  done chainifying
+  $ hg log --graph --template '{rev} {files}'
+  o  3 file1
+  |
+  o  2 file2
+  |
+  o  1 file1
+  |
+  @  0 base.txt
+  

mercurial/state.py

@@ -19,6 +19,8 b' the data.'
 
 from __future__ import absolute_import
 
+import contextlib
+
 from .i18n import _
 
 from . import (
@@ -119,6 +121,7 b' class _statecheck(object):'
         reportonly,
         continueflag,
         stopflag,
+        childopnames,
         cmdmsg,
         cmdhint,
         statushint,
@@ -132,6 +135,8 b' class _statecheck(object):'
         self._reportonly = reportonly
         self._continueflag = continueflag
         self._stopflag = stopflag
+        self._childopnames = childopnames
+        self._delegating = False
         self._cmdmsg = cmdmsg
         self._cmdhint = cmdhint
         self._statushint = statushint
@@ -181,12 +186,15 b' class _statecheck(object):'
         """
         if self._opname == b'merge':
             return len(repo[None].parents()) > 1
+        elif self._delegating:
+            return False
         else:
             return repo.vfs.exists(self._fname)
 
 
 # A list of statecheck objects for multistep operations like graft.
 _unfinishedstates = []
+_unfinishedstatesbyname = {}
 
 
 def addunfinished(
@@ -197,6 +205,7 b' def addunfinished('
     reportonly=False,
     continueflag=False,
     stopflag=False,
+    childopnames=None,
     cmdmsg=b"",
     cmdhint=b"",
     statushint=b"",
@@ -218,6 +227,8 b' def addunfinished('
     `--continue` option or not.
     stopflag is a boolean that determines whether or not a command supports
     --stop flag
+    childopnames is a list of other opnames this op uses as sub-steps of its
+    own execution. They must already be added.
     cmdmsg is used to pass a different status message in case standard
     message of the format "abort: cmdname in progress" is not desired.
     cmdhint is used to pass a different hint message in case standard
@@ -230,6 +241,7 b' def addunfinished('
     continuefunc stores the function required to finish an interrupted
     operation.
     """
+    childopnames = childopnames or []
     statecheckobj = _statecheck(
         opname,
         fname,
@@ -238,17 +250,98 b' def addunfinished('
         reportonly,
         continueflag,
         stopflag,
+        childopnames,
         cmdmsg,
         cmdhint,
         statushint,
         abortfunc,
         continuefunc,
     )
+
     if opname == b'merge':
         _unfinishedstates.append(statecheckobj)
     else:
+        # This check enforces that for any op 'foo' which depends on op 'bar',
+        # 'foo' comes before 'bar' in _unfinishedstates. This ensures that
+        # getrepostate() always returns the most specific applicable answer.
+        for childopname in childopnames:
+            if childopname not in _unfinishedstatesbyname:
+                raise error.ProgrammingError(
+                    _(b'op %s depends on unknown op %s') % (opname, childopname)
+                )
+
         _unfinishedstates.insert(0, statecheckobj)
 
+    if opname in _unfinishedstatesbyname:
+        raise error.ProgrammingError(_(b'op %s registered twice') % opname)
+    _unfinishedstatesbyname[opname] = statecheckobj
+
+
+def _getparentandchild(opname, childopname):
+    p = _unfinishedstatesbyname.get(opname, None)
+    if not p:
+        raise error.ProgrammingError(_(b'unknown op %s') % opname)
+    if childopname not in p._childopnames:
+        raise error.ProgrammingError(
+            _(b'op %s does not delegate to %s') % (opname, childopname)
+        )
+    c = _unfinishedstatesbyname[childopname]
+    return p, c
+
+
[e-mail]
+def delegating(repo, opname, childopname):
+    """context wrapper for delegations from opname to childopname.
+
+    requires that childopname was specified when opname was registered.
+
+    Usage:
+      def my_command_foo_that_uses_rebase(...):
+        ...
+        with state.delegating(repo, 'foo', 'rebase'):
+          _run_rebase(...)
+        ...
+    """
+
+    p, c = _getparentandchild(opname, childopname)
+    if p._delegating:
+        raise error.ProgrammingError(
+            _(b'cannot delegate from op %s recursively') % opname
+        )
+    p._delegating = True
+    try:
+        yield
+    except error.ConflictResolutionRequired as e:
+        # Rewrite conflict resolution advice for the parent opname.
+        if e.opname == childopname:
+            raise error.ConflictResolutionRequired(opname)
+        raise e
+    finally:
+        p._delegating = False
+
+
+def ischildunfinished(repo, opname, childopname):
+    """Returns true if both opname and childopname are unfinished."""
+
+    p, c = _getparentandchild(opname, childopname)
+    return (p._delegating or p.isunfinished(repo)) and c.isunfinished(repo)
+
+
+def continuechild(ui, repo, opname, childopname):
+    """Checks that childopname is in progress, and continues it."""
+
+    p, c = _getparentandchild(opname, childopname)
+    if not ischildunfinished(repo, opname, childopname):
+        raise error.ProgrammingError(
+            _(b'child op %s of parent %s is not unfinished')
+            % (childopname, opname)
+        )
+    if not c.continuefunc:
+        raise error.ProgrammingError(
+            _(b'op %s has no continue function') % childopname
+        )
+    return c.continuefunc(ui, repo)
+
 
 addunfinished(
     b'update',