168             result = buildstate(repo, destf, srcf, basef, detachf)

   168 

   169             if not destf:

   170                 # Destination defaults to the latest revision in the current branch

   171                 branch = repo[None].branch()

   172                 dest = repo[branch]

   173             else:

   174                 dest = repo[destf]

   175 

   176             if srcf:

   177                 revsetargs = ('(%s)::', srcf)

   178             else:

   179                 base = basef or '.'

   180                 revsetargs = ('(children(ancestor(%s, %d)) and ::(%s))::',

   181                              base, dest, base)

   182 

   183             rebaseset = [c.rev() for c in repo.set(*revsetargs)]

   184             if rebaseset:

   185                 result = buildstate(repo, dest, rebaseset, detachf)

   186             else:

   187                 repo.ui.debug(_('base is ancestor of destination'))

   188                 result = None

   510 def buildstate(repo, dest, src, base, detach):

   530 def buildstate(repo, dest, rebaseset, detach):

   511     'Define which revisions are going to be rebased and where'

   531     '''Define which revisions are going to be rebased and where

   512     targetancestors = set()

   532 

   513     detachset = set()

   533     repo: repo

   514 

   534     dest: context

   515     if not dest:

   535     rebaseset: set of rev

   516         # Destination defaults to the latest revision in the current branch

   536     detach: boolean'''

   517         branch = repo[None].branch()

   518         dest = repo[branch].rev()

   519     else:

   520         dest = repo[dest].rev()

   525     if 'qtip' in repo.tags() and (repo[dest].node() in

   541     if 'qtip' in repo.tags() and (dest.node() in

   529     if src:

   545     detachset = set()

   530         commonbase = repo[src].ancestor(repo[dest])

   546     roots = list(repo.set('roots(%ld)', rebaseset))

   531         if commonbase == repo[src]:

   547     if not roots:

   532             raise util.Abort(_('source is ancestor of destination'))

   548         raise util.Abort( _('no matching revisions'))

   533         if commonbase == repo[dest]:

   549     if len(roots) > 1:

   534             samebranch = repo[src].branch() == repo[dest].branch()

   550         raise util.Abort( _("can't rebase multiple roots"))

   535             if samebranch and repo[src] in repo[dest].children():

   551     root = roots[0]

   536                 raise util.Abort(_('source is a child of destination'))

   552 

   537             # rebase on ancestor, force detach

   553     commonbase = root.ancestor(dest)

   538             detach = True

   554     if commonbase == root:

   539         source = repo[src].rev()

   555         raise util.Abort(_('source is ancestor of destination'))

   540         if detach:

   556     if commonbase == dest:

   541             # We need to keep track of source's ancestors up to the common base

   557         samebranch = root.branch() == dest.branch()

   542             srcancestors = set(repo.changelog.ancestors(source))

   558         if samebranch and root in dest.children():

   543             baseancestors = set(repo.changelog.ancestors(commonbase.rev()))

   559            repo.ui.debug(_('source is a child of destination'))

   544             detachset = srcancestors - baseancestors

   560            return None

   545             detachset.discard(commonbase.rev())

   561         # rebase on ancestor, force detach

   546     else:

   562         detach = True

   547         if base:

   563     if detach:

   548             cwd = repo[base].rev()

   564         detachset = [c.rev() for c in repo.set('::%d - ::%d - %d',

   549         else:

   565                                                 root, commonbase, root)]

   550             cwd = repo['.'].rev()

   566 

   551 

   567     repo.ui.debug('rebase onto %d starting from %d\n' % (dest, root))

   552         if cwd == dest:

   568     state = dict.fromkeys(rebaseset, nullrev)

   553             repo.ui.debug('source and destination are the same\n')

   554             return None

   555 

   556         targetancestors = set(repo.changelog.ancestors(dest))

   557         if cwd in targetancestors:

   558             repo.ui.debug('source is ancestor of destination\n')

   559             return None

   560 

   561         cwdancestors = set(repo.changelog.ancestors(cwd))

   562         if dest in cwdancestors:

   563             repo.ui.debug('source is descendant of destination\n')

   564             return None

   565 

   566         cwdancestors.add(cwd)

   567         rebasingbranch = cwdancestors - targetancestors

   568         source = min(rebasingbranch)

   569 

   570     repo.ui.debug('rebase onto %d starting from %d\n' % (dest, source))

   571     state = dict.fromkeys(repo.changelog.descendants(source), nullrev)

   573     state[source] = nullrev

   570     return repo['.'].rev(), dest.rev(), state

   574     return repo['.'].rev(), repo[dest].rev(), state