shelve: add utility to abort current transaction but keep dirstate

"hg shelve" and "hg unshelve" use aborting a current transaction to
discard temporary changes while (un)shelving.

This assumes that dirstate changes in a transaction scope are kept
even after aborting it. But this assumption will be broken by
"transactional dirstate". See the wiki page below for detail about it.

    https://mercurial.selenic.com/wiki/DirstateTransactionPlan

This patch adds utility function "_aborttransaction()" to abort
current transaction but keep dirstate changes for (un)shelving.

'dirstate.invalidate()' just after aborting a transaction should be
removed soon by subsequent patch, which writes or discards in-memory
dirstate changes at releasing transaction according to the result of
it.

BTW, there are some other ways below, which (seem to, at first glance)
resolve this issue. But this patch chose straightforward way for ease
of review and future refactorring.

  - commit transaction at first, and then rollback it

    It causes unintentional "dirty read" of running transaction to
    other processes at committing it.

  - use dirstateguard to save and restore shelved dirstate

    After DirstateTransactionPlan, making 'dirstate.write()' write
    in-memory changes into actual file requires
    'transaction.writepending()' while transaction running.

    It causes meaningless writing other in-memory changes out, even
    though they are never referred.

    In addition to it, it isn't desirable that scope of dirstateguard
    and transaction intersects each other.

  - get list of files changed from the parent, keep it in memory, and
    emulate that changes after aborting transaction

    This additional memory consumption may block aborting transaction
    in large repository (on small resource environment).

hgext/shelve.py

@@ -190,6 +190,35 @@ def cleanupoldbackups(repo):
                 if err.errno != errno.ENOENT:
                     raise
 
+def _aborttransaction(repo):
+    '''Abort current transaction for shelve/unshelve, but keep dirstate
+    '''
+    backupname = 'dirstate.shelve'
+    dirstatebackup = None
+    try:
+        # create backup of (un)shelved dirstate, because aborting transaction
+        # should restore dirstate to one at the beginning of the
+        # transaction, which doesn't include the result of (un)shelving
+        fp = repo.vfs.open(backupname, "w")
+        dirstatebackup = backupname
+        # clearing _dirty/_dirtypl of dirstate by _writedirstate below
+        # is unintentional. but it doesn't cause problem in this case,
+        # because no code path refers them until transaction is aborted.
+        repo.dirstate._writedirstate(fp) # write in-memory changes forcibly
+
+        tr = repo.currenttransaction()
+        tr.abort()
+
+        # TODO: this should be done via transaction.abort()
+        repo.dirstate.invalidate() # prevent wlock from writing changes out
+
+        # restore to backuped dirstate
+        repo.vfs.rename(dirstatebackup, 'dirstate')
+        dirstatebackup = None
+    finally:
+        if dirstatebackup:
+            repo.vfs.unlink(dirstatebackup)
+
 def createcmd(ui, repo, pats, opts):
     """subcommand that creates a new shelve"""