+ def _stoprebase(self):
+ """stop the interrupted rebase"""
+ self.restorestatus()
+ if not self.stateobj.exists():
+ raise error.Abort(_("no interrupted rebase found"))
+ allowunstable = obsolete.isenabled(self.repo, obsolete.allowunstableopt)
+ if not (self.keepf or allowunstable):
+ raise error.Abort(_("can't remove original changesets with"
+ " unrebased descendants"),
+ hint=_('either enable evolve extension to allow unstable '
+ 'revisions or use --keep to keep original changesets'))
+
+ # update to the last rebased node if any
+ ctx = self.repo[None]
+ pars = [p.node() for p in ctx.parents()]
+ p1 = pars[0]
+ hg.updaterepo(self.repo, p1, overwrite=True)

Perhaps this differs from what a successful rebase would do. Unlike graft,
hg rebase goes back to the original working directory.

+ # either mark obsolete or keep rebased revisions
+ repo, ui, opts = self.repo, self.ui, self.opts
+ fm = ui.formatter('rebase', opts)
+ fm.startitem()
+ clearrebased(ui, repo, self.destmap, self.state, self.skipped,
+ collapsedas=None, keepf=self.keepf, fm=fm)
+ clearstatus(self.repo)
+ fm.end()
+ return 0

I doubt if this would work with --collapse. Can you try writing some tests?

I'm not pretty sure, but it might be possible to utilize _finishrebase()
to implement --stop, roughly by:

1. restore status
2. drop revisions that aren't rebased yet
3. finish it

+ elif stop:
+ #todo: raise error for conflicting options

Yes!

In D3959#61670, @yuja wrote:

+ def _stoprebase(self):
+ """stop the interrupted rebase"""
+ self.restorestatus()
+ if not self.stateobj.exists():
+ raise error.Abort(_("no interrupted rebase found"))
+ allowunstable = obsolete.isenabled(self.repo, obsolete.allowunstableopt)
+ if not (self.keepf or allowunstable):
+ raise error.Abort(_("can't remove original changesets with"
+ " unrebased descendants"),
+ hint=_('either enable evolve extension to allow unstable '
+ 'revisions or use --keep to keep original changesets'))
+
+ # update to the last rebased node if any
+ ctx = self.repo[None]
+ pars = [p.node() for p in ctx.parents()]
+ p1 = pars[0]
+ hg.updaterepo(self.repo, p1, overwrite=True)

Perhaps this differs from what a successful rebase would do. Unlike graft,
hg rebase goes back to the original working directory.

right, will change it.

+ # either mark obsolete or keep rebased revisions
+ repo, ui, opts = self.repo, self.ui, self.opts
+ fm = ui.formatter('rebase', opts)
+ fm.startitem()
+ clearrebased(ui, repo, self.destmap, self.state, self.skipped,
+ collapsedas=None, keepf=self.keepf, fm=fm)
+ clearstatus(self.repo)
+ fm.end()
+ return 0

I doubt if this would work with --collapse. Can you try writing some tests?

What is the expected behaviour in case of --collapse? Should it collapse only those revisions which are rebased, then we may have to ask user to change commit message accordingly.

I'm not pretty sure, but it might be possible to utilize _finishrebase()
to implement --stop, roughly by:

1. restore status
2. drop revisions that aren't rebased yet
3. finish it

yeah, trying to do it in _finishrebase()

+ elif stop:
+ #todo: raise error for conflicting options

Yes!

> I doubt if this would work with --collapse. Can you try writing some tests?
What is the expected behaviour in case of --collapse? Should it collapse only those revisions which are rebased, then we may have to ask user to change commit message accordingly.

No idea. Perhaps we can revisit it later by making hg rebase --stop just
abort if it was a --collapse session.

Excellent! I like the feature and this has been on my TODO for long. Thanks for coding this up. You also need to take care of bookmark movements. Bookmark from changesets which have successfully rebased should be moved to their successors when we call --stop.

@pulkit I will send a follow up which will take care of bookmarks movement. Thanks for review!

In D3959#61803, @pulkit wrote:

You also need to take care of bookmark movements. Bookmark from changesets which have successfully rebased should be moved to their successors when we call --stop.

@pulkit
I think bookmarks movement is already handled by clearrebased() function. I going to send a patch to reflect this behaviour. Correct me if I am missing something.

• def _finishrebase(self):

+ def _finishrebase(self, stoprebase=False):

repo, ui, opts = self.repo, self.ui, self.opts
fm = ui.formatter('rebase', opts)
fm.startitem()

+ if stoprebase:
+ self.restorestatus()
+ if self.collapsef:
+ ui.status(_("cannot stop in --collapse session\n"))
+ return

raise Abort because it's an error?

+
+ allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt)
+ if not (self.keepf or allowunstable):
+ raise error.Abort(_("can't remove original changesets with"
+ " unrebased descendants"),
+ hint=_('either enable obsmarkers to allow unstable '
+ 'revisions or use --keep to keep original '
+ 'changesets'))

It will be nice if we can move the pre-process out from _finishrebase(),
and get rid of the stoprebase flag somehow.

if self.collapsef:
    p1, p2, _base = defineparents(repo, min(self.state), self.destmap,
                                  self.state, self.skipped,

@@ -626,7 +640,10 @@

    newwd = self.originalwd
if newwd not in [c.rev() for c in repo[None].parents()]:
    ui.note(_("update back to initial working directory parent\n"))

• hg.updaterepo(repo, newwd, overwrite=False)

+ if stoprebase:
+ hg.updaterepo(repo, newwd, overwrite=True)
+ else:
+ hg.updaterepo(repo, newwd, overwrite=False)

This implies an interrupted merge won't be cleared if no update is required.
(try hg up 3 && hg rebase -s 1 -d 5 in the first test you've added.)

Perhaps the rebase --stop flow can be processed as follows?

rbsrt = rebaseruntime(repo, ui)
rbsrt.restorestatus()
... check unsupported options ...
with repo.wlock(), repo.lock():
    if needupdate(repo, state):
        .. update to the current working revision with overwrite=True
        .. to clear interrupted merge
    rbsrt._finishrebase()

Queued, many thanks.

+ elif stop:
+ rbsrt = rebaseruntime(repo, ui)
+ rbsrt.restorestatus()

Perhaps restorestatus() needs to be covered by the lock to prevent it from
being updated by another process. Can you send a follow up?